@documentation-robotics/cli 0.1.13 → 0.3.0

package/dist/mcp/tools/changeset-editing.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/changeset-editing.ts"],
+  "sourcesContent": ["/**\n * changeset_update, changeset_unstage, changeset_discard \u2014 revise a staged changeset while\n * planning a change. Mirror `dr changeset unstage|discard` and add the rename / re-describe step\n * the CLI has no command for, all through StagingAreaManager.\n *\n * Every mutation reloads the cached model afterwards, like changeset-lifecycle.ts: the model\n * projects the active changeset's elements at load time, and the projection cache is keyed by\n * what is staged.\n *\n * Commit and apply stay off the MCP surface (landing a change is the human's step). Discard is\n * exposed because an agent must be able to abandon its own plan, but it clears the staged changes\n * for good, so it needs `confirm: true`. See docs/CHANGE_MODELING.md.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { ChangesetGraph } from \"../../core/changeset-graph.js\";\nimport type { Changeset, StagedChange } from \"../../core/changeset.js\";\nimport { StagingAreaManager } from \"../../core/staging-area.js\";\nimport { stagedRelationshipChangesAtEnds, stagedRelationshipTriple } from \"../../core/relationship-staging.js\";\nimport { CLIError, ErrorCategory, getErrorMessage } from \"../../utils/errors.js\";\nimport { jsonResult, loadModel, reloadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\nimport { resolveChangeset } from \"./changeset-shared.js\";\n\nconst changesetIdSchema = z\n  .string()\n  .optional()\n  .describe(\"Changeset ID or name. Defaults to the active changeset.\");\n\nfunction requireStaged(changeset: Changeset, action: string): void {\n  if (changeset.status !== \"staged\") {\n    throw new CLIError(`Changeset '${changeset.name}' is ${changeset.status}; cannot ${action}`, ErrorCategory.USER, [\n      'Use \"changeset_list\" to find a staged changeset, or \"changeset_create\" to start a new one',\n    ]);\n  }\n}\n\n/** Wraps a StagingAreaManager error (plain Error) as a user error the agent can act on. */\nasync function asUserError<T>(fn: () => Promise<T>, suggestions: string[]): Promise<T> {\n  try {\n    return await fn();\n  } catch (error) {\n    if (error instanceof CLIError) throw error;\n    throw new CLIError(getErrorMessage(error), ErrorCategory.USER, suggestions);\n  }\n}\n\nfunction summarize(change: StagedChange): Record<string, unknown> {\n  const triple = change.type.startsWith(\"relationship-\") ? stagedRelationshipTriple(change) : null;\n  return {\n    type: change.type,\n    elementId: change.elementId,\n    layer: change.layerName,\n    ...(triple ? { relationship: triple } : {}),\n  };\n}\n\n// ---------------------------------------------------------------------------\n// changeset_update\n// ---------------------------------------------------------------------------\n\nconst updateInputSchema = {\n  changesetId: changesetIdSchema,\n  name: z.string().min(1).optional().describe(\"New name. Must not be another changeset's name.\"),\n  description: z\n    .string()\n    .optional()\n    .describe(\"New description: the change's intent and what done looks like. An empty string clears it.\"),\n  rootPath: rootPathSchema,\n};\n\nexport type ChangesetUpdateArgs = z.infer<z.ZodObject<typeof updateInputSchema>>;\n\nexport async function changesetUpdateHandler(args: ChangesetUpdateArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    if (args.name === undefined && args.description === undefined) {\n      throw new CLIError(\"Nothing to update\", ErrorCategory.USER, ['Pass \"name\" and/or \"description\"']);\n    }\n    const model = await loadModel(args.rootPath);\n    const manager = new StagingAreaManager(model.rootPath, model);\n    const changeset = await resolveChangeset(manager, args.changesetId);\n\n    const updated = await asUserError(\n      () => manager.update(changeset.id!, { name: args.name, description: args.description }),\n      ['Use \"changeset_list\" to see the names already taken']\n    );\n    await reloadModel(args.rootPath);\n\n    return jsonResult({\n      id: updated.id,\n      name: updated.name,\n      ...(changeset.name !== updated.name ? { previousName: changeset.name } : {}),\n      description: updated.description ?? null,\n      status: updated.status,\n      changes: updated.changes.length,\n    });\n  });\n}\n\nexport const changesetUpdateTool: McpToolDefinition<typeof updateInputSchema> = {\n  name: \"changeset_update\",\n  description:\n    \"Rename a changeset or change its description (the change's intent). Staged changes are untouched. \" +\n    \"Defaults to the active changeset.\",\n  inputSchema: updateInputSchema,\n  handler: changesetUpdateHandler,\n};\n\n// ---------------------------------------------------------------------------\n// changeset_unstage\n// ---------------------------------------------------------------------------\n\nconst unstageInputSchema = {\n  changesetId: changesetIdSchema,\n  elementId: z\n    .string()\n    .optional()\n    .describe(\"Drop every staged change to this element (its add, updates or delete). ID or path.\"),\n  source: z\n    .string()\n    .optional()\n    .describe(\n      \"Drop staged relationship changes (adds and deletes) from this element: to target when given, otherwise to \" +\n        \"any element. The element's own changes are not touched.\"\n    ),\n  target: z\n    .string()\n    .optional()\n    .describe(\n      \"Drop staged relationship changes (adds and deletes) to this element: from source when given, otherwise from \" +\n        \"any element. The element's own changes are not touched.\"\n    ),\n  predicate: z.string().optional().describe(\"Only relationship changes with this predicate. Omit for any.\"),\n  keepRelationships: z\n    .boolean()\n    .optional()\n    .describe(\n      \"With elementId: keep the staged relationship changes that depend on the element's change. By default, \" +\n        \"unstaging an element's add also drops staged relationships to it (they would dangle), and unstaging its \" +\n        \"delete also drops the relationship removals its cascade staged (removals staged before the delete are kept).\"\n    ),\n  rootPath: rootPathSchema,\n};\n\nexport type ChangesetUnstageArgs = z.infer<z.ZodObject<typeof unstageInputSchema>>;\n\nfunction describeEnds(args: { source?: string; target?: string }): string {\n  if (args.source && args.target) return `from ${args.source} to ${args.target}`;\n  return args.source ? `from ${args.source}` : `to ${args.target}`;\n}\n\nexport async function changesetUnstageHandler(args: ChangesetUnstageArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const byElement = args.elementId !== undefined;\n    const byRelationship = args.source !== undefined || args.target !== undefined;\n    if (byElement === byRelationship) {\n      throw new CLIError(\"Name either an element or a relationship to unstage\", ErrorCategory.USER, [\n        'Pass \"elementId\" to drop an element\\'s staged changes',\n        'Or pass \"source\" and/or \"target\" (and optionally \"predicate\") to drop staged relationship changes',\n      ]);\n    }\n    if (byRelationship && !args.source && !args.target) {\n      throw new CLIError('\"source\" or \"target\" must not be empty', ErrorCategory.USER);\n    }\n\n    const model = await loadModel(args.rootPath);\n    const manager = new StagingAreaManager(model.rootPath, model);\n    const changeset = await resolveChangeset(manager, args.changesetId);\n    requireStaged(changeset, \"unstage changes\");\n    const graph = await ChangesetGraph.build(model, changeset);\n    const changes = changeset.changes as StagedChange[];\n\n    const keys = new Set<string>();\n    const notes: string[] = [];\n\n    if (byElement) {\n      const element = graph.getElement(args.elementId!);\n      const ids = new Set([args.elementId!, ...(element ? [element.id, element.uuid ?? element.id] : [])]);\n      const own = changes.filter((c) => !c.type.startsWith(\"relationship-\") && ids.has(c.elementId));\n      for (const change of own) keys.add(change.elementId);\n\n      // Relationship changes that only make sense with the element's change.\n      const dependentType = own.some((c) => c.type === \"add\")\n        ? \"relationship-add\"\n        : own.some((c) => c.type === \"delete\")\n          ? \"relationship-delete\"\n          : null;\n      const touching = dependentType\n        ? changes.filter((c) => {\n            if (c.type !== dependentType) return false;\n            const triple = stagedRelationshipTriple(c);\n            return (\n              !!triple &&\n              (ids.has(triple.source) ||\n                ids.has(triple.target) ||\n                (element && (graph.resolve(triple.source) === element.id || graph.resolve(triple.target) === element.id)))\n            );\n          })\n        : [];\n      // A delete cascades into relationship removals staged right after it. Removals staged before the\n      // delete were the agent's own decisions, not the cascade's, so they stay.\n      const seq = (c: StagedChange): number => c.sequenceNumber ?? changes.indexOf(c);\n      const deleteSeqs = own.filter((c) => c.type === \"delete\").map(seq);\n      const firstDelete = deleteSeqs.length > 0 ? Math.min(...deleteSeqs) : -1;\n      const dependent =\n        dependentType === \"relationship-delete\" ? touching.filter((c) => seq(c) > firstDelete) : touching;\n      const deliberate = touching.filter((c) => !dependent.includes(c));\n      if (deliberate.length > 0) {\n        notes.push(\n          `${deliberate.length} relationship removal(s) on ${args.elementId} staged before its delete were kept ` +\n            `(${deliberate.map((c) => c.elementId).join(\", \")}); unstage them by source and target if they should go too`\n        );\n      }\n      if (dependent.length > 0) {\n        if (args.keepRelationships) {\n          notes.push(\n            `${dependent.length} staged relationship change(s) on ${args.elementId} were kept (keepRelationships)` +\n              (dependentType === \"relationship-add\" ? \"; they will dangle unless the element is staged again\" : \"\")\n          );\n        } else {\n          for (const change of dependent) keys.add(change.elementId);\n        }\n      }\n    } else {\n      const matched = stagedRelationshipChangesAtEnds(graph, changeset, {\n        source: args.source || undefined,\n        target: args.target || undefined,\n        predicate: args.predicate,\n      });\n      // A relationship removal staged after the delete of one of its ends is that delete's cascade:\n      // without it the deleted element's relationship dangles and the changeset no longer commits.\n      const seq = (c: StagedChange): number => c.sequenceNumber ?? changes.indexOf(c);\n      const deleteSeq = new Map<string, number>();\n      for (const change of changes) {\n        if (change.type !== \"delete\") continue;\n        const id = graph.resolve(change.elementId);\n        deleteSeq.set(id, Math.min(deleteSeq.get(id) ?? Infinity, seq(change)));\n      }\n      const deletedEndOf = (change: StagedChange): string | undefined => {\n        if (change.type !== \"relationship-delete\") return undefined;\n        const triple = stagedRelationshipTriple(change);\n        if (!triple) return undefined;\n        return [graph.resolve(triple.source), graph.resolve(triple.target)].find(\n          (end) => deleteSeq.has(end) && deleteSeq.get(end)! < seq(change)\n        );\n      };\n      const cascaded = matched.filter((c) => deletedEndOf(c) !== undefined);\n      const deletedEnds = [...new Set(cascaded.map((c) => deletedEndOf(c)!))].join(\", \");\n      const cascadeList = cascaded.map((c) => c.elementId).join(\", \");\n      // One end sweeps every relationship there, so it leaves a delete's cascade alone. Naming both\n      // ends asks for those relationships specifically, so they go, with a warning.\n      const bothEnds = !!args.source && !!args.target;\n      for (const change of matched) {\n        if (!bothEnds && cascaded.includes(change)) continue;\n        keys.add(change.elementId);\n      }\n      if (cascaded.length > 0 && bothEnds) {\n        notes.push(\n          `Unstaged ${cascaded.length} relationship removal(s) cascaded from the staged delete of ${deletedEnds} ` +\n            `(${cascadeList}): those relationships now dangle, so the changeset will not commit until they are ` +\n            `removed again or the delete is unstaged (\"changeset_unstage\" with elementId)`\n        );\n      } else if (cascaded.length > 0) {\n        notes.push(\n          `Kept ${cascaded.length} relationship removal(s) cascaded from the staged delete of ${deletedEnds} ` +\n            `(${cascadeList}): dropping them would leave those relationships dangling. Unstage the delete ` +\n            `(\"changeset_unstage\" with elementId) to restore them, or name both source and target to drop one anyway`\n        );\n      }\n    }\n\n    const removed = changes.filter((c) => keys.has(c.elementId));\n    if (removed.length === 0) {\n      return jsonResult({\n        status: \"not-staged\",\n        changeset: changeset.name,\n        message: byElement\n          ? `No staged change to ${args.elementId} in '${changeset.name}'`\n          : `No staged relationship change ${describeEnds(args)}` +\n            `${args.predicate ? ` (${args.predicate})` : \"\"} in '${changeset.name}'`,\n        suggestions: ['Use \"changeset_show\" to list the staged changes'],\n        ...(notes.length > 0 ? { notes } : {}),\n      });\n    }\n\n    for (const key of keys) {\n      await manager.unstage(changeset.id!, key);\n    }\n    await reloadModel(args.rootPath);\n\n    return jsonResult({\n      status: \"unstaged\",\n      changeset: changeset.name,\n      unstaged: removed.map(summarize),\n      remainingChanges: changes.length - removed.length,\n      ...(notes.length > 0 ? { notes } : {}),\n    });\n  });\n}\n\nexport const changesetUnstageTool: McpToolDefinition<typeof unstageInputSchema> = {\n  name: \"changeset_unstage\",\n  description:\n    \"Undo part of a staged changeset: drop the staged changes to one element (elementId), or the staged \" +\n    \"relationship adds/deletes between source and target, or every one from source alone or to target alone \" +\n    \"(optionally one predicate). The base model is not touched. \" +\n    \"Defaults to the active changeset. Use changeset_show to see what is staged.\",\n  inputSchema: unstageInputSchema,\n  handler: changesetUnstageHandler,\n};\n\n// ---------------------------------------------------------------------------\n// changeset_discard\n// ---------------------------------------------------------------------------\n\nconst discardInputSchema = {\n  changesetId: z.string().describe(\"Changeset ID or name to discard. Required: discard is never implied.\"),\n  confirm: z\n    .boolean()\n    .describe(\n      \"Must be true. Discarding deletes the changeset's staged changes permanently (only its name, description and \" +\n        \"a 'discarded' status remain), so confirm only when the plan is to be abandoned.\"\n    ),\n  rootPath: rootPathSchema,\n};\n\nexport type ChangesetDiscardArgs = z.infer<z.ZodObject<typeof discardInputSchema>>;\n\nexport async function changesetDiscardHandler(args: ChangesetDiscardArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const manager = new StagingAreaManager(model.rootPath, model);\n    const changeset = await resolveChangeset(manager, args.changesetId);\n    requireStaged(changeset, \"discard it\");\n\n    if (args.confirm !== true) {\n      throw new CLIError(\n        `Discarding '${changeset.name}' deletes its ${changeset.changes.length} staged change(s) permanently`,\n        ErrorCategory.USER,\n        [\n          'Pass \"confirm\": true to discard it',\n          'Use \"changeset_unstage\" to drop individual changes instead',\n          'Use \"changeset_deactivate\" to stop staging into it and keep its changes',\n        ]\n      );\n    }\n\n    const wasActive = (await manager.getActiveId()) === changeset.id;\n    const discardedChanges = changeset.changes.length;\n    await manager.discard(changeset.id!);\n    if (wasActive) {\n      await manager.clearActive();\n    }\n    await reloadModel(args.rootPath);\n\n    return jsonResult({\n      id: changeset.id,\n      name: changeset.name,\n      status: \"discarded\",\n      discardedChanges,\n      deactivated: wasActive,\n    });\n  });\n}\n\nexport const changesetDiscardTool: McpToolDefinition<typeof discardInputSchema> = {\n  name: \"changeset_discard\",\n  description:\n    \"Abandon a staged changeset: PERMANENTLY deletes its staged changes and marks it discarded (deactivating it if \" +\n    \"active). Not recoverable, so it requires confirm: true. The base model is not touched. To undo part of a \" +\n    \"plan use changeset_unstage; to pause it use changeset_deactivate.\",\n  inputSchema: discardInputSchema,\n  handler: changesetDiscardHandler,\n};\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/mcp/tools/changeset-lifecycle.js

@@ -0,0 +1,83 @@
+import { z } from "zod";
+import { StagingAreaManager } from "../../core/staging-area.js";
+import { CLIError, ErrorCategory } from "../../utils/errors.js";
+import { jsonResult, loadModel, reloadModel, rootPathSchema, runTool } from "./shared.js";
+import { resolveChangeset } from "./changeset-shared.js";
+const createInputSchema = {
+  name: z.string().min(1).describe("Short name for the change, e.g. 'add-order-export'."),
+  description: z.string().optional().describe("The change's intent: what it is for and what done looks like. Shown to the human reviewing it."),
+  activate: z.boolean().optional().describe("Make it the active changeset so mutations stage into it (default true)."),
+  rootPath: rootPathSchema
+};
+async function changesetCreateHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), manager = new StagingAreaManager(model.rootPath, model);
+    if (await manager.load(args.name))
+      throw new CLIError(`Changeset '${args.name}' already exists`, ErrorCategory.USER, [
+        `Use "changeset_activate" with "${args.name}" to continue it`,
+        "Or choose another name"
+      ]);
+    const changeset = await manager.create(args.name, args.description), activate = args.activate ?? !0, previouslyActive = activate ? await manager.getActiveId() : null;
+    return activate && (await manager.setActive(changeset.id), await reloadModel(args.rootPath)), jsonResult({
+      id: changeset.id,
+      name: changeset.name,
+      ...changeset.description ? { description: changeset.description } : {},
+      status: changeset.status,
+      active: activate,
+      ...previouslyActive && previouslyActive !== changeset.id ? { deactivated: previouslyActive } : {}
+    });
+  });
+}
+const changesetCreateTool = {
+  name: "changeset_create",
+  description: "Start planning a change: create a changeset carrying the change's intent and (by default) activate it, so model_add / model_update / model_delete / relationship_add / relationship_delete stage into it instead of writing the model. The human commits it later; it is never committed over MCP.",
+  inputSchema: createInputSchema,
+  handler: changesetCreateHandler
+}, activateInputSchema = {
+  changesetId: z.string().describe("Changeset ID or name."),
+  rootPath: rootPathSchema
+};
+async function changesetActivateHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), manager = new StagingAreaManager(model.rootPath, model), changeset = await resolveChangeset(manager, args.changesetId);
+    if (changeset.status !== "staged")
+      throw new CLIError(`Changeset '${changeset.name}' is ${changeset.status} and cannot accept changes`, ErrorCategory.USER, ['Use "changeset_create" to start a new one']);
+    const previouslyActive = await manager.getActiveId();
+    return await manager.setActive(changeset.id), await reloadModel(args.rootPath), jsonResult({
+      id: changeset.id,
+      name: changeset.name,
+      active: !0,
+      changes: changeset.changes.length,
+      ...previouslyActive && previouslyActive !== changeset.id ? { deactivated: previouslyActive } : {}
+    });
+  });
+}
+const changesetActivateTool = {
+  name: "changeset_activate",
+  description: "Make an existing staged changeset the active one, so mutations stage into it.",
+  inputSchema: activateInputSchema,
+  handler: changesetActivateHandler
+}, deactivateInputSchema = {
+  rootPath: rootPathSchema
+};
+async function changesetDeactivateHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), manager = new StagingAreaManager(model.rootPath, model), activeId = await manager.getActiveId();
+    return activeId && (await manager.clearActive(), await reloadModel(args.rootPath)), jsonResult({ deactivated: activeId ?? null });
+  });
+}
+const changesetDeactivateTool = {
+  name: "changeset_deactivate",
+  description: "Deactivate the active changeset. Its changes stay staged; afterwards mutations write the base model directly.",
+  inputSchema: deactivateInputSchema,
+  handler: changesetDeactivateHandler
+};
+export {
+  changesetActivateHandler,
+  changesetActivateTool,
+  changesetCreateHandler,
+  changesetCreateTool,
+  changesetDeactivateHandler,
+  changesetDeactivateTool
+};
+//# sourceMappingURL=changeset-lifecycle.js.map

package/dist/mcp/tools/changeset-lifecycle.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/changeset-lifecycle.ts"],
+  "sourcesContent": ["/**\n * changeset_create, changeset_activate, changeset_deactivate \u2014 open and switch the changeset\n * that model and relationship mutations stage into. Mirrors `dr changeset create|activate|deactivate`.\n *\n * Every one of these reloads the cached model afterwards: the model decides at load time whether\n * its layers are projected through an active changeset.\n *\n * Commit, apply and delete are deliberately not exposed over MCP: landing a change is the\n * human's step (viewer or CLI). Rename, unstage and (confirmed) discard are in\n * changeset-editing.ts. See docs/CHANGE_MODELING.md.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { StagingAreaManager } from \"../../core/staging-area.js\";\nimport { CLIError, ErrorCategory } from \"../../utils/errors.js\";\nimport { jsonResult, loadModel, reloadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\nimport { resolveChangeset } from \"./changeset-shared.js\";\n\n// ---------------------------------------------------------------------------\n// changeset_create\n// ---------------------------------------------------------------------------\n\nconst createInputSchema = {\n  name: z.string().min(1).describe(\"Short name for the change, e.g. 'add-order-export'.\"),\n  description: z\n    .string()\n    .optional()\n    .describe(\"The change's intent: what it is for and what done looks like. Shown to the human reviewing it.\"),\n  activate: z\n    .boolean()\n    .optional()\n    .describe(\"Make it the active changeset so mutations stage into it (default true).\"),\n  rootPath: rootPathSchema,\n};\n\nexport type ChangesetCreateArgs = z.infer<z.ZodObject<typeof createInputSchema>>;\n\nexport async function changesetCreateHandler(args: ChangesetCreateArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const manager = new StagingAreaManager(model.rootPath, model);\n\n    if (await manager.load(args.name)) {\n      throw new CLIError(`Changeset '${args.name}' already exists`, ErrorCategory.USER, [\n        `Use \"changeset_activate\" with \"${args.name}\" to continue it`,\n        \"Or choose another name\",\n      ]);\n    }\n\n    const changeset = await manager.create(args.name, args.description);\n    const activate = args.activate ?? true;\n    const previouslyActive = activate ? await manager.getActiveId() : null;\n    if (activate) {\n      await manager.setActive(changeset.id);\n      await reloadModel(args.rootPath);\n    }\n\n    return jsonResult({\n      id: changeset.id,\n      name: changeset.name,\n      ...(changeset.description ? { description: changeset.description } : {}),\n      status: changeset.status,\n      active: activate,\n      ...(previouslyActive && previouslyActive !== changeset.id ? { deactivated: previouslyActive } : {}),\n    });\n  });\n}\n\nexport const changesetCreateTool: McpToolDefinition<typeof createInputSchema> = {\n  name: \"changeset_create\",\n  description:\n    \"Start planning a change: create a changeset carrying the change's intent and (by default) activate it, \" +\n    \"so model_add / model_update / model_delete / relationship_add / relationship_delete stage into it instead \" +\n    \"of writing the model. The human commits it later; it is never committed over MCP.\",\n  inputSchema: createInputSchema,\n  handler: changesetCreateHandler,\n};\n\n// ---------------------------------------------------------------------------\n// changeset_activate\n// ---------------------------------------------------------------------------\n\nconst activateInputSchema = {\n  changesetId: z.string().describe(\"Changeset ID or name.\"),\n  rootPath: rootPathSchema,\n};\n\nexport type ChangesetActivateArgs = z.infer<z.ZodObject<typeof activateInputSchema>>;\n\nexport async function changesetActivateHandler(args: ChangesetActivateArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const manager = new StagingAreaManager(model.rootPath, model);\n    const changeset = await resolveChangeset(manager, args.changesetId);\n\n    if (changeset.status !== \"staged\") {\n      throw new CLIError(\n        `Changeset '${changeset.name}' is ${changeset.status} and cannot accept changes`,\n        ErrorCategory.USER,\n        ['Use \"changeset_create\" to start a new one']\n      );\n    }\n\n    const previouslyActive = await manager.getActiveId();\n    await manager.setActive(changeset.id);\n    await reloadModel(args.rootPath);\n\n    return jsonResult({\n      id: changeset.id,\n      name: changeset.name,\n      active: true,\n      changes: changeset.changes.length,\n      ...(previouslyActive && previouslyActive !== changeset.id ? { deactivated: previouslyActive } : {}),\n    });\n  });\n}\n\nexport const changesetActivateTool: McpToolDefinition<typeof activateInputSchema> = {\n  name: \"changeset_activate\",\n  description: \"Make an existing staged changeset the active one, so mutations stage into it.\",\n  inputSchema: activateInputSchema,\n  handler: changesetActivateHandler,\n};\n\n// ---------------------------------------------------------------------------\n// changeset_deactivate\n// ---------------------------------------------------------------------------\n\nconst deactivateInputSchema = {\n  rootPath: rootPathSchema,\n};\n\nexport type ChangesetDeactivateArgs = z.infer<z.ZodObject<typeof deactivateInputSchema>>;\n\nexport async function changesetDeactivateHandler(args: ChangesetDeactivateArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const manager = new StagingAreaManager(model.rootPath, model);\n    const activeId = await manager.getActiveId();\n    if (activeId) {\n      await manager.clearActive();\n      await reloadModel(args.rootPath);\n    }\n    return jsonResult({ deactivated: activeId ?? null });\n  });\n}\n\nexport const changesetDeactivateTool: McpToolDefinition<typeof deactivateInputSchema> = {\n  name: \"changeset_deactivate\",\n  description:\n    \"Deactivate the active changeset. Its changes stay staged; afterwards mutations write the base model directly.\",\n  inputSchema: deactivateInputSchema,\n  handler: changesetDeactivateHandler,\n};\n"],
+  "mappings": "AAYA,SAAS,SAAS;AAElB,SAAS,0BAA0B;AACnC,SAAS,UAAU,qBAAqB;AACxC,SAAS,YAAY,WAAW,aAAa,gBAAgB,eAAuC;AACpG,SAAS,wBAAwB;AAMjC,MAAM,oBAAoB;EACxB,MAAM,EAAE,OAAM,EAAG,IAAI,CAAC,EAAE,SAAS,qDAAqD;EACtF,aAAa,EACV,OAAM,EACN,SAAQ,EACR,SAAS,gGAAgG;EAC5G,UAAU,EACP,QAAO,EACP,SAAQ,EACR,SAAS,yEAAyE;EACrF,UAAU;;AAKZ,eAAsB,uBAAuB,MAAyB;AACpE,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GACrC,UAAU,IAAI,mBAAmB,MAAM,UAAU,KAAK;AAE5D,QAAI,MAAM,QAAQ,KAAK,KAAK,IAAI;AAC9B,YAAM,IAAI,SAAS,cAAc,KAAK,IAAI,oBAAoB,cAAc,MAAM;QAChF,kCAAkC,KAAK,IAAI;QAC3C;OACD;AAGH,UAAM,YAAY,MAAM,QAAQ,OAAO,KAAK,MAAM,KAAK,WAAW,GAC5D,WAAW,KAAK,YAAY,IAC5B,mBAAmB,WAAW,MAAM,QAAQ,YAAW,IAAK;AAClE,WAAI,aACF,MAAM,QAAQ,UAAU,UAAU,EAAE,GACpC,MAAM,YAAY,KAAK,QAAQ,IAG1B,WAAW;MAChB,IAAI,UAAU;MACd,MAAM,UAAU;MAChB,GAAI,UAAU,cAAc,EAAE,aAAa,UAAU,YAAW,IAAK,CAAA;MACrE,QAAQ,UAAU;MAClB,QAAQ;MACR,GAAI,oBAAoB,qBAAqB,UAAU,KAAK,EAAE,aAAa,iBAAgB,IAAK,CAAA;KACjG;EACH,CAAC;AACH;AAEO,MAAM,sBAAmE;EAC9E,MAAM;EACN,aACE;EAGF,aAAa;EACb,SAAS;GAOL,sBAAsB;EAC1B,aAAa,EAAE,OAAM,EAAG,SAAS,uBAAuB;EACxD,UAAU;;AAKZ,eAAsB,yBAAyB,MAA2B;AACxE,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GACrC,UAAU,IAAI,mBAAmB,MAAM,UAAU,KAAK,GACtD,YAAY,MAAM,iBAAiB,SAAS,KAAK,WAAW;AAElE,QAAI,UAAU,WAAW;AACvB,YAAM,IAAI,SACR,cAAc,UAAU,IAAI,QAAQ,UAAU,MAAM,8BACpD,cAAc,MACd,CAAC,2CAA2C,CAAC;AAIjD,UAAM,mBAAmB,MAAM,QAAQ,YAAW;AAClD,iBAAM,QAAQ,UAAU,UAAU,EAAE,GACpC,MAAM,YAAY,KAAK,QAAQ,GAExB,WAAW;MAChB,IAAI,UAAU;MACd,MAAM,UAAU;MAChB,QAAQ;MACR,SAAS,UAAU,QAAQ;MAC3B,GAAI,oBAAoB,qBAAqB,UAAU,KAAK,EAAE,aAAa,iBAAgB,IAAK,CAAA;KACjG;EACH,CAAC;AACH;AAEO,MAAM,wBAAuE;EAClF,MAAM;EACN,aAAa;EACb,aAAa;EACb,SAAS;GAOL,wBAAwB;EAC5B,UAAU;;AAKZ,eAAsB,2BAA2B,MAA6B;AAC5E,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GACrC,UAAU,IAAI,mBAAmB,MAAM,UAAU,KAAK,GACtD,WAAW,MAAM,QAAQ,YAAW;AAC1C,WAAI,aACF,MAAM,QAAQ,YAAW,GACzB,MAAM,YAAY,KAAK,QAAQ,IAE1B,WAAW,EAAE,aAAa,YAAY,KAAI,CAAE;EACrD,CAAC;AACH;AAEO,MAAM,0BAA2E;EACtF,MAAM;EACN,aACE;EACF,aAAa;EACb,SAAS;;",
+  "names": []
+}

package/dist/mcp/tools/changeset-list.js

@@ -0,0 +1,33 @@
+import { StagingAreaManager } from "../../core/staging-area.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  rootPath: rootPathSchema
+};
+async function changesetListHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), manager = new StagingAreaManager(model.rootPath, model), changesets = await manager.list(), activeChangesetId = await manager.getActiveId(), changesetsById = {};
+    for (const changeset of changesets)
+      changesetsById[changeset.id] = {
+        name: changeset.name,
+        status: changeset.status,
+        created: changeset.created,
+        changes_count: changeset.changes.length
+      };
+    return jsonResult({
+      version: "1.0.0",
+      changesets: changesetsById,
+      activeChangesetId
+    });
+  });
+}
+const changesetListTool = {
+  name: "changeset_list",
+  description: "List all staged changesets, mirroring the REST GET /api/changesets endpoint.",
+  inputSchema,
+  handler: changesetListHandler
+};
+export {
+  changesetListHandler,
+  changesetListTool
+};
+//# sourceMappingURL=changeset-list.js.map

package/dist/mcp/tools/changeset-list.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/changeset-list.ts"],
+  "sourcesContent": ["/**\n * changeset_list \u2014 list all staged changesets. Mirrors the REST\n * `GET /api/changesets` endpoint (see `ChangesetsListSchema` in\n * `cli/src/server/schemas.ts`).\n */\n\nimport type { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { StagingAreaManager } from \"../../core/staging-area.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  rootPath: rootPathSchema,\n};\n\nexport type ChangesetListArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function changesetListHandler(args: ChangesetListArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const manager = new StagingAreaManager(model.rootPath, model);\n    const changesets = await manager.list();\n    const activeChangesetId = await manager.getActiveId();\n\n    const changesetsById: Record<\n      string,\n      { name: string; status: string; created: string; changes_count: number }\n    > = {};\n    for (const changeset of changesets) {\n      changesetsById[changeset.id] = {\n        name: changeset.name,\n        status: changeset.status,\n        created: changeset.created,\n        changes_count: changeset.changes.length,\n      };\n    }\n\n    return jsonResult({\n      version: \"1.0.0\",\n      changesets: changesetsById,\n      activeChangesetId,\n    });\n  });\n}\n\nexport const changesetListTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"changeset_list\",\n  description: \"List all staged changesets, mirroring the REST GET /api/changesets endpoint.\",\n  inputSchema,\n  handler: changesetListHandler,\n};\n"],
+  "mappings": "AAQA,SAAS,0BAA0B;AACnC,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AAEvF,MAAM,cAAc;EAClB,UAAU;;AAKZ,eAAsB,qBAAqB,MAAuB;AAChE,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GACrC,UAAU,IAAI,mBAAmB,MAAM,UAAU,KAAK,GACtD,aAAa,MAAM,QAAQ,KAAI,GAC/B,oBAAoB,MAAM,QAAQ,YAAW,GAE7C,iBAGF,CAAA;AACJ,eAAW,aAAa;AACtB,qBAAe,UAAU,EAAE,IAAI;QAC7B,MAAM,UAAU;QAChB,QAAQ,UAAU;QAClB,SAAS,UAAU;QACnB,eAAe,UAAU,QAAQ;;AAIrC,WAAO,WAAW;MAChB,SAAS;MACT,YAAY;MACZ;KACD;EACH,CAAC;AACH;AAEO,MAAM,oBAA2D;EACtE,MAAM;EACN,aAAa;EACb;EACA,SAAS;;",
+  "names": []
+}

package/dist/mcp/tools/changeset-shared.js

@@ -0,0 +1,31 @@
+import { ChangesetGraph } from "../../core/changeset-graph.js";
+import { StagingAreaManager } from "../../core/staging-area.js";
+import { CLIError, ErrorCategory } from "../../utils/errors.js";
+async function resolveChangeset(manager, changesetId, parameter = "changesetId") {
+  const id = changesetId ?? await manager.getActiveId();
+  if (!id)
+    throw new CLIError("No changeset named and none is active", ErrorCategory.USER, [
+      `Pass "${parameter}", or use "changeset_create" / "changeset_activate" first`,
+      'Use "changeset_list" to see existing changesets'
+    ]);
+  const changeset = await manager.load(id);
+  if (!changeset)
+    throw new CLIError(`Changeset ${id} not found`, ErrorCategory.NOT_FOUND, [
+      'Use "changeset_list" to see all available changesets'
+    ]);
+  return changeset;
+}
+async function activeStagedChangeset(manager) {
+  const active = await manager.getActive();
+  return active && active.status === "staged" ? active : null;
+}
+async function loadChangesetGraph(model, changesetId) {
+  const manager = new StagingAreaManager(model.rootPath, model), changeset = await resolveChangeset(manager, changesetId), graph = await ChangesetGraph.build(model, changeset);
+  return { manager, changeset, graph };
+}
+export {
+  activeStagedChangeset,
+  loadChangesetGraph,
+  resolveChangeset
+};
+//# sourceMappingURL=changeset-shared.js.map

package/dist/mcp/tools/changeset-shared.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/changeset-shared.ts"],
+  "sourcesContent": ["/**\n * Helpers shared by the changeset-planning MCP tools.\n */\n\nimport type { Changeset } from \"../../core/changeset.js\";\nimport { ChangesetGraph } from \"../../core/changeset-graph.js\";\nimport type { Model } from \"../../core/model.js\";\nimport { StagingAreaManager } from \"../../core/staging-area.js\";\nimport { CLIError, ErrorCategory } from \"../../utils/errors.js\";\n\n/** Loads a changeset by id or name, or the active one when none is named. */\nexport async function resolveChangeset(\n  manager: StagingAreaManager,\n  changesetId?: string,\n  /** The tool parameter that names the changeset, for the hint when none is named or active. */\n  parameter = \"changesetId\"\n): Promise<Changeset> {\n  const id = changesetId ?? (await manager.getActiveId());\n  if (!id) {\n    throw new CLIError(\"No changeset named and none is active\", ErrorCategory.USER, [\n      `Pass \"${parameter}\", or use \"changeset_create\" / \"changeset_activate\" first`,\n      'Use \"changeset_list\" to see existing changesets',\n    ]);\n  }\n  const changeset = await manager.load(id);\n  if (!changeset) {\n    throw new CLIError(`Changeset ${id} not found`, ErrorCategory.NOT_FOUND, [\n      'Use \"changeset_list\" to see all available changesets',\n    ]);\n  }\n  return changeset;\n}\n\n/** The active changeset when it can still accept changes, else null. */\nexport async function activeStagedChangeset(manager: StagingAreaManager): Promise<Changeset | null> {\n  const active = await manager.getActive();\n  return active && active.status === \"staged\" ? active : null;\n}\n\n/** Builds the projected graph for a changeset (by id/name, or the active one). */\nexport async function loadChangesetGraph(\n  model: Model,\n  changesetId?: string\n): Promise<{ manager: StagingAreaManager; changeset: Changeset; graph: ChangesetGraph }> {\n  const manager = new StagingAreaManager(model.rootPath, model);\n  const changeset = await resolveChangeset(manager, changesetId);\n  const graph = await ChangesetGraph.build(model, changeset);\n  return { manager, changeset, graph };\n}\n"],
+  "mappings": "AAKA,SAAS,sBAAsB;AAE/B,SAAS,0BAA0B;AACnC,SAAS,UAAU,qBAAqB;AAGxC,eAAsB,iBACpB,SACA,aAEA,YAAY,eAAa;AAEzB,QAAM,KAAK,eAAgB,MAAM,QAAQ,YAAW;AACpD,MAAI,CAAC;AACH,UAAM,IAAI,SAAS,yCAAyC,cAAc,MAAM;MAC9E,SAAS,SAAS;MAClB;KACD;AAEH,QAAM,YAAY,MAAM,QAAQ,KAAK,EAAE;AACvC,MAAI,CAAC;AACH,UAAM,IAAI,SAAS,aAAa,EAAE,cAAc,cAAc,WAAW;MACvE;KACD;AAEH,SAAO;AACT;AAGA,eAAsB,sBAAsB,SAA2B;AACrE,QAAM,SAAS,MAAM,QAAQ,UAAS;AACtC,SAAO,UAAU,OAAO,WAAW,WAAW,SAAS;AACzD;AAGA,eAAsB,mBACpB,OACA,aAAoB;AAEpB,QAAM,UAAU,IAAI,mBAAmB,MAAM,UAAU,KAAK,GACtD,YAAY,MAAM,iBAAiB,SAAS,WAAW,GACvD,QAAQ,MAAM,eAAe,MAAM,OAAO,SAAS;AACzD,SAAO,EAAE,SAAS,WAAW,MAAK;AACpC;",
+  "names": []
+}

package/dist/mcp/tools/changeset-show.js

@@ -0,0 +1,55 @@
+import { z } from "zod";
+import { StagingAreaManager } from "../../core/staging-area.js";
+import { summarizeChangeset } from "../../core/changeset-summary.js";
+import { CLIError, ErrorCategory } from "../../utils/errors.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  changesetId: z.string().describe("Changeset ID or name."),
+  detail: z.enum(["full", "summary"]).optional().describe('"full" (default): every change with its before/after snapshots. "summary": one entry per change (sequence, operation, element id and type or relationship source/predicate/target, and for updates the changed field names such as attributes.summary), plus totals per operation, without snapshots.'),
+  rootPath: rootPathSchema
+};
+async function changesetShowHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), changeset = await new StagingAreaManager(model.rootPath, model).load(args.changesetId);
+    if (!changeset)
+      throw new CLIError(`Changeset ${args.changesetId} not found`, ErrorCategory.NOT_FOUND, [
+        'Use "changeset_list" to see all available changesets'
+      ]);
+    if (args.detail === "summary") {
+      const summary = summarizeChangeset(changeset.changes);
+      return jsonResult({
+        id: changeset.id,
+        name: changeset.name,
+        description: changeset.description,
+        status: changeset.status,
+        created: changeset.created,
+        modified: changeset.modified,
+        detail: "summary",
+        totals: summary.totals,
+        changes: summary.changes
+      });
+    }
+    return jsonResult({
+      id: changeset.id,
+      name: changeset.name,
+      description: changeset.description,
+      status: changeset.status,
+      created: changeset.created,
+      modified: changeset.modified,
+      baseSnapshot: changeset.baseSnapshot,
+      stats: changeset.stats,
+      changes: changeset.changes
+    });
+  });
+}
+const changesetShowTool = {
+  name: "changeset_show",
+  description: `Show a single changeset's detail including its description, stats, and list of changes. Pass detail: "summary" for one compact line per change (operation, element or relationship, changed fields) and totals per operation, without the before/after snapshots.`,
+  inputSchema,
+  handler: changesetShowHandler
+};
+export {
+  changesetShowHandler,
+  changesetShowTool
+};
+//# sourceMappingURL=changeset-show.js.map

package/dist/mcp/tools/changeset-show.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/changeset-show.ts"],
+  "sourcesContent": ["/**\n * changeset_show \u2014 show a single changeset's full detail, including its list\n * of changes. Mirrors the REST `GET /api/changesets/:changesetId` endpoint\n * (see `ChangesetDetailSchema` in `cli/src/server/schemas.ts`).\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { StagingAreaManager } from \"../../core/staging-area.js\";\nimport { summarizeChangeset } from \"../../core/changeset-summary.js\";\nimport { CLIError, ErrorCategory } from \"../../utils/errors.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  changesetId: z.string().describe(\"Changeset ID or name.\"),\n  detail: z\n    .enum([\"full\", \"summary\"])\n    .optional()\n    .describe(\n      '\"full\" (default): every change with its before/after snapshots. \"summary\": one entry per change ' +\n        \"(sequence, operation, element id and type or relationship source/predicate/target, and for updates the \" +\n        \"changed field names such as attributes.summary), plus totals per operation, without snapshots.\"\n    ),\n  rootPath: rootPathSchema,\n};\n\nexport type ChangesetShowArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function changesetShowHandler(args: ChangesetShowArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const manager = new StagingAreaManager(model.rootPath, model);\n    const changeset = await manager.load(args.changesetId);\n\n    if (!changeset) {\n      throw new CLIError(`Changeset ${args.changesetId} not found`, ErrorCategory.NOT_FOUND, [\n        'Use \"changeset_list\" to see all available changesets',\n      ]);\n    }\n\n    if (args.detail === \"summary\") {\n      const summary = summarizeChangeset(changeset.changes);\n      return jsonResult({\n        id: changeset.id,\n        name: changeset.name,\n        description: changeset.description,\n        status: changeset.status,\n        created: changeset.created,\n        modified: changeset.modified,\n        detail: \"summary\",\n        totals: summary.totals,\n        changes: summary.changes,\n      });\n    }\n\n    return jsonResult({\n      id: changeset.id,\n      name: changeset.name,\n      description: changeset.description,\n      status: changeset.status,\n      created: changeset.created,\n      modified: changeset.modified,\n      baseSnapshot: changeset.baseSnapshot,\n      stats: changeset.stats,\n      changes: changeset.changes,\n    });\n  });\n}\n\nexport const changesetShowTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"changeset_show\",\n  description:\n    \"Show a single changeset's detail including its description, stats, and list of changes. Pass \" +\n    'detail: \"summary\" for one compact line per change (operation, element or relationship, changed fields) ' +\n    \"and totals per operation, without the before/after snapshots.\",\n  inputSchema,\n  handler: changesetShowHandler,\n};\n"],
+  "mappings": "AAMA,SAAS,SAAS;AAElB,SAAS,0BAA0B;AACnC,SAAS,0BAA0B;AACnC,SAAS,UAAU,qBAAqB;AACxC,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AAEvF,MAAM,cAAc;EAClB,aAAa,EAAE,OAAM,EAAG,SAAS,uBAAuB;EACxD,QAAQ,EACL,KAAK,CAAC,QAAQ,SAAS,CAAC,EACxB,SAAQ,EACR,SACC,uSAEkG;EAEtG,UAAU;;AAKZ,eAAsB,qBAAqB,MAAuB;AAChE,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GAErC,YAAY,MADF,IAAI,mBAAmB,MAAM,UAAU,KAAK,EAC5B,KAAK,KAAK,WAAW;AAErD,QAAI,CAAC;AACH,YAAM,IAAI,SAAS,aAAa,KAAK,WAAW,cAAc,cAAc,WAAW;QACrF;OACD;AAGH,QAAI,KAAK,WAAW,WAAW;AAC7B,YAAM,UAAU,mBAAmB,UAAU,OAAO;AACpD,aAAO,WAAW;QAChB,IAAI,UAAU;QACd,MAAM,UAAU;QAChB,aAAa,UAAU;QACvB,QAAQ,UAAU;QAClB,SAAS,UAAU;QACnB,UAAU,UAAU;QACpB,QAAQ;QACR,QAAQ,QAAQ;QAChB,SAAS,QAAQ;OAClB;IACH;AAEA,WAAO,WAAW;MAChB,IAAI,UAAU;MACd,MAAM,UAAU;MAChB,aAAa,UAAU;MACvB,QAAQ,UAAU;MAClB,SAAS,UAAU;MACnB,UAAU,UAAU;MACpB,cAAc,UAAU;MACxB,OAAO,UAAU;MACjB,SAAS,UAAU;KACpB;EACH,CAAC;AACH;AAEO,MAAM,oBAA2D;EACtE,MAAM;EACN,aACE;EAGF;EACA,SAAS;;",
+  "names": []
+}

package/dist/mcp/tools/changeset-verify.js

@@ -0,0 +1,43 @@
+import { z } from "zod";
+import { verifyChangesetInModel } from "../../core/changeset-verify.js";
+import { StagingAreaManager } from "../../core/staging-area.js";
+import { CLIError, ErrorCategory } from "../../utils/errors.js";
+import { jsonResult, reloadModel, rootPathSchema, runTool } from "./shared.js";
+import { resolveChangeset } from "./changeset-shared.js";
+const inputSchema = {
+  planned: z.string().optional().describe("The planned changeset, by ID or name. Defaults to the active changeset."),
+  against: z.object({
+    changesetId: z.string().optional().describe("An as-built changeset (by ID or name), e.g. one written by extraction or by hand."),
+    base: z.boolean().optional().describe("Compare with the base model, e.g. after the as-built changeset was committed on the branch.")
+  }).describe('What was built: {"changesetId": "..."} or {"base": true}.'),
+  matchBySource: z.boolean().optional().describe("Also match elements of the same layer and type that share a source file (default true)."),
+  rootPath: rootPathSchema
+};
+async function changesetVerifyHandler(args) {
+  return runTool(async () => {
+    if (args.against?.changesetId && args.against.base)
+      throw new CLIError('Pass either "against.changesetId" or "against.base", not both', ErrorCategory.USER);
+    if (!args.against?.changesetId && !args.against?.base)
+      throw new CLIError("Nothing to verify against", ErrorCategory.USER, [
+        'Pass "against": {"changesetId": "<as-built changeset>"} to compare with another changeset',
+        'Pass "against": {"base": true} to compare with the base model'
+      ]);
+    const model = await reloadModel(args.rootPath), manager = new StagingAreaManager(model.rootPath, model), planned = await resolveChangeset(manager, args.planned, "planned"), asBuilt = args.against?.changesetId ? await resolveChangeset(manager, args.against.changesetId) : void 0;
+    return jsonResult(await verifyChangesetInModel(model, {
+      planned,
+      against: asBuilt ? { changeset: asBuilt } : { base: !0 },
+      matchBySource: args.matchBySource
+    }));
+  });
+}
+const changesetVerifyTool = {
+  name: "changeset_verify",
+  description: "Compare a planned changeset with what was built: another (as-built) changeset, or the base model. Elements match by id, then by layer + type + name ignoring case and separators, then by source file; relationships match through those element matches. Reports matched, missing (planned, not built), unplanned (built, not planned), divergent (matched but type, description or attributes differ, with the fields), and planned deletions that still exist, with a verdict. Fuzzy matches are marked probable with their reason; confirm them. Reads the model fresh from disk, so a commit made outside MCP is seen. Read-only.",
+  inputSchema,
+  handler: changesetVerifyHandler
+};
+export {
+  changesetVerifyHandler,
+  changesetVerifyTool
+};
+//# sourceMappingURL=changeset-verify.js.map

package/dist/mcp/tools/changeset-verify.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/changeset-verify.ts"],
+  "sourcesContent": ["/**\n * changeset_verify \u2014 compare a planned changeset with what was built.\n * See `cli/src/core/changeset-verify.ts` and docs/CHANGE_MODELING.md.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { verifyChangesetInModel } from \"../../core/changeset-verify.js\";\nimport { StagingAreaManager } from \"../../core/staging-area.js\";\nimport { CLIError, ErrorCategory } from \"../../utils/errors.js\";\nimport { jsonResult, reloadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\nimport { resolveChangeset } from \"./changeset-shared.js\";\n\nconst inputSchema = {\n  planned: z\n    .string()\n    .optional()\n    .describe(\"The planned changeset, by ID or name. Defaults to the active changeset.\"),\n  against: z\n    .object({\n      changesetId: z\n        .string()\n        .optional()\n        .describe(\"An as-built changeset (by ID or name), e.g. one written by extraction or by hand.\"),\n      base: z\n        .boolean()\n        .optional()\n        .describe(\"Compare with the base model, e.g. after the as-built changeset was committed on the branch.\"),\n    })\n    .describe('What was built: {\"changesetId\": \"...\"} or {\"base\": true}.'),\n  matchBySource: z\n    .boolean()\n    .optional()\n    .describe(\"Also match elements of the same layer and type that share a source file (default true).\"),\n  rootPath: rootPathSchema,\n};\n\nexport type ChangesetVerifyArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function changesetVerifyHandler(args: ChangesetVerifyArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    if (args.against?.changesetId && args.against.base) {\n      throw new CLIError('Pass either \"against.changesetId\" or \"against.base\", not both', ErrorCategory.USER);\n    }\n    if (!args.against?.changesetId && !args.against?.base) {\n      throw new CLIError(\"Nothing to verify against\", ErrorCategory.USER, [\n        'Pass \"against\": {\"changesetId\": \"<as-built changeset>\"} to compare with another changeset',\n        'Pass \"against\": {\"base\": true} to compare with the base model',\n      ]);\n    }\n    // Always read the model fresh: the build is often committed outside MCP (`dr changeset commit` is\n    // not exposed here), and a cached model would compare against the base as it was when the server\n    // started. Verify is read-only and infrequent, so the reload is cheap insurance.\n    const model = await reloadModel(args.rootPath);\n    const manager = new StagingAreaManager(model.rootPath, model);\n    const planned = await resolveChangeset(manager, args.planned, \"planned\");\n    const asBuilt = args.against?.changesetId ? await resolveChangeset(manager, args.against.changesetId) : undefined;\n    return jsonResult(\n      await verifyChangesetInModel(model, {\n        planned,\n        against: asBuilt ? { changeset: asBuilt } : { base: true },\n        matchBySource: args.matchBySource,\n      })\n    );\n  });\n}\n\nexport const changesetVerifyTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"changeset_verify\",\n  description:\n    \"Compare a planned changeset with what was built: another (as-built) changeset, or the base model. Elements \" +\n    \"match by id, then by layer + type + name ignoring case and separators, then by source file; relationships \" +\n    \"match through those element matches. Reports matched, missing (planned, not built), unplanned (built, not \" +\n    \"planned), divergent (matched but type, description or attributes differ, with the fields), and planned \" +\n    \"deletions that still exist, with a verdict. Fuzzy matches are marked probable with their reason; confirm \" +\n    \"them. Reads the model fresh from disk, so a commit made outside MCP is seen. Read-only.\",\n  inputSchema,\n  handler: changesetVerifyHandler,\n};\n"],
+  "mappings": "AAKA,SAAS,SAAS;AAElB,SAAS,8BAA8B;AACvC,SAAS,0BAA0B;AACnC,SAAS,UAAU,qBAAqB;AACxC,SAAS,YAAY,aAAa,gBAAgB,eAAuC;AACzF,SAAS,wBAAwB;AAEjC,MAAM,cAAc;EAClB,SAAS,EACN,OAAM,EACN,SAAQ,EACR,SAAS,yEAAyE;EACrF,SAAS,EACN,OAAO;IACN,aAAa,EACV,OAAM,EACN,SAAQ,EACR,SAAS,mFAAmF;IAC/F,MAAM,EACH,QAAO,EACP,SAAQ,EACR,SAAS,6FAA6F;GAC1G,EACA,SAAS,2DAA2D;EACvE,eAAe,EACZ,QAAO,EACP,SAAQ,EACR,SAAS,yFAAyF;EACrG,UAAU;;AAKZ,eAAsB,uBAAuB,MAAyB;AACpE,SAAO,QAAQ,YAAW;AACxB,QAAI,KAAK,SAAS,eAAe,KAAK,QAAQ;AAC5C,YAAM,IAAI,SAAS,iEAAiE,cAAc,IAAI;AAExG,QAAI,CAAC,KAAK,SAAS,eAAe,CAAC,KAAK,SAAS;AAC/C,YAAM,IAAI,SAAS,6BAA6B,cAAc,MAAM;QAClE;QACA;OACD;AAKH,UAAM,QAAQ,MAAM,YAAY,KAAK,QAAQ,GACvC,UAAU,IAAI,mBAAmB,MAAM,UAAU,KAAK,GACtD,UAAU,MAAM,iBAAiB,SAAS,KAAK,SAAS,SAAS,GACjE,UAAU,KAAK,SAAS,cAAc,MAAM,iBAAiB,SAAS,KAAK,QAAQ,WAAW,IAAI;AACxG,WAAO,WACL,MAAM,uBAAuB,OAAO;MAClC;MACA,SAAS,UAAU,EAAE,WAAW,QAAO,IAAK,EAAE,MAAM,GAAI;MACxD,eAAe,KAAK;KACrB,CAAC;EAEN,CAAC;AACH;AAEO,MAAM,sBAA6D;EACxE,MAAM;EACN,aACE;EAMF;EACA,SAAS;;",
+  "names": []
+}

package/dist/mcp/tools/chat-launch.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+import { detectAvailableClients } from "../../coding-agents/chat-utils.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  prompt: z.string().min(1).describe("The message to send to the AI coding agent."),
+  client: z.string().optional().describe('Exact client name to use ("Claude Code" or "GitHub Copilot"). Defaults to the first available client.'),
+  agent: z.string().optional().describe('Optional agent/skill name to invoke. Defaults to "dr-architect".'),
+  rootPath: rootPathSchema
+};
+async function chatLaunchHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), availableClients = await detectAvailableClients();
+    if (availableClients.length === 0)
+      return jsonResult({
+        status: "unavailable",
+        message: "No AI coding agent is installed. Install Claude Code or GitHub Copilot."
+      }, { isError: !0 });
+    let selected = availableClients[0];
+    if (args.client) {
+      const match = availableClients.find((client) => client.getClientName() === args.client);
+      if (!match)
+        return jsonResult({
+          status: "unavailable",
+          message: `"${args.client}" is not installed or not available. Available: ${availableClients.map((client) => client.getClientName()).join(", ")}`
+        }, { isError: !0 });
+      selected = match;
+    }
+    const response = await selected.sendMessage(args.prompt, {
+      workingDirectory: model.rootPath,
+      agent: args.agent ?? "dr-architect",
+      outputStream: null
+    });
+    return jsonResult({
+      status: "ok",
+      client: selected.getClientName(),
+      response
+    });
+  });
+}
+const chatLaunchTool = {
+  name: "chat_launch",
+  description: "Send a single prompt to an installed AI coding agent (Claude Code or GitHub Copilot) in run-to-completion mode and return its full response.",
+  inputSchema,
+  handler: chatLaunchHandler
+};
+export {
+  chatLaunchHandler,
+  chatLaunchTool
+};
+//# sourceMappingURL=chat-launch.js.map

package/dist/mcp/tools/chat-launch.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/chat-launch.ts"],
+  "sourcesContent": ["/**\n * chat_launch \u2014 send a single prompt to an installed AI coding agent (Claude\n * Code or GitHub Copilot) in run-to-completion (`--print`) mode and return its\n * full response. Reuses `BaseChatClient.sendMessage()`, the same call `dr\n * chat` makes per turn, but as a single request/response instead of an\n * interactive REPL \u2014 there is no multi-turn session across separate\n * `chat_launch` calls.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { detectAvailableClients } from \"../../coding-agents/chat-utils.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  prompt: z.string().min(1).describe(\"The message to send to the AI coding agent.\"),\n  client: z\n    .string()\n    .optional()\n    .describe(\n      'Exact client name to use (\"Claude Code\" or \"GitHub Copilot\"). Defaults to the first available client.'\n    ),\n  agent: z\n    .string()\n    .optional()\n    .describe('Optional agent/skill name to invoke. Defaults to \"dr-architect\".'),\n  rootPath: rootPathSchema,\n};\n\nexport type ChatLaunchArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function chatLaunchHandler(args: ChatLaunchArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const availableClients = await detectAvailableClients();\n\n    if (availableClients.length === 0) {\n      return jsonResult(\n        {\n          status: \"unavailable\",\n          message: \"No AI coding agent is installed. Install Claude Code or GitHub Copilot.\",\n        },\n        { isError: true }\n      );\n    }\n\n    let selected = availableClients[0];\n    if (args.client) {\n      const match = availableClients.find((client) => client.getClientName() === args.client);\n      if (!match) {\n        return jsonResult(\n          {\n            status: \"unavailable\",\n            message: `\"${args.client}\" is not installed or not available. Available: ${availableClients\n              .map((client) => client.getClientName())\n              .join(\", \")}`,\n          },\n          { isError: true }\n        );\n      }\n      selected = match;\n    }\n\n    const response = await selected.sendMessage(args.prompt, {\n      workingDirectory: model.rootPath,\n      agent: args.agent ?? \"dr-architect\",\n      outputStream: null,\n    });\n\n    return jsonResult({\n      status: \"ok\",\n      client: selected.getClientName(),\n      response,\n    });\n  });\n}\n\nexport const chatLaunchTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"chat_launch\",\n  description:\n    \"Send a single prompt to an installed AI coding agent (Claude Code or GitHub Copilot) in run-to-completion mode and return its full response.\",\n  inputSchema,\n  handler: chatLaunchHandler,\n};\n"],
+  "mappings": "AASA,SAAS,SAAS;AAElB,SAAS,8BAA8B;AACvC,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AAEvF,MAAM,cAAc;EAClB,QAAQ,EAAE,OAAM,EAAG,IAAI,CAAC,EAAE,SAAS,6CAA6C;EAChF,QAAQ,EACL,OAAM,EACN,SAAQ,EACR,SACC,uGAAuG;EAE3G,OAAO,EACJ,OAAM,EACN,SAAQ,EACR,SAAS,kEAAkE;EAC9E,UAAU;;AAKZ,eAAsB,kBAAkB,MAAoB;AAC1D,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GACrC,mBAAmB,MAAM,uBAAsB;AAErD,QAAI,iBAAiB,WAAW;AAC9B,aAAO,WACL;QACE,QAAQ;QACR,SAAS;SAEX,EAAE,SAAS,GAAI,CAAE;AAIrB,QAAI,WAAW,iBAAiB,CAAC;AACjC,QAAI,KAAK,QAAQ;AACf,YAAM,QAAQ,iBAAiB,KAAK,CAAC,WAAW,OAAO,cAAa,MAAO,KAAK,MAAM;AACtF,UAAI,CAAC;AACH,eAAO,WACL;UACE,QAAQ;UACR,SAAS,IAAI,KAAK,MAAM,mDAAmD,iBACxE,IAAI,CAAC,WAAW,OAAO,cAAa,CAAE,EACtC,KAAK,IAAI,CAAC;WAEf,EAAE,SAAS,GAAI,CAAE;AAGrB,iBAAW;IACb;AAEA,UAAM,WAAW,MAAM,SAAS,YAAY,KAAK,QAAQ;MACvD,kBAAkB,MAAM;MACxB,OAAO,KAAK,SAAS;MACrB,cAAc;KACf;AAED,WAAO,WAAW;MAChB,QAAQ;MACR,QAAQ,SAAS,cAAa;MAC9B;KACD;EACH,CAAC;AACH;AAEO,MAAM,iBAAwD;EACnE,MAAM;EACN,aACE;EACF;EACA,SAAS;;",
+  "names": []
+}

package/dist/mcp/tools/chat-status.js

@@ -0,0 +1,26 @@
+import { detectAvailableClients, selectChatClient } from "../../coding-agents/chat-utils.js";
+import { jsonResult, runTool } from "./shared.js";
+const inputSchema = {};
+async function chatStatusHandler(_args) {
+  return runTool(async () => {
+    const availableClients = await detectAvailableClients(), selected = selectChatClient(availableClients);
+    return jsonResult({
+      available: availableClients.map((client) => client.getClientName()),
+      selected: selected ? selected.getClientName() : null,
+      sdk_available: availableClients.length > 0,
+      sdk_version: selected ? selected.getClientName() : null,
+      error_message: availableClients.length === 0 ? "No chat client available. Install Claude Code or GitHub Copilot." : null
+    });
+  });
+}
+const chatStatusTool = {
+  name: "chat_status",
+  description: "Report which AI coding agents (Claude Code, GitHub Copilot) are installed and available.",
+  inputSchema,
+  handler: chatStatusHandler
+};
+export {
+  chatStatusHandler,
+  chatStatusTool
+};
+//# sourceMappingURL=chat-status.js.map

package/dist/mcp/tools/chat-status.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/chat-status.ts"],
+  "sourcesContent": ["/**\n * chat_status \u2014 report which AI coding agents (Claude Code, GitHub Copilot)\n * are installed and available. Mirrors the REST/WebSocket `chat.status`\n * JSON-RPC method (`cli/src/server/server.ts`).\n */\n\nimport type { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { detectAvailableClients, selectChatClient } from \"../../coding-agents/chat-utils.js\";\nimport { jsonResult, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {};\n\nexport type ChatStatusArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function chatStatusHandler(_args: ChatStatusArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const availableClients = await detectAvailableClients();\n    const selected = selectChatClient(availableClients);\n\n    return jsonResult({\n      available: availableClients.map((client) => client.getClientName()),\n      selected: selected ? selected.getClientName() : null,\n      sdk_available: availableClients.length > 0,\n      sdk_version: selected ? selected.getClientName() : null,\n      error_message:\n        availableClients.length === 0\n          ? \"No chat client available. Install Claude Code or GitHub Copilot.\"\n          : null,\n    });\n  });\n}\n\nexport const chatStatusTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"chat_status\",\n  description: \"Report which AI coding agents (Claude Code, GitHub Copilot) are installed and available.\",\n  inputSchema,\n  handler: chatStatusHandler,\n};\n"],
+  "mappings": "AAQA,SAAS,wBAAwB,wBAAwB;AACzD,SAAS,YAAY,eAAuC;AAE5D,MAAM,cAAc,CAAA;AAIpB,eAAsB,kBAAkB,OAAqB;AAC3D,SAAO,QAAQ,YAAW;AACxB,UAAM,mBAAmB,MAAM,uBAAsB,GAC/C,WAAW,iBAAiB,gBAAgB;AAElD,WAAO,WAAW;MAChB,WAAW,iBAAiB,IAAI,CAAC,WAAW,OAAO,cAAa,CAAE;MAClE,UAAU,WAAW,SAAS,cAAa,IAAK;MAChD,eAAe,iBAAiB,SAAS;MACzC,aAAa,WAAW,SAAS,cAAa,IAAK;MACnD,eACE,iBAAiB,WAAW,IACxB,qEACA;KACP;EACH,CAAC;AACH;AAEO,MAAM,iBAAwD;EACnE,MAAM;EACN,aAAa;EACb;EACA,SAAS;;",
+  "names": []
+}

package/dist/mcp/tools/index.js

@@ -0,0 +1,65 @@
+import { annotationListTool } from "./annotation-list.js";
+import { annotationGetTool } from "./annotation-get.js";
+import { annotationCreateTool } from "./annotation-create.js";
+import { annotationUpdateTool } from "./annotation-update.js";
+import { annotationDeleteTool } from "./annotation-delete.js";
+import { annotationReplyTool } from "./annotation-reply.js";
+import { modelListTool } from "./model-list.js";
+import { modelShowTool } from "./model-show.js";
+import { modelSearchTool } from "./model-search.js";
+import { modelStatsTool } from "./model-stats.js";
+import { modelInfoTool } from "./model-info.js";
+import { modelTraceTool } from "./model-trace.js";
+import { modelAddTool } from "./model-add.js";
+import { modelUpdateTool } from "./model-update.js";
+import { modelDeleteTool } from "./model-delete.js";
+import { modelValidateTool } from "./model-validate.js";
+import { modelExportTool } from "./model-export.js";
+import { modelReloadTool } from "./model-reload.js";
+import { changesetListTool } from "./changeset-list.js";
+import { changesetShowTool } from "./changeset-show.js";
+import { changesetCreateTool, changesetActivateTool, changesetDeactivateTool } from "./changeset-lifecycle.js";
+import { changesetImpactTool, changesetBriefTool } from "./changeset-analysis-tools.js";
+import { relationshipAddTool, relationshipDeleteTool } from "./relationship-tools.js";
+import { specTypeTool } from "./spec-type.js";
+import { chatStatusTool } from "./chat-status.js";
+import { chatLaunchTool } from "./chat-launch.js";
+import { changesetVerifyTool } from "./changeset-verify.js";
+import { changesetUpdateTool, changesetUnstageTool, changesetDiscardTool } from "./changeset-editing.js";
+export {
+  annotationCreateTool,
+  annotationDeleteTool,
+  annotationGetTool,
+  annotationListTool,
+  annotationReplyTool,
+  annotationUpdateTool,
+  changesetActivateTool,
+  changesetBriefTool,
+  changesetCreateTool,
+  changesetDeactivateTool,
+  changesetDiscardTool,
+  changesetImpactTool,
+  changesetListTool,
+  changesetShowTool,
+  changesetUnstageTool,
+  changesetUpdateTool,
+  changesetVerifyTool,
+  chatLaunchTool,
+  chatStatusTool,
+  modelAddTool,
+  modelDeleteTool,
+  modelExportTool,
+  modelInfoTool,
+  modelListTool,
+  modelReloadTool,
+  modelSearchTool,
+  modelShowTool,
+  modelStatsTool,
+  modelTraceTool,
+  modelUpdateTool,
+  modelValidateTool,
+  relationshipAddTool,
+  relationshipDeleteTool,
+  specTypeTool
+};
+//# sourceMappingURL=index.js.map

package/dist/mcp/tools/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/index.ts"],
+  "sourcesContent": ["export { annotationListTool } from \"./annotation-list.js\";\nexport { annotationGetTool } from \"./annotation-get.js\";\nexport { annotationCreateTool } from \"./annotation-create.js\";\nexport { annotationUpdateTool } from \"./annotation-update.js\";\nexport { annotationDeleteTool } from \"./annotation-delete.js\";\nexport { annotationReplyTool } from \"./annotation-reply.js\";\nexport { modelListTool } from \"./model-list.js\";\nexport { modelShowTool } from \"./model-show.js\";\nexport { modelSearchTool } from \"./model-search.js\";\nexport { modelStatsTool } from \"./model-stats.js\";\nexport { modelInfoTool } from \"./model-info.js\";\nexport { modelTraceTool } from \"./model-trace.js\";\nexport { modelAddTool } from \"./model-add.js\";\nexport { modelUpdateTool } from \"./model-update.js\";\nexport { modelDeleteTool } from \"./model-delete.js\";\nexport { modelValidateTool } from \"./model-validate.js\";\nexport { modelExportTool } from \"./model-export.js\";\nexport { modelReloadTool } from \"./model-reload.js\";\nexport { changesetListTool } from \"./changeset-list.js\";\nexport { changesetShowTool } from \"./changeset-show.js\";\nexport { changesetCreateTool, changesetActivateTool, changesetDeactivateTool } from \"./changeset-lifecycle.js\";\nexport { changesetImpactTool, changesetBriefTool } from \"./changeset-analysis-tools.js\";\nexport { relationshipAddTool, relationshipDeleteTool } from \"./relationship-tools.js\";\nexport { specTypeTool } from \"./spec-type.js\";\nexport { chatStatusTool } from \"./chat-status.js\";\nexport { chatLaunchTool } from \"./chat-launch.js\";\nexport { changesetVerifyTool } from \"./changeset-verify.js\";\nexport type { McpToolDefinition } from \"./shared.js\";\nexport { changesetUpdateTool, changesetUnstageTool, changesetDiscardTool } from \"./changeset-editing.js\";\n"],
+  "mappings": "AAAA,SAAS,0BAA0B;AACnC,SAAS,yBAAyB;AAClC,SAAS,4BAA4B;AACrC,SAAS,4BAA4B;AACrC,SAAS,4BAA4B;AACrC,SAAS,2BAA2B;AACpC,SAAS,qBAAqB;AAC9B,SAAS,qBAAqB;AAC9B,SAAS,uBAAuB;AAChC,SAAS,sBAAsB;AAC/B,SAAS,qBAAqB;AAC9B,SAAS,sBAAsB;AAC/B,SAAS,oBAAoB;AAC7B,SAAS,uBAAuB;AAChC,SAAS,uBAAuB;AAChC,SAAS,yBAAyB;AAClC,SAAS,uBAAuB;AAChC,SAAS,uBAAuB;AAChC,SAAS,yBAAyB;AAClC,SAAS,yBAAyB;AAClC,SAAS,qBAAqB,uBAAuB,+BAA+B;AACpF,SAAS,qBAAqB,0BAA0B;AACxD,SAAS,qBAAqB,8BAA8B;AAC5D,SAAS,oBAAoB;AAC7B,SAAS,sBAAsB;AAC/B,SAAS,sBAAsB;AAC/B,SAAS,2BAA2B;AAEpC,SAAS,qBAAqB,sBAAsB,4BAA4B;",
+  "names": []
+}