brainfile 0.19.0 → 0.21.0

package/dist/mcp/helpers.js

@@ -37,10 +37,12 @@ exports.resolveBrainfile = resolveBrainfile;
 exports.requireV2 = requireV2;
 exports.mcpStructuredError = mcpStructuredError;
 exports.findGitRoot = findGitRoot;
+exports.withBoardCommit = withBoardCommit;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const core_1 = require("@brainfile/core");
 const v2_only_1 = require("../utils/v2-only");
+const board_autosync_1 = require("../utils/board-autosync");
 function resolveBrainfile(filePath) {
     return path.resolve(filePath);
 }
@@ -56,6 +58,9 @@ function requireV2(filePath) {
     if (!(0, core_1.isV2)(resolvedPath)) {
         return { content: [{ type: 'text', text: `Error: ${v2_only_1.V1_UNSUPPORTED_MESSAGE}` }], isError: true };
     }
+    // A shared board in autosync=full mode fetches before stale reads.
+    (0, board_autosync_1.installAutosync)();
+    (0, board_autosync_1.fetchBeforeRead)(path.dirname(resolvedPath));
     return null;
 }
 function mcpStructuredError(message, field, value) {
@@ -85,4 +90,43 @@ function findGitRoot(startDir) {
     }
     return null;
 }
+// ── Board-on-a-branch (spec-9): one commit per mutating tool call ─────────
+const board_repo_1 = require("../utils/board-repo");
+function isErrorResult(result) {
+    return typeof result === 'object' && result !== null && result.isError === true;
+}
+function describeToolCall(toolName, input) {
+    const action = typeof input.action === 'string' ? ` ${input.action}` : '';
+    const rawId = input.taskId ?? input.task;
+    const id = Array.isArray(rawId) ? ` ${rawId.join(',')}` : typeof rawId === 'string' ? ` ${rawId}` : '';
+    const detail = [input.title, input.column]
+        .find((v) => typeof v === 'string' && v.length > 0);
+    return `${toolName}${action}${id}${detail ? `: ${detail}` : ''}`;
+}
+/**
+ * Wrap a mutating tool handler so a successful call commits the board when it
+ * is tracked. A failed commit never fails the tool. The acting agent comes
+ * from `BRAINFILE_AGENT`, which the MCP host sets per agent.
+ */
+function withBoardCommit(toolName, defaultFile, handler) {
+    return async (input, extra) => {
+        const result = await handler(input, extra);
+        try {
+            if (!isErrorResult(result)) {
+                const filePath = typeof input.file === 'string' && input.file ? input.file : defaultFile;
+                const dotDir = path.dirname(resolveBrainfile(filePath));
+                if ((0, board_repo_1.isTrackedBoard)(dotDir)) {
+                    (0, board_repo_1.commitBoard)(dotDir, {
+                        message: describeToolCall(toolName, input),
+                        agent: process.env.BRAINFILE_AGENT ?? null,
+                    });
+                }
+            }
+        }
+        catch {
+            /* recording is best-effort */
+        }
+        return result;
+    };
+}
 //# sourceMappingURL=helpers.js.map

package/dist/mcp/helpers.js.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/mcp/helpers.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,4CAEC;AAMD,8BAYC;AAED,gDAYC;AAKD,kCAeC;AA/DD,uCAAyB;AACzB,2CAA6B;AAC7B,0CAAuC;AACvC,8CAA0D;AAM1D,SAAgB,gBAAgB,CAAC,QAAgB;IAC/C,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;AAChC,CAAC;AAED;;;GAGG;AACH,SAAgB,SAAS,CAAC,QAAgB;IACxC,MAAM,YAAY,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAEhD,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;QACjC,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,0BAA0B,YAAY,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IACjH,CAAC;IAED,IAAI,CAAC,IAAA,WAAI,EAAC,YAAY,CAAC,EAAE,CAAC;QACxB,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,IAAI,EAAE,MAAe,EAAE,IAAI,EAAE,UAAU,gCAAsB,EAAE,EAAE,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,CAAC;IAC3G,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED,SAAgB,kBAAkB,CAAC,OAAe,EAAE,KAAa,EAAE,KAAa;IAC9E,OAAO;QACL,OAAO,EAAE,CAAC;gBACR,IAAI,EAAE,MAAe;gBACrB,IAAI,EAAE,IAAI,CAAC,SAAS,CAClB,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,kBAAkB,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,EAC9D,IAAI,EACJ,CAAC,CACF;aACF,CAAC;QACF,OAAO,EAAE,IAAI;KACd,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,WAAW,CAAC,QAAgB;IAC1C,IAAI,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;IACxC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC;IAEzC,OAAO,UAAU,KAAK,IAAI,EAAE,CAAC;QAC3B,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;QAC9C,IAAI,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;YAC3B,OAAO,UAAU,CAAC;QACpB,CAAC;QACD,MAAM,SAAS,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QAC3C,IAAI,SAAS,KAAK,UAAU;YAAE,MAAM;QACpC,UAAU,GAAG,SAAS,CAAC;IACzB,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../src/mcp/helpers.ts"],"names":[],"mappings":"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"}

package/dist/mcp/schemas.d.ts

@@ -0,0 +1,297 @@
+/**
+ * Output schemas for the 11 consolidated MCP tools.
+ *
+ * Each tool declares one of these as `outputSchema`, and every non-error
+ * success path returns the matching object as `structuredContent` alongside
+ * the `content` text block it already emitted. The text block is never
+ * removed, so clients that read only `content` are unaffected.
+ *
+ * Three SDK behaviours (v2.0.0) shape everything here — all verified against
+ * the installed `@modelcontextprotocol/server` runtime:
+ *
+ * 1. Declaring `outputSchema` makes `structuredContent` MANDATORY on every
+ *    result that is not `isError: true`. `McpServer.validateToolOutput`
+ *    throws `Output validation error: … no structured content was provided`
+ *    otherwise. Adding a schema to a tool therefore means auditing *every*
+ *    success `return` in that tool, not just the main one.
+ *
+ * 2. Output validation is SKIPPED when `isError: true`, so error paths need
+ *    neither `structuredContent` nor schema conformance. Error returns are
+ *    left exactly as they were.
+ *
+ * 3. Root shape decides whether the two protocol eras agree. The 2025-era
+ *    wire codec re-wraps `structuredContent` as `{result: …}` whenever the
+ *    ADVERTISED schema root is not `type: "object"`, while the 2026-era codec
+ *    is identity — so a non-object root would hand the two eras different
+ *    bytes. Unions are still safe: the SDK's `standardSchemaToJsonSchema`
+ *    injects `type: "object"` for any `oneOf`/`anyOf` whose members are all
+ *    object-shaped (`isProvablyObjectShapedRoot`). Every union below is a
+ *    union of objects for exactly that reason — adding a non-object member
+ *    (a bare `z.string()`, say) would silently split the eras apart.
+ *
+ * Enum-ish fields that originate in hand-editable YAML (notably `priority`)
+ * are typed `z.string()` rather than `z.enum([...])`. A board carrying
+ * `priority: urgent` would otherwise fail output validation and turn a
+ * working call into an error result.
+ */
+import { z } from 'zod';
+export declare const listTasksOutputSchema: z.ZodObject<{
+    tasks: z.ZodArray<z.ZodObject<{
+        column: z.ZodString;
+        id: z.ZodString;
+        title: z.ZodString;
+        priority: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        assignee: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    count: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * `get_task` spreads the raw `Task`, whose TypeScript type carries an open
+ * `[key: string]: unknown` index signature so extension fields (`x-otto`,
+ * `x-cursor`, …) round-trip. Modelled with `z.looseObject` so the advertised
+ * JSON Schema says `additionalProperties: {}` instead of `false` — a closed
+ * object would advertise those extension fields as illegal.
+ *
+ * `id` and `title` are required because `parseTaskContent` returns null for
+ * any task file missing either, so a task that reached this point has both.
+ * `column` is always set by the handler.
+ */
+export declare const getTaskOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    column: z.ZodString;
+    type: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodOptional<z.ZodString>;
+    dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blockedBy: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    relatedFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    assignee: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    priority: z.ZodOptional<z.ZodString>;
+    dueDate: z.ZodOptional<z.ZodString>;
+    subtasks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        completed: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>>;
+    contract: z.ZodOptional<z.ZodObject<{}, z.core.$loose>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+    completedAt: z.ZodOptional<z.ZodString>;
+    position: z.ZodOptional<z.ZodNumber>;
+    archived: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$loose>;
+/**
+ * Three genuinely different payloads selected by which input was supplied.
+ * The variants' required-field sets don't overlap (`isLog` scalar vs `logs`
+ * array vs `results` array), so an untagged union discriminates structurally
+ * and no payload had to change to add a tag.
+ */
+export declare const searchOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
+    isLog: z.ZodBoolean;
+    description: z.ZodOptional<z.ZodString>;
+    log: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    logs: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        completedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    count: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    results: z.ZodArray<z.ZodObject<{
+        column: z.ZodOptional<z.ZodString>;
+        score: z.ZodNumber;
+        isLog: z.ZodOptional<z.ZodBoolean>;
+        id: z.ZodString;
+        title: z.ZodString;
+        priority: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        assignee: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    count: z.ZodNumber;
+}, z.core.$strip>]>;
+/** New payload: `task_add` previously returned only a prose confirmation. */
+export declare const taskAddOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    title: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Both tools branch their TEXT on single-vs-batch, but the structured payload
+ * is always the batch shape (a one-element `results` array for a single move),
+ * so agents parse one shape regardless of how many IDs they passed.
+ */
+export declare const taskMoveOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    successCount: z.ZodNumber;
+    failureCount: z.ZodNumber;
+    results: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        success: z.ZodBoolean;
+        message: z.ZodOptional<z.ZodString>;
+        warning: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const taskPatchOutputSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    successCount: z.ZodNumber;
+    failureCount: z.ZodNumber;
+    results: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        success: z.ZodBoolean;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** New payload: `task_delete` previously returned only a prose confirmation. */
+export declare const taskDeleteOutputSchema: z.ZodObject<{
+    id: z.ZodString;
+    deleted: z.ZodLiteral<true>;
+}, z.core.$strip>;
+/**
+ * `toggle` and `update` both key their payload `updated` but carry different
+ * item shapes (`{id, completed}` vs `{id, title}`), which is ambiguous without
+ * a tag. The tool's own `action` input is echoed into the output to
+ * discriminate — an added field, nothing renamed.
+ *
+ * The singular paths (which used to emit prose only) now emit the same plural
+ * array shape, so item count never changes the structure.
+ */
+export declare const subtaskOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"add">;
+    added: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>>;
+    count: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"delete">;
+    deleted: z.ZodArray<z.ZodString>;
+    missing: z.ZodArray<z.ZodString>;
+    count: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"toggle">;
+    updated: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        completed: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    count: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"update">;
+    updated: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+    }, z.core.$strip>>;
+    count: z.ZodNumber;
+}, z.core.$strip>], "action">;
+/**
+ * Six heterogeneous actions, tagged by the `action` input the caller already
+ * supplied. `pickup`'s payload is genuinely free-text agent-context markdown,
+ * so its variant is deliberately thin — an output schema does not have to
+ * invent structure that the payload does not have.
+ */
+export declare const contractOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    action: z.ZodLiteral<"attach">;
+    task: z.ZodString;
+    status: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"pickup">;
+    task: z.ZodString;
+    markdown: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"deliver">;
+    task: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"validate">;
+    ok: z.ZodBoolean;
+    status: z.ZodString;
+    deliverables: z.ZodArray<z.ZodObject<{
+        deliverable: z.ZodObject<{
+            type: z.ZodOptional<z.ZodString>;
+            path: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>;
+        ok: z.ZodBoolean;
+        resolvedPath: z.ZodOptional<z.ZodString>;
+        error: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    commands: z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        exitCode: z.ZodNumber;
+        stdout: z.ZodString;
+        stderr: z.ZodString;
+    }, z.core.$loose>>;
+    warnings: z.ZodArray<z.ZodObject<{
+        command: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"graph">;
+    attached: z.ZodArray<z.ZodString>;
+    count: z.ZodNumber;
+    order: z.ZodArray<z.ZodString>;
+    graph: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"activate">;
+    activated: z.ZodArray<z.ZodString>;
+    count: z.ZodNumber;
+}, z.core.$strip>], "action">;
+/**
+ * New payload: every success path previously returned prose only, with the
+ * interesting values (`completedAt`, issue number/id, issue URL) interpolated
+ * into the message. They are now also returned as real fields.
+ *
+ * Tagged by the `destination` input. The default path (no `destination`) and
+ * `destination: 'local'` share the `local` variant and are told apart by
+ * `archived`.
+ */
+export declare const taskCompleteOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    destination: z.ZodLiteral<"local">;
+    taskId: z.ZodString;
+    completedAt: z.ZodOptional<z.ZodString>;
+    archived: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    destination: z.ZodLiteral<"github">;
+    taskId: z.ZodString;
+    issueNumber: z.ZodOptional<z.ZodNumber>;
+    issueUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    destination: z.ZodLiteral<"linear">;
+    taskId: z.ZodString;
+    issueId: z.ZodOptional<z.ZodString>;
+    issueUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "destination">;
+/**
+ * `brief` — per-agent attention digest.
+ *
+ * Object root (not a bare array of lanes) so both protocol eras hand clients
+ * identical bytes, per note 3 above. `lastBriefAt` is nullable rather than
+ * optional: "this agent has never briefed" is a meaningful state a client must
+ * be able to distinguish from an omitted field.
+ */
+export declare const briefOutputSchema: z.ZodObject<{
+    agent: z.ZodString;
+    mode: z.ZodEnum<{
+        full: "full";
+        delta: "delta";
+    }>;
+    generatedAt: z.ZodString;
+    lastBriefAt: z.ZodNullable<z.ZodString>;
+    peek: z.ZodBoolean;
+    lanes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        items: z.ZodArray<z.ZodObject<{
+            taskId: z.ZodOptional<z.ZodString>;
+            text: z.ZodString;
+            why: z.ZodString;
+            at: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/mcp/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/mcp/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAwBxB,eAAO,MAAM,qBAAqB;;;;;;;;;;iBAGhC,CAAC;AAIH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;iBAqB9B,CAAC;AAmCH;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;mBAI7B,CAAC;AAIH,6EAA6E;AAC7E,eAAO,MAAM,mBAAmB;;;iBAG9B,CAAC;AAIH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;iBAW/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;iBAShC,CAAC;AAIH,gFAAgF;AAChF,eAAO,MAAM,sBAAsB;;;iBAGjC,CAAC;AAIH;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;6BAsB9B,CAAC;AAaH;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAgD/B,CAAC;AAIH;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;kCAmBnC,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;iBAgB5B,CAAC"}