@documentation-robotics/cli 0.2.0 → 0.4.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 * Landing a change is the human's step: changeset_commit (changeset-commit.ts) asks a person to\n * confirm it. Discard is exposed because an agent must be able to abandon its own plan, but it\n * clears the staged changes for good, so it needs `confirm: true`. See docs/CHANGE_MODELING.md.\n */\n\nimport { z } from \"zod\";\nimport { strictItem } from \"../strict-schema.js\";\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 elementIdField = z\n  .string()\n  .optional()\n  .describe(\"Drop every staged change to this element (its add, updates or delete). ID or path.\");\nconst sourceField = 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  );\nconst targetField = 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  );\nconst predicateField = z.string().optional().describe(\"Only relationship changes with this predicate. Omit for any.\");\nconst keepRelationshipsField = 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\nconst unstageItemSchema = strictItem(\"A changes[] item\", {\n  elementId: elementIdField,\n  source: sourceField,\n  target: targetField,\n  predicate: predicateField,\n  keepRelationships: keepRelationshipsField,\n});\n\ntype UnstageSpec = z.infer<typeof unstageItemSchema>;\n\nconst unstageInputSchema = {\n  changesetId: changesetIdSchema,\n  elementId: elementIdField,\n  source: sourceField,\n  target: targetField,\n  predicate: predicateField,\n  keepRelationships: keepRelationshipsField,\n  changes: z\n    .array(unstageItemSchema)\n    .min(1)\n    .optional()\n    .describe(\n      \"Several unstages at once, each {elementId} or {source, predicate?, target} or {source} or {target}, with the \" +\n        \"same meaning as the single form. All are removed in one write, with a result per item: unstaged, \" +\n        \"already-unstaged (an earlier item took its changes), not-staged, or invalid with the reason. Cannot be \" +\n        \"combined with the single-form fields.\"\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\n/** Refuses a spec that names neither or both of an element and a relationship. */\nfunction checkUnstageSpec(spec: UnstageSpec): void {\n  const byElement = spec.elementId !== undefined;\n  const byRelationship = spec.source !== undefined || spec.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 && !spec.source && !spec.target) {\n    throw new CLIError('\"source\" or \"target\" must not be empty', ErrorCategory.USER);\n  }\n}\n\n/** The change keys one unstage spec selects, and what it kept or should say. */\nfunction selectUnstage(\n  spec: UnstageSpec,\n  graph: ChangesetGraph,\n  changeset: Changeset\n): { keys: Set<string>; notes: string[] } {\n  const changes = changeset.changes as StagedChange[];\n  const keys = new Set<string>();\n  const notes: string[] = [];\n\n  if (spec.elementId !== undefined) {\n    const element = graph.getElement(spec.elementId);\n    const ids = new Set([spec.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 ${spec.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 (spec.keepRelationships) {\n        notes.push(\n          `${dependent.length} staged relationship change(s) on ${spec.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    return { keys, notes };\n  }\n\n  const matched = stagedRelationshipChangesAtEnds(graph, changeset, {\n    source: spec.source || undefined,\n    target: spec.target || undefined,\n    predicate: spec.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 = !!spec.source && !!spec.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  return { keys, notes };\n}\n\nfunction notStagedMessage(spec: UnstageSpec, changesetName: string): string {\n  return spec.elementId !== undefined\n    ? `No staged change to ${spec.elementId} in '${changesetName}'`\n    : `No staged relationship change ${describeEnds(spec)}` +\n        `${spec.predicate ? ` (${spec.predicate})` : \"\"} in '${changesetName}'`;\n}\n\nconst SINGLE_FORM_FIELDS = [\"elementId\", \"source\", \"target\", \"predicate\", \"keepRelationships\"] as const;\n\nexport async function changesetUnstageHandler(args: ChangesetUnstageArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    if (args.changes) {\n      const mixed = SINGLE_FORM_FIELDS.filter((field) => args[field] !== undefined);\n      if (mixed.length > 0) {\n        throw new CLIError(`\"changes\" cannot be combined with ${mixed.map((f) => `\"${f}\"`).join(\", \")}`, ErrorCategory.USER, [\n          'Put those fields on the items of the \"changes\" list',\n        ]);\n      }\n      return unstageBatch(args.changes, args.changesetId, args.rootPath);\n    }\n\n    checkUnstageSpec(args);\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    const { keys, notes } = selectUnstage(args, graph, changeset);\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: notStagedMessage(args, changeset.name),\n        suggestions: ['Use \"changeset_show\" to list the staged changes'],\n        ...(notes.length > 0 ? { notes } : {}),\n      });\n    }\n\n    // Each key is a revision of its own, as before the list form: briefs count unstages by revision.\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\ninterface UnstageBatchResult {\n  index: number;\n  status: \"unstaged\" | \"already-unstaged\" | \"not-staged\" | \"invalid\";\n  elementId?: string;\n  source?: string;\n  target?: string;\n  predicate?: string;\n  unstaged?: Record<string, unknown>[];\n  message?: string;\n  reason?: string;\n  suggestions?: string[];\n  notes?: string[];\n}\n\n/**\n * changeset_unstage's list form: select each item's changes against the changeset as it stands,\n * then remove them all in one write. A change two items select is reported under the first.\n */\nasync function unstageBatch(specs: UnstageSpec[], changesetId: string | undefined, rootPath: string | undefined) {\n  const model = await loadModel(rootPath);\n  const manager = new StagingAreaManager(model.rootPath, model);\n  const changeset = await resolveChangeset(manager, changesetId);\n  requireStaged(changeset, \"unstage changes\");\n  const graph = await ChangesetGraph.build(model, changeset);\n  const changes = changeset.changes as StagedChange[];\n\n  const claimed = new Set<string>();\n  const results: UnstageBatchResult[] = [];\n  for (const [index, spec] of specs.entries()) {\n    const asSent: UnstageBatchResult = {\n      index,\n      status: \"unstaged\",\n      ...(spec.elementId !== undefined ? { elementId: spec.elementId } : {}),\n      ...(spec.source !== undefined ? { source: spec.source } : {}),\n      ...(spec.target !== undefined ? { target: spec.target } : {}),\n      ...(spec.predicate !== undefined ? { predicate: spec.predicate } : {}),\n    };\n    let selection: { keys: Set<string>; notes: string[] };\n    try {\n      checkUnstageSpec(spec);\n      selection = selectUnstage(spec, graph, changeset);\n    } catch (error) {\n      results.push({\n        ...asSent,\n        status: \"invalid\",\n        reason: getErrorMessage(error),\n        ...(error instanceof CLIError && error.suggestions?.length ? { suggestions: error.suggestions } : {}),\n      });\n      continue;\n    }\n    const notes = [...selection.notes];\n    const fresh = [...selection.keys].filter((key) => !claimed.has(key));\n    const earlier = selection.keys.size - fresh.length;\n    for (const key of fresh) claimed.add(key);\n    const removed = changes.filter((c) => fresh.includes(c.elementId));\n    const status: UnstageBatchResult[\"status\"] =\n      removed.length > 0 ? \"unstaged\" : earlier > 0 ? \"already-unstaged\" : \"not-staged\";\n    if (earlier > 0) notes.push(`${earlier} of its change(s) were already unstaged by an earlier item`);\n    results.push({\n      ...asSent,\n      status,\n      ...(removed.length > 0 ? { unstaged: removed.map(summarize) } : {}),\n      ...(status === \"not-staged\" ? { message: notStagedMessage(spec, changeset.name) } : {}),\n      ...(notes.length > 0 ? { notes } : {}),\n    });\n  }\n\n  if (claimed.size > 0) {\n    await manager.unstageMany(changeset.id!, [...claimed]);\n    await reloadModel(rootPath);\n  }\n\n  const counts: Record<string, number> = {};\n  for (const result of results) counts[result.status] = (counts[result.status] ?? 0) + 1;\n  const removedCount = changes.filter((c) => claimed.has(c.elementId)).length;\n  return jsonResult({\n    changeset: changeset.name,\n    counts,\n    results,\n    unstagedChanges: removedCount,\n    remainingChanges: changes.length - removedCount,\n    ...(results.some((r) => r.status === \"not-staged\")\n      ? { suggestions: ['Use \"changeset_show\" to list the staged changes'] }\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). To drop several, send changes: [...] (one write, a result per item). The base \" +\n    \"model is not touched. 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": ["seq"]
+}

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. Before calling it, propose the changeset's name and intent (description) to the user and confirm both with them. Landing it is the user's step: changeset_commit commits only after they confirm it, or they commit it in the viewer.",
+  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. Before calling it, propose the changeset's name and intent (description) to the user \" +\n    \"and confirm both with them. Landing it is the user's step: changeset_commit commits only after they confirm \" +\n    \"it, or they commit it in the viewer.\",\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;EAKF,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-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

@@ -1,9 +1,11 @@
 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) {
@@ -13,6 +15,20 @@ async function changesetShowHandler(args) {
       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,
@@ -28,7 +44,7 @@ async function changesetShowHandler(args) {
 }
 const changesetShowTool = {
   name: "changeset_show",
-  description: "Show a single changeset's full detail including its description, stats, and list of changes.",
+  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
 };

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

@@ -1,7 +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 { 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  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    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: \"Show a single changeset's full detail including its description, stats, and list of changes.\",\n  inputSchema,\n  handler: changesetShowHandler,\n};\n"],
-  "mappings": "AAMA,SAAS,SAAS;AAElB,SAAS,0BAA0B;AACnC,SAAS,UAAU,qBAAqB;AACxC,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AAEvF,MAAM,cAAc;EAClB,aAAa,EAAE,OAAM,EAAG,SAAS,uBAAuB;EACxD,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,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,aAAa;EACb;EACA,SAAS;;",
+  "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,49 @@
+import { z } from "zod";
+import { strictItem } from "../strict-schema.js";
+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: strictItem("against", {
+    changesetId: z.string().optional().describe("The as-built changeset (by ID or name). It should come from codebase_extract with since, not be written by the agent: a copy of the plan matches by definition."),
+    base: z.boolean().optional().describe("Compare with the base model, e.g. after the as-built changeset was committed on the branch."),
+    extracted: z.boolean().optional().describe("With base: the base holds a landed extraction of the build, so what extraction can't see is unverifiable rather than missing, as against an extracted as-built changeset.")
+  }).describe('What was built: {"changesetId": "..."} or {"base": true} (with "extracted": true after an extraction landed).'),
+  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?.extracted && !args.against.base)
+      throw new CLIError('"against.extracted" goes with "against.base"', ErrorCategory.USER, [
+        "An as-built changeset from codebase_extract is recognised on its own"
+      ]);
+    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, extracted: args.against.extracted === !0 },
+      matchBySource: args.matchBySource
+    }));
+  });
+}
+const changesetVerifyTool = {
+  name: "changeset_verify",
+  description: "Compare a planned changeset with what was built: the as-built changeset codebase_extract wrote (with since, the branch's base), 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), unverifiable (planned, but extraction can't see it: intent, re-exports, tests in languages without test cards, relationships no code edge maps to; not part of the verdict), unplanned (built, not planned), divergent (matched but type, name or attributes differ, with both values), and planned deletions that still exist, with a verdict. Description differences are notes on a match, not divergence: don't edit the plan to match extracted text. extraction.asBuilt counts the as-built elements extraction really staged, from its own record (not the sourceProvenance they declare); the rest are agentAdded, with why, and a warning says when they are more than half. 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 { strictItem } from \"../strict-schema.js\";\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: strictItem(\"against\", {\n    changesetId: z\n      .string()\n      .optional()\n      .describe(\n        \"The as-built changeset (by ID or name). It should come from codebase_extract with since, not be written \" +\n          \"by the agent: a copy of the plan matches by definition.\"\n      ),\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    extracted: z\n      .boolean()\n      .optional()\n      .describe(\n        \"With base: the base holds a landed extraction of the build, so what extraction can't see is \" +\n          \"unverifiable rather than missing, as against an extracted as-built changeset.\"\n      ),\n  }).describe('What was built: {\"changesetId\": \"...\"} or {\"base\": true} (with \"extracted\": true after an extraction landed).'),\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?.extracted && !args.against.base) {\n      throw new CLIError('\"against.extracted\" goes with \"against.base\"', ErrorCategory.USER, [\n        \"An as-built changeset from codebase_extract is recognised on its own\",\n      ]);\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, extracted: args.against.extracted === 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: the as-built changeset codebase_extract wrote (with since, \" +\n    \"the branch's base), or the base model. Elements match by id, then by layer + type + name ignoring case and \" +\n    \"separators, then by source file; relationships match through those element matches. Reports matched, \" +\n    \"missing (planned, not built), unverifiable (planned, but extraction can't see it: intent, re-exports, tests \" +\n    \"in languages without test cards, relationships no code edge maps to; not part of the verdict), unplanned \" +\n    \"(built, not planned), divergent (matched but type, name or attributes differ, with both values), and planned \" +\n    \"deletions that still exist, with a verdict. Description differences are notes on a match, not divergence: \" +\n    \"don't edit the plan to match extracted text. extraction.asBuilt counts the as-built elements extraction \" +\n    \"really staged, from its own record (not the sourceProvenance they declare); the rest are agentAdded, with \" +\n    \"why, and a warning says when they are more than half. Fuzzy matches are marked probable with their reason; \" +\n    \"confirm 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;AAClB,SAAS,kBAAkB;AAE3B,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,WAAW,WAAW;IAC7B,aAAa,EACV,OAAM,EACN,SAAQ,EACR,SACC,iKAC2D;IAE/D,MAAM,EACH,QAAO,EACP,SAAQ,EACR,SAAS,6FAA6F;IACzG,WAAW,EACR,QAAO,EACP,SAAQ,EACR,SACC,2KACiF;GAEtF,EAAE,SAAS,+GAA+G;EAC3H,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,KAAK,SAAS,aAAa,CAAC,KAAK,QAAQ;AAC3C,YAAM,IAAI,SAAS,gDAAgD,cAAc,MAAM;QACrF;OACD;AAEH,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,IAAM,WAAW,KAAK,QAAQ,cAAc,GAAI;MACpG,eAAe,KAAK;KACrB,CAAC;EAEN,CAAC;AACH;AAEO,MAAM,sBAA6D;EACxE,MAAM;EACN,aACE;EAWF;EACA,SAAS;;",
+  "names": []
+}