v1.1.0: Fix API endpoints and implement update/delete commands

- Fix GetDocument to use /blocks?id= endpoint instead of /documents/{id}
- Fix SearchDocuments to use 'include' parameter instead of 'query'
- Fix CreateDocument to wrap request in {"documents":[...]} format
- Implement UpdateDocument using POST /blocks with position.pageId
- Implement DeleteDocument using DELETE /blocks with blockIds
- Add Block and BlocksResponse models for blocks API
- Add SearchItem model and search result output functions
- Update all tests for new API behavior

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: nerveband

cmd/output.go

@@ -245,3 +245,49 @@ func outputDeleted(docID string) {
 		fmt.Printf("Document %s deleted successfully\n", docID)
 	}
 }
+
+// outputSearchResults prints search results in the specified format
+func outputSearchResults(items []models.SearchItem, format string) error {
+	switch format {
+	case "json":
+		return outputJSON(items)
+	case "table":
+		return outputSearchTable(items)
+	case "markdown":
+		return outputSearchMarkdown(items)
+	default:
+		return fmt.Errorf("unsupported format: %s", format)
+	}
+}
+
+// outputSearchTable prints search results as a table
+func outputSearchTable(items []models.SearchItem) error {
+	w := tabwriter.NewWriter(os.Stdout, 0, 0, 2, ' ', 0)
+
+	if !hasNoHeaders() {
+		fmt.Fprintln(w, "DOCUMENT ID\tMATCH")
+		fmt.Fprintln(w, "-----------\t-----")
+	}
+
+	for _, item := range items {
+		match := item.Markdown
+		// Clean up the markdown snippet for display
+		match = strings.ReplaceAll(match, "\n", " ")
+		if len(match) > 80 {
+			match = match[:77] + "..."
+		}
+		fmt.Fprintf(w, "%s\t%s\n", item.DocumentID, match)
+	}
+
+	return w.Flush()
+}
+
+// outputSearchMarkdown prints search results as markdown
+func outputSearchMarkdown(items []models.SearchItem) error {
+	fmt.Println("# Search Results")
+	for _, item := range items {
+		fmt.Printf("## Document: %s\n", item.DocumentID)
+		fmt.Printf("%s\n\n", item.Markdown)
+	}
+	return nil
+}

cmd/root.go

@@ -22,7 +22,7 @@ var (
 	apiURL      string
 	outputFormat string
 	cfgManager  *config.Manager
-	version     = "1.0.0"
+	version     = "1.1.0"
 
 	// Global flags for LLM/scripting friendliness
 	quietMode   bool

cmd/search.go

@@ -22,7 +22,7 @@ var searchCmd = &cobra.Command{
 		}
 
 		format := getOutputFormat()
-		return outputDocuments(result.Items, format)
+		return outputSearchResults(result.Items, format)
 	},
 }
 

internal/api/client.go

@@ -7,6 +7,7 @@ import (
 	"io"
 	"net/http"
 	"net/url"
+	"strings"
 	"time"
 
 	"github.com/ashrafali/craft-cli/internal/models"
@@ -108,25 +109,62 @@ func (c *Client) GetDocuments() (*models.DocumentList, error) {
 	return &result, nil
 }
 
-// GetDocument retrieves a single document by ID
+// GetDocument retrieves a single document by ID using the blocks endpoint
 func (c *Client) GetDocument(id string) (*models.Document, error) {
-	path := fmt.Sprintf("/documents/%s", id)
+	path := fmt.Sprintf("/blocks?id=%s", url.QueryEscape(id))
 	data, err := c.doRequest("GET", path, nil)
 	if err != nil {
 		return nil, err
 	}
 
-	var doc models.Document
-	if err := json.Unmarshal(data, &doc); err != nil {
+	var blocksResp models.BlocksResponse
+	if err := json.Unmarshal(data, &blocksResp); err != nil {
 		return nil, fmt.Errorf("invalid response from API: %w", err)
 	}
 
-	return &doc, nil
+	// Combine markdown from all blocks
+	markdown := combineBlocksMarkdown(blocksResp)
+
+	doc := &models.Document{
+		ID:       blocksResp.ID,
+		Title:    blocksResp.Markdown,
+		Markdown: markdown,
+	}
+
+	return doc, nil
+}
+
+// combineBlocksMarkdown extracts and combines markdown from all blocks
+func combineBlocksMarkdown(resp models.BlocksResponse) string {
+	var parts []string
+
+	// Add the document title/header
+	if resp.Markdown != "" {
+		parts = append(parts, "# "+resp.Markdown)
+	}
+
+	// Recursively collect markdown from all content blocks
+	for _, block := range resp.Content {
+		collectBlockMarkdown(&block, &parts)
+	}
+
+	return strings.Join(parts, "\n\n")
+}
+
+// collectBlockMarkdown recursively collects markdown from a block and its children
+func collectBlockMarkdown(block *models.Block, parts *[]string) {
+	if block.Markdown != "" {
+		*parts = append(*parts, block.Markdown)
+	}
+	for _, child := range block.Content {
+		collectBlockMarkdown(&child, parts)
+	}
 }
 
 // SearchDocuments searches for documents matching a query
 func (c *Client) SearchDocuments(query string) (*models.SearchResult, error) {
-	path := fmt.Sprintf("/documents/search?query=%s", url.QueryEscape(query))
+	// Craft API uses 'include' parameter instead of 'query'
+	path := fmt.Sprintf("/documents/search?include=%s", url.QueryEscape(query))
 	data, err := c.doRequest("GET", path, nil)
 	if err != nil {
 		return nil, err
@@ -140,40 +178,195 @@ func (c *Client) SearchDocuments(query string) (*models.SearchResult, error) {
 	return &result, nil
 }
 
+// createDocumentsRequest wraps documents for the API
+type createDocumentsRequest struct {
+	Documents []models.CreateDocumentRequest `json:"documents"`
+}
+
+// createDocumentsResponse represents the API response for document creation
+type createDocumentsResponse struct {
+	Items []struct {
+		ID    string `json:"id"`
+		Title string `json:"title"`
+	} `json:"items"`
+}
+
 // CreateDocument creates a new document
 func (c *Client) CreateDocument(req *models.CreateDocumentRequest) (*models.Document, error) {
-	data, err := c.doRequest("POST", "/documents", req)
+	// Craft API expects {"documents": [...]} wrapper
+	wrapper := createDocumentsRequest{
+		Documents: []models.CreateDocumentRequest{*req},
+	}
+
+	data, err := c.doRequest("POST", "/documents", wrapper)
 	if err != nil {
 		return nil, err
 	}
 
-	var doc models.Document
-	if err := json.Unmarshal(data, &doc); err != nil {
+	var resp createDocumentsResponse
+	if err := json.Unmarshal(data, &resp); err != nil {
 		return nil, fmt.Errorf("invalid response from API: %w", err)
 	}
 
-	return &doc, nil
+	if len(resp.Items) == 0 {
+		return nil, fmt.Errorf("no document returned from API")
+	}
+
+	doc := &models.Document{
+		ID:    resp.Items[0].ID,
+		Title: resp.Items[0].Title,
+	}
+
+	return doc, nil
 }
 
-// UpdateDocument updates an existing document
+// blockPosition specifies where to insert a block
+type blockPosition struct {
+	PageID   string `json:"pageId"`
+	Position string `json:"position"` // "start", "end", or block ID
+}
+
+// addBlockRequest is the request body for adding blocks
+type addBlockRequest struct {
+	Markdown string        `json:"markdown"`
+	Position blockPosition `json:"position"`
+}
+
+// addBlockResponse is the response from adding blocks
+type addBlockResponse struct {
+	Items []struct {
+		ID       string `json:"id"`
+		Type     string `json:"type"`
+		Markdown string `json:"markdown"`
+	} `json:"items"`
+}
+
+// UpdateDocument updates an existing document by adding content
+// Note: The Craft Connect API only supports adding content blocks, not updating title or replacing content
 func (c *Client) UpdateDocument(id string, req *models.UpdateDocumentRequest) (*models.Document, error) {
-	path := fmt.Sprintf("/documents/%s", id)
-	data, err := c.doRequest("PUT", path, req)
+	// Title updates are not supported via the API
+	if req.Title != "" && req.Markdown == "" {
+		return nil, fmt.Errorf("the Craft Connect API does not support title updates. Use the Craft app to rename documents")
+	}
+
+	if req.Markdown == "" {
+		return nil, fmt.Errorf("markdown content is required for updates")
+	}
+
+	// Add content blocks to the document
+	addReq := addBlockRequest{
+		Markdown: req.Markdown,
+		Position: blockPosition{
+			PageID:   id,
+			Position: "end",
+		},
+	}
+
+	data, err := c.doRequest("POST", "/blocks", addReq)
 	if err != nil {
 		return nil, err
 	}
 
-	var doc models.Document
-	if err := json.Unmarshal(data, &doc); err != nil {
+	var resp addBlockResponse
+	if err := json.Unmarshal(data, &resp); err != nil {
 		return nil, fmt.Errorf("invalid response from API: %w", err)
 	}
 
-	return &doc, nil
+	// Return a document with the update info
+	doc := &models.Document{
+		ID: id,
+	}
+
+	// If title was also requested, note it in return
+	if req.Title != "" {
+		doc.Title = req.Title + " (title not updated - API limitation)"
+	}
+
+	// Set markdown to confirm what was added
+	if len(resp.Items) > 0 {
+		doc.Markdown = resp.Items[0].Markdown
+	}
+
+	return doc, nil
+}
+
+// deleteBlocksRequest is the request body for deleting blocks
+type deleteBlocksRequest struct {
+	BlockIDs []string `json:"blockIds"`
+}
+
+// deleteBlocksResponse is the response from deleting blocks
+type deleteBlocksResponse struct {
+	Items []struct {
+		ID string `json:"id"`
+	} `json:"items"`
 }
 
 // DeleteDocument deletes a document by ID
+// Note: The Craft Connect API does not support deleting root page blocks (documents)
+// This will attempt to delete all content blocks within the document
 func (c *Client) DeleteDocument(id string) error {
-	path := fmt.Sprintf("/documents/%s", id)
-	_, err := c.doRequest("DELETE", path, nil)
-	return err
+	// First, get the document to find all its content blocks
+	doc, err := c.GetDocument(id)
+	if err != nil {
+		return fmt.Errorf("failed to get document: %w", err)
+	}
+
+	// Get the blocks again to get block IDs
+	path := fmt.Sprintf("/blocks?id=%s", url.QueryEscape(id))
+	data, err := c.doRequest("GET", path, nil)
+	if err != nil {
+		return fmt.Errorf("failed to get document blocks: %w", err)
+	}
+
+	var blocksResp models.BlocksResponse
+	if err := json.Unmarshal(data, &blocksResp); err != nil {
+		return fmt.Errorf("invalid response from API: %w", err)
+	}
+
+	// Collect all content block IDs (not the root page)
+	var blockIDs []string
+	for _, block := range blocksResp.Content {
+		collectBlockIDs(&block, &blockIDs)
+	}
+
+	if len(blockIDs) == 0 {
+		return fmt.Errorf("the Craft Connect API cannot delete documents (only content blocks). Document '%s' has no deletable content blocks", doc.Title)
+	}
+
+	// Delete the content blocks
+	deleteReq := deleteBlocksRequest{
+		BlockIDs: blockIDs,
+	}
+
+	_, err = c.doRequest("DELETE", "/blocks", deleteReq)
+	if err != nil {
+		return fmt.Errorf("failed to delete blocks: %w", err)
+	}
+
+	return nil
+}
+
+// collectBlockIDs recursively collects all block IDs
+func collectBlockIDs(block *models.Block, ids *[]string) {
+	if block.ID != "" {
+		*ids = append(*ids, block.ID)
+	}
+	for _, child := range block.Content {
+		collectBlockIDs(&child, ids)
+	}
+}
+
+// DeleteBlock deletes a specific block by ID
+func (c *Client) DeleteBlock(blockID string) error {
+	deleteReq := deleteBlocksRequest{
+		BlockIDs: []string{blockID},
+	}
+
+	_, err := c.doRequest("DELETE", "/blocks", deleteReq)
+	if err != nil {
+		return fmt.Errorf("failed to delete block: %w", err)
+	}
+
+	return nil
 }