@bendyline/gilde 0.1.37 → 0.1.39

package/data/craftbook-templates/re/research-to-document/versions/1.2.2/test.json

@@ -0,0 +1,243 @@
+{
+  "schemaVersion": 1,
+  "title": "Word Document DocBlocks artifact-surface eval",
+  "objective": "Verify the research-to-document craftbook carries a reviewed Markdown source all the way to a real editable DOCX in the ARTIFACTS drawer via the DocBlocks template route (list_templates / describe_template / convert_document / preview_document / save_artifact) — the surface and tool family powerpoint-deck's workspace-copy route does not cover.",
+  "tags": [
+    "external",
+    "documents"
+  ],
+  "prompt": "Read `source/brief.md` and publish a Word document.\n\n1. Write the complete document source to `report.md`: a title, executive summary, compact metrics table, findings, and next actions. Do not create HTML or document XML by hand.\n2. Publish it with the pre-authorized DocBlocks tools. Call `list_roots` to find the read-enabled workspace root and the write-enabled artifacts root. Call `list_templates` and `describe_template` to choose a document template and follow its section expectations. Then `convert_document` to DOCX, `preview_document` to confirm it rendered, and `save_artifact` to persist it to `tasks/eval/report.docx` in the artifacts drawer.\n\nThe finished deliverable is the real DOCX at `tasks/eval/report.docx` in the artifacts drawer. Markdown, HTML, or hand-built OOXML written to that path is not a substitute.",
+  "setup": {
+    "projectName": "Word Document from Content Eval",
+    "about": "The reviewed source is Markdown and is converted to an editable DOCX by DocBlocks. The finished document lands in the project ARTIFACTS drawer, not the workspace.",
+    "missionObjectives": "Create a complete, source-grounded report.md, then convert and save it as a real artifacts-drawer tasks/eval/report.docx through the DocBlocks template route.",
+    "files": [
+      {
+        "path": "source/brief.md",
+        "content": "# Boreal Desk Returns Pilot\n\nAudience: operations leaders.\n\nFacts:\n- Pilot coverage: 18 SKUs.\n- Median first response improved from 18 hours to 6 hours.\n- Preventable refund leakage fell from 14.2% to 8.9%.\n- Top unresolved complaint: status silence after photo submission.\n- Next actions: automated status emails, barcode-exception training, weekly Finance exception export.\n\nDo not invent other metrics."
+      }
+    ],
+    "worker": {
+      "name": "Jules",
+      "role": "Copywriter"
+    },
+    "craftbookParams": {
+      "workPath": "tasks/eval"
+    }
+  },
+  "mocks": [
+    {
+      "kind": "mcp",
+      "id": "docblocks",
+      "toolsetId": "docblocks",
+      "description": "Deterministic fake DocBlocks MCP for template selection, DOCX conversion, preview, and artifact-drawer saving.",
+      "tools": [
+        {
+          "name": "list_roots",
+          "description": "List the workspace read root and artifacts write root.",
+          "resultTemplate": {
+            "roots": [
+              {
+                "id": "workspace",
+                "name": "workspace",
+                "capabilities": [
+                  "read"
+                ]
+              },
+              {
+                "id": "artifacts",
+                "name": "artifacts",
+                "capabilities": [
+                  "read",
+                  "write"
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "name": "get_authoring_context",
+          "description": "Return optional DOCX authoring guidance.",
+          "resultTemplate": {
+            "targetFormat": "docx",
+            "guidance": "Content-first Markdown; one H1 title, H2 sections, real tables."
+          }
+        },
+        {
+          "name": "list_templates",
+          "description": "List the document templates available for DOCX conversion.",
+          "resultTemplate": {
+            "templates": [
+              {
+                "id": "briefing-report",
+                "label": "Briefing report",
+                "formats": [
+                  "docx",
+                  "pdf"
+                ]
+              },
+              {
+                "id": "one-pager",
+                "label": "Executive one-pager",
+                "formats": [
+                  "docx"
+                ]
+              },
+              {
+                "id": "slide-notes",
+                "label": "Slide notes",
+                "formats": [
+                  "pptx"
+                ]
+              }
+            ]
+          }
+        },
+        {
+          "name": "describe_template",
+          "description": "Describe a template's expected sections and styles.",
+          "resultTemplate": {
+            "id": "briefing-report",
+            "sections": [
+              "Title",
+              "Executive summary",
+              "Metrics",
+              "Findings",
+              "Next actions"
+            ],
+            "styles": {
+              "heading": "Heading 1",
+              "table": "Grid Table 4"
+            }
+          }
+        },
+        {
+          "name": "convert_document",
+          "description": "Convert approved Markdown to a deterministic DOCX artifact URI.",
+          "resultTemplate": {
+            "artifacts": [
+              {
+                "format": "docx",
+                "uri": "mock://docblocks/report.docx",
+                "sha256": "3333333333333333333333333333333333333333333333333333333333333333"
+              }
+            ],
+            "diagnostics": []
+          }
+        },
+        {
+          "name": "preview_document",
+          "description": "Return deterministic page-preview evidence.",
+          "resultTemplate": {
+            "pages": 4,
+            "overflow": false,
+            "missingStyles": [],
+            "previewed": true
+          }
+        },
+        {
+          "name": "save_artifact",
+          "description": "Save the converted DOCX into the project artifacts drawer.",
+          "resultTemplate": {
+            "ok": true,
+            "bytes": 2100,
+            "sha256": "4444444444444444444444444444444444444444444444444444444444444444"
+          },
+          "writeFixture": {
+            "surface": "artifact",
+            "pathArgument": "destination.path",
+            "fixture": "minimal-docx"
+          }
+        }
+      ]
+    }
+  ],
+  "success": {
+    "summary": "report.md is a complete source-grounded Markdown document, and artifacts/report.docx is a real ZIP-shaped DOCX produced through the DocBlocks template route rather than written by hand.",
+    "deliverables": [
+      {
+        "path": "report.md",
+        "kind": "markdown-report",
+        "minBytes": 1000,
+        "checks": [
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "(?:^|\\n)#\\s+.+",
+            "flags": "m"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "executive summary",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "18\\s+SKUs|18\\s+hours|6\\s+hours|14\\.2%|8\\.9%",
+            "flags": "i"
+          },
+          {
+            "kind": "contains",
+            "file": "report.md",
+            "pattern": "automated status emails|barcode-exception training|weekly Finance exception export",
+            "flags": "i"
+          },
+          {
+            "kind": "notContains",
+            "file": "report.md",
+            "pattern": "<html|<style|word/document\\.xml|base64",
+            "flags": "i"
+          }
+        ]
+      }
+    ],
+    "mocks": [
+      {
+        "service": "docblocks",
+        "requiredTools": [
+          "list_roots",
+          "list_templates",
+          "describe_template",
+          "convert_document",
+          "preview_document",
+          "save_artifact"
+        ]
+      }
+    ],
+    "checks": [
+      {
+        "kind": "binaryDocument",
+        "file": "tasks/eval/report.docx",
+        "artifact": true,
+        "minBytes": 800
+      }
+    ]
+  },
+  "rubric": {
+    "artifact": {
+      "path": "report.md",
+      "kind": "markdown"
+    },
+    "axes": [
+      {
+        "name": "grounding",
+        "description": "Every metric and action comes from the seeded brief."
+      },
+      {
+        "name": "structure",
+        "description": "The source has a usable title, summary, sections, table, and next actions."
+      },
+      {
+        "name": "convertibility",
+        "description": "The Markdown is complete enough for direct DocBlocks DOCX conversion without HTML or XML."
+      }
+    ]
+  },
+  "qualityFocus": [
+    "Markdown source quality",
+    "DOCX readiness",
+    "no HTML or OOXML intermediary"
+  ]
+}

package/data/craftbook-templates/re/rest-api/versions/1.0.3/craftbook.json

@@ -0,0 +1,159 @@
+{
+  "id": "rest-api",
+  "name": "REST API Service",
+  "description": "Build a RESTful HTTP API service with resource endpoints, JSON request/response bodies, status codes, validation, and error handling. Locks the contract FIRST — resources, routes, verbs, request/response shapes, status-code map, auth, and pagination — so the implementation has a fixed target, then builds the server, then writes endpoint tests that exercise every route and error case. Covers CRUD endpoints, RESTful routing, OpenAPI-style contract, HTTP status codes, input validation, JSON serialization, and integration tests against the running handler.\n\nA gallery craftbook generated from an archetype spec. It runs\n`phase → (per-phase gate) → … → evaluate → (loop) → finish`. Each build\nphase that produces a checkable artifact is followed by a **runtime\ngate-checkpoint** — the runtime verifies the artifact and routes with no\nmodel turn, looping back to redo the phase on a miss. The final `evaluate`\nstep holds a static deliverable gate plus a reviewer QA pass. What it adds\nover the generic `build-loop`: a specialist role per phase, a\ndomain-correct ordering, and a concrete per-phase quality bar.\n\nDeliverables marked \"artifact\" land in the project's artifacts drawer (`write_artifact` / `read_artifact`), not the shipped workspace — review output is not product source.\n\nPhases:\n\n1. Contract design (planner) — lock resources, routes, request/response shapes, status codes → gated on artifact `{{workPath}}/contract-design.md` (markdown-notes)\n2. Build the service (developer) — implement the server to the locked contract → gated on `src/server.js` (code-module)\n3. Write endpoint tests (developer) — test every route, status code, and error path → gated on `src/server.test.js` (code-with-tests)\n\nThe gates never advance with an unmet criterion, and loop back to the\nowning phase to fix named gaps.\n",
+  "entryStepId": "contract-design",
+  "triggers": [
+    "build a rest api",
+    "create an http api",
+    "crud endpoints",
+    "make a backend api",
+    "json api service"
+  ],
+  "steps": [
+    {
+      "id": "contract-design",
+      "name": "Contract design",
+      "description": "lock resources, routes, request/response shapes, status codes",
+      "prompt": "Design the API contract before any server code. Step 1: List the resources (nouns) the API exposes and the operations on each. Step 2: For every endpoint write the exact method + path (e.g. `GET /users/:id`, `POST /users`), with no base path/version prefix unless the source brief explicitly requires one, plus the request body/query shape, the success response shape and status code, and the error responses with their status codes (400 validation, 404 missing, 409 conflict, 401/403 auth). Step 3: Decide cross-cutting rules: content-type (`application/json`), pagination scheme for list endpoints, auth mechanism (or none), and the canonical error envelope (e.g. `{ error: { code, message } }`). Step 4: Write a numbered acceptance-criteria checklist of 5-9 concrete, testable items (e.g. 'POST /users with valid body returns 201 + the created resource with an id', 'GET on a missing id returns 404 with the error envelope', 'a malformed body returns 400, never 500'). Step 5: `write_task_note` the full contract table + the checklist, and write the same to the produces path. No implementation yet.\n\nThe deliverable `{{workPath}}/contract-design.md` lands in the project's artifacts drawer — write it with `write_artifact` and read it back with `read_artifact`; the shipped workspace stays untouched.",
+      "suggestedRole": "planner",
+      "advanceWhen": {
+        "file": "{{workPath}}/contract-design.md",
+        "minBytes": 1,
+        "sniff": "nonempty",
+        "artifact": true
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "{{workPath}}/contract-design.md",
+            "bytes": 120,
+            "artifact": true
+          },
+          {
+            "kind": "sniff",
+            "file": "{{workPath}}/contract-design.md",
+            "sniff": "nonempty",
+            "artifact": true
+          }
+        ],
+        "onReject": "contract-design",
+        "maxAttempts": 3
+      },
+      "next": "build"
+    },
+    {
+      "id": "build",
+      "name": "Build the service",
+      "description": "implement the server to the locked contract",
+      "prompt": "Implement the API server in a single runnable source file that satisfies the contract exactly. Step 1: Wire a minimal HTTP server/router (standard library or the project's framework) with one handler per endpoint from the contract. If using Node built-ins, use a normal top-level import such as `import http from \"node:http\"` or `import { createServer } from \"node:http\"`; do not hide standard-library imports behind dynamic `await import()` inside a synchronous factory. Step 2: Parse and VALIDATE every request body/param before acting; on invalid input return the 400 error envelope, never let it reach a 500. Step 3: Return the exact status codes and response shapes the contract specifies, with `Content-Type: application/json`; after writing any auth, validation, not-found, or success response, immediately `return` so the handler cannot write headers twice. Step 4: Implement the error envelope and a catch-all so unexpected errors return a clean 500 with the envelope, not a stack trace. Use an in-memory store if no DB was specified. On a loop-back, fix only the gaps the reviewer named — do not regress passing routes. `write_task_note` the file path and which criteria now pass.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "src/server.js",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "src/server.js",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "src/server.js",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "src/server.js"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "src/server.js"
+          }
+        ],
+        "onReject": "build",
+        "maxAttempts": 3
+      },
+      "next": "test"
+    },
+    {
+      "id": "test",
+      "name": "Write endpoint tests",
+      "description": "test every route, status code, and error path",
+      "prompt": "Write integration tests that exercise the running handler against every acceptance criterion. Step 1: For each endpoint, assert the happy path: correct status code AND response shape. Step 2: Assert each error path the contract names — 400 on bad input, 404 on missing, 401/403 on auth, 409 on conflict. Step 3: Assert the error envelope shape is consistent across all error responses. Step 4: Include at least one round-trip test (create then read back) to prove state is wired. For self-contained Node HTTP tests, start the server on `listen(0)`, read the assigned port from `server.address().port`, use built-in `fetch`, and close the server in `finally`. Make the tests runnable and self-contained. `write_task_note` the test file path and the pass/fail count.",
+      "suggestedRole": "developer",
+      "advanceWhen": {
+        "file": "src/server.test.js",
+        "minBytes": 1,
+        "sniff": "nonempty"
+      },
+      "gate": {
+        "at": "completion",
+        "checks": [
+          {
+            "kind": "minBytes",
+            "file": "src/server.js",
+            "bytes": 200
+          },
+          {
+            "kind": "sniff",
+            "file": "src/server.js",
+            "sniff": "nonempty"
+          },
+          {
+            "kind": "esmImports",
+            "file": "src/server.js"
+          },
+          {
+            "kind": "sourceParses",
+            "file": "src/server.js"
+          }
+        ],
+        "onReject": "test",
+        "maxAttempts": 4
+      },
+      "next": "evaluate"
+    },
+    {
+      "id": "evaluate",
+      "name": "Evaluate",
+      "description": "Grade the deliverable against every acceptance criterion. All pass → finish; any fail → loop back and fix the gap.",
+      "prompt": "Run the test suite and exercise the API. For EACH acceptance criterion: confirm the endpoint returns the documented status code and response shape, confirm every error path returns the correct code with the error envelope (and never a raw 500/stack trace on bad input), and confirm at least one create→read round-trip works. Write PASS/FAIL per criterion with the offending route on any FAIL.\n\nThen route — this is the whole point of the loop:\n\n- **Every criterion PASSES →** call `advance_task_step({ ref, stepId: \"evaluate\", next: \"finish\" })`.\n- **Any criterion FAILS →** write the specific gaps to notes, then call `advance_task_step({ ref, stepId: \"evaluate\", next: \"build\" })` to loop back. The builder fixes exactly those gaps.\n\nNever route to `finish` while any criterion is unmet. The build phase's completion gate already blocked a grossly-incomplete deliverable; your job is the judgment an automated check cannot make (does it actually work, read well, look right). After ~3 unproductive loops, stop and report DONE_WITH_CONCERNS so the user can step in.",
+      "suggestedRole": "reviewer",
+      "consumes": [
+        {
+          "file": "src/server.js"
+        }
+      ],
+      "next": "build"
+    },
+    {
+      "id": "finish",
+      "name": "Finish",
+      "description": "All acceptance criteria met. Stamp a short summary and report DONE.",
+      "prompt": "Every acceptance criterion passed. Write a one-paragraph DONE summary to task notes via `write_task_note`: what was built, the deliverable path(s), and a one-line confirmation that each criterion is met. Then report DONE.",
+      "suggestedRole": "developer",
+      "terminal": true
+    }
+  ],
+  "version": "1.0.3",
+  "releasedAt": "2026-08-21T00:00:00Z",
+  "paramSchema": {
+    "type": "object",
+    "properties": {
+      "workPath": {
+        "type": "string",
+        "title": "Working folder",
+        "description": "Per-task working folder in the artifacts drawer. Defaults to this task's own folder so runs never collide; override with a stable name when you deliberately want runs to share files.",
+        "default": "{{task.dir}}"
+      }
+    }
+  },
+  "minGezelVersion": "1.26233"
+}