@documentation-robotics/cli 0.1.13 → 0.3.0

package/dist/mcp/tools/annotation-create.js

@@ -0,0 +1,39 @@
+import { AnnotationStore } from "../../core/annotation-store.js";
+import { findElementLayer } from "../../utils/element-utils.js";
+import { CLIError, ErrorCategory } from "../../utils/errors.js";
+import { annotationAuthorSchema, annotationContentSchema, annotationTagsSchema, elementIdSchema } from "./annotation-shared.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  elementId: elementIdSchema,
+  content: annotationContentSchema,
+  author: annotationAuthorSchema,
+  tags: annotationTagsSchema,
+  rootPath: rootPathSchema
+};
+async function annotationCreateHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath);
+    if (!await findElementLayer(model, args.elementId))
+      throw new CLIError(`Element ${args.elementId} not found`, ErrorCategory.NOT_FOUND, [
+        'Use "model_search" to find similar elements'
+      ]);
+    const annotation = await new AnnotationStore(model.rootPath).create({
+      elementId: args.elementId,
+      content: args.content,
+      author: args.author,
+      tags: args.tags
+    });
+    return jsonResult(annotation);
+  });
+}
+const annotationCreateTool = {
+  name: "annotation_create",
+  description: "Create a new annotation on a model element.",
+  inputSchema,
+  handler: annotationCreateHandler
+};
+export {
+  annotationCreateHandler,
+  annotationCreateTool
+};
+//# sourceMappingURL=annotation-create.js.map

package/dist/mcp/tools/annotation-create.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/annotation-create.ts"],
+  "sourcesContent": ["/**\n * annotation_create \u2014 create a new annotation on a model element. Mirrors\n * `POST /api/annotations` on the REST server.\n */\n\nimport type { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { AnnotationStore } from \"../../core/annotation-store.js\";\nimport { findElementLayer } from \"../../utils/element-utils.js\";\nimport { CLIError, ErrorCategory } from \"../../utils/errors.js\";\nimport {\n  annotationAuthorSchema,\n  annotationContentSchema,\n  annotationTagsSchema,\n  elementIdSchema,\n} from \"./annotation-shared.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  elementId: elementIdSchema,\n  content: annotationContentSchema,\n  author: annotationAuthorSchema,\n  tags: annotationTagsSchema,\n  rootPath: rootPathSchema,\n};\n\nexport type AnnotationCreateArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function annotationCreateHandler(args: AnnotationCreateArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n\n    const layerName = await findElementLayer(model, args.elementId);\n    if (!layerName) {\n      throw new CLIError(`Element ${args.elementId} not found`, ErrorCategory.NOT_FOUND, [\n        'Use \"model_search\" to find similar elements',\n      ]);\n    }\n\n    const store = new AnnotationStore(model.rootPath);\n    const annotation = await store.create({\n      elementId: args.elementId,\n      content: args.content,\n      author: args.author,\n      tags: args.tags,\n    });\n\n    return jsonResult(annotation);\n  });\n}\n\nexport const annotationCreateTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"annotation_create\",\n  description: \"Create a new annotation on a model element.\",\n  inputSchema,\n  handler: annotationCreateHandler,\n};\n"],
+  "mappings": "AAOA,SAAS,uBAAuB;AAChC,SAAS,wBAAwB;AACjC,SAAS,UAAU,qBAAqB;AACxC,SACE,wBACA,yBACA,sBACA,uBACK;AACP,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AAEvF,MAAM,cAAc;EAClB,WAAW;EACX,SAAS;EACT,QAAQ;EACR,MAAM;EACN,UAAU;;AAKZ,eAAsB,wBAAwB,MAA0B;AACtE,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ;AAG3C,QAAI,CADc,MAAM,iBAAiB,OAAO,KAAK,SAAS;AAE5D,YAAM,IAAI,SAAS,WAAW,KAAK,SAAS,cAAc,cAAc,WAAW;QACjF;OACD;AAIH,UAAM,aAAa,MADL,IAAI,gBAAgB,MAAM,QAAQ,EACjB,OAAO;MACpC,WAAW,KAAK;MAChB,SAAS,KAAK;MACd,QAAQ,KAAK;MACb,MAAM,KAAK;KACZ;AAED,WAAO,WAAW,UAAU;EAC9B,CAAC;AACH;AAEO,MAAM,uBAA8D;EACzE,MAAM;EACN,aAAa;EACb;EACA,SAAS;;",
+  "names": []
+}

package/dist/mcp/tools/annotation-delete.js

@@ -0,0 +1,29 @@
+import { AnnotationStore } from "../../core/annotation-store.js";
+import { CLIError, ErrorCategory } from "../../utils/errors.js";
+import { annotationIdSchema } from "./annotation-shared.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  annotationId: annotationIdSchema,
+  rootPath: rootPathSchema
+};
+async function annotationDeleteHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath);
+    if (!await new AnnotationStore(model.rootPath).delete(args.annotationId))
+      throw new CLIError(`Annotation ${args.annotationId} not found`, ErrorCategory.NOT_FOUND, [
+        'Use "annotation_list" to find existing annotations'
+      ]);
+    return jsonResult({ status: "deleted", annotationId: args.annotationId });
+  });
+}
+const annotationDeleteTool = {
+  name: "annotation_delete",
+  description: "Delete an annotation and its replies.",
+  inputSchema,
+  handler: annotationDeleteHandler
+};
+export {
+  annotationDeleteHandler,
+  annotationDeleteTool
+};
+//# sourceMappingURL=annotation-delete.js.map

package/dist/mcp/tools/annotation-delete.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/annotation-delete.ts"],
+  "sourcesContent": ["/**\n * annotation_delete \u2014 delete an annotation and its replies. Mirrors\n * `DELETE /api/annotations/:annotationId` on the REST server.\n */\n\nimport type { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { AnnotationStore } from \"../../core/annotation-store.js\";\nimport { CLIError, ErrorCategory } from \"../../utils/errors.js\";\nimport { annotationIdSchema } from \"./annotation-shared.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  annotationId: annotationIdSchema,\n  rootPath: rootPathSchema,\n};\n\nexport type AnnotationDeleteArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function annotationDeleteHandler(args: AnnotationDeleteArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const store = new AnnotationStore(model.rootPath);\n    const deleted = await store.delete(args.annotationId);\n\n    if (!deleted) {\n      throw new CLIError(`Annotation ${args.annotationId} not found`, ErrorCategory.NOT_FOUND, [\n        'Use \"annotation_list\" to find existing annotations',\n      ]);\n    }\n\n    return jsonResult({ status: \"deleted\", annotationId: args.annotationId });\n  });\n}\n\nexport const annotationDeleteTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"annotation_delete\",\n  description: \"Delete an annotation and its replies.\",\n  inputSchema,\n  handler: annotationDeleteHandler,\n};\n"],
+  "mappings": "AAOA,SAAS,uBAAuB;AAChC,SAAS,UAAU,qBAAqB;AACxC,SAAS,0BAA0B;AACnC,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AAEvF,MAAM,cAAc;EAClB,cAAc;EACd,UAAU;;AAKZ,eAAsB,wBAAwB,MAA0B;AACtE,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ;AAI3C,QAAI,CAFY,MADF,IAAI,gBAAgB,MAAM,QAAQ,EACpB,OAAO,KAAK,YAAY;AAGlD,YAAM,IAAI,SAAS,cAAc,KAAK,YAAY,cAAc,cAAc,WAAW;QACvF;OACD;AAGH,WAAO,WAAW,EAAE,QAAQ,WAAW,cAAc,KAAK,aAAY,CAAE;EAC1E,CAAC;AACH;AAEO,MAAM,uBAA8D;EACzE,MAAM;EACN,aAAa;EACb;EACA,SAAS;;",
+  "names": []
+}

package/dist/mcp/tools/annotation-get.js

@@ -0,0 +1,29 @@
+import { AnnotationStore } from "../../core/annotation-store.js";
+import { CLIError, ErrorCategory } from "../../utils/errors.js";
+import { annotationIdSchema } from "./annotation-shared.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  annotationId: annotationIdSchema,
+  rootPath: rootPathSchema
+};
+async function annotationGetHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), annotation = await new AnnotationStore(model.rootPath).get(args.annotationId);
+    if (!annotation)
+      throw new CLIError(`Annotation ${args.annotationId} not found`, ErrorCategory.NOT_FOUND, [
+        'Use "annotation_list" to find existing annotations'
+      ]);
+    return jsonResult(annotation);
+  });
+}
+const annotationGetTool = {
+  name: "annotation_get",
+  description: "Get a single annotation by ID, including its replies.",
+  inputSchema,
+  handler: annotationGetHandler
+};
+export {
+  annotationGetHandler,
+  annotationGetTool
+};
+//# sourceMappingURL=annotation-get.js.map

package/dist/mcp/tools/annotation-get.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/annotation-get.ts"],
+  "sourcesContent": ["/**\n * annotation_get \u2014 retrieve a single annotation (with its replies) by ID.\n * Mirrors `GET /api/annotations/:annotationId` on the REST server.\n */\n\nimport type { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { AnnotationStore } from \"../../core/annotation-store.js\";\nimport { CLIError, ErrorCategory } from \"../../utils/errors.js\";\nimport { annotationIdSchema } from \"./annotation-shared.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  annotationId: annotationIdSchema,\n  rootPath: rootPathSchema,\n};\n\nexport type AnnotationGetArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function annotationGetHandler(args: AnnotationGetArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const store = new AnnotationStore(model.rootPath);\n    const annotation = await store.get(args.annotationId);\n    if (!annotation) {\n      throw new CLIError(`Annotation ${args.annotationId} not found`, ErrorCategory.NOT_FOUND, [\n        'Use \"annotation_list\" to find existing annotations',\n      ]);\n    }\n    return jsonResult(annotation);\n  });\n}\n\nexport const annotationGetTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"annotation_get\",\n  description: \"Get a single annotation by ID, including its replies.\",\n  inputSchema,\n  handler: annotationGetHandler,\n};\n"],
+  "mappings": "AAOA,SAAS,uBAAuB;AAChC,SAAS,UAAU,qBAAqB;AACxC,SAAS,0BAA0B;AACnC,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AAEvF,MAAM,cAAc;EAClB,cAAc;EACd,UAAU;;AAKZ,eAAsB,qBAAqB,MAAuB;AAChE,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GAErC,aAAa,MADL,IAAI,gBAAgB,MAAM,QAAQ,EACjB,IAAI,KAAK,YAAY;AACpD,QAAI,CAAC;AACH,YAAM,IAAI,SAAS,cAAc,KAAK,YAAY,cAAc,cAAc,WAAW;QACvF;OACD;AAEH,WAAO,WAAW,UAAU;EAC9B,CAAC;AACH;AAEO,MAAM,oBAA2D;EACtE,MAAM;EACN,aAAa;EACb;EACA,SAAS;;",
+  "names": []
+}

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

@@ -0,0 +1,24 @@
+import { AnnotationStore } from "../../core/annotation-store.js";
+import { elementIdSchema } from "./annotation-shared.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  elementId: elementIdSchema.optional().describe("If provided, only return annotations on this element."),
+  rootPath: rootPathSchema
+};
+async function annotationListHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), annotations = await new AnnotationStore(model.rootPath).list(args.elementId);
+    return jsonResult({ annotations });
+  });
+}
+const annotationListTool = {
+  name: "annotation_list",
+  description: "List annotations on model elements, optionally filtered to a single element.",
+  inputSchema,
+  handler: annotationListHandler
+};
+export {
+  annotationListHandler,
+  annotationListTool
+};
+//# sourceMappingURL=annotation-list.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/annotation-list.ts"],
+  "sourcesContent": ["/**\n * annotation_list \u2014 list annotations, optionally filtered to a single\n * element. Mirrors `GET /api/annotations` on the REST server.\n */\n\nimport type { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { AnnotationStore } from \"../../core/annotation-store.js\";\nimport { elementIdSchema } from \"./annotation-shared.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  elementId: elementIdSchema.optional().describe(\"If provided, only return annotations on this element.\"),\n  rootPath: rootPathSchema,\n};\n\nexport type AnnotationListArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function annotationListHandler(args: AnnotationListArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const store = new AnnotationStore(model.rootPath);\n    const annotations = await store.list(args.elementId);\n    return jsonResult({ annotations });\n  });\n}\n\nexport const annotationListTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"annotation_list\",\n  description: \"List annotations on model elements, optionally filtered to a single element.\",\n  inputSchema,\n  handler: annotationListHandler,\n};\n"],
+  "mappings": "AAOA,SAAS,uBAAuB;AAChC,SAAS,uBAAuB;AAChC,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AAEvF,MAAM,cAAc;EAClB,WAAW,gBAAgB,SAAQ,EAAG,SAAS,uDAAuD;EACtG,UAAU;;AAKZ,eAAsB,sBAAsB,MAAwB;AAClE,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GAErC,cAAc,MADN,IAAI,gBAAgB,MAAM,QAAQ,EAChB,KAAK,KAAK,SAAS;AACnD,WAAO,WAAW,EAAE,YAAW,CAAE;EACnC,CAAC;AACH;AAEO,MAAM,qBAA4D;EACvE,MAAM;EACN,aAAa;EACb;EACA,SAAS;;",
+  "names": []
+}

package/dist/mcp/tools/annotation-reply.js

@@ -0,0 +1,34 @@
+import { AnnotationStore } from "../../core/annotation-store.js";
+import { CLIError, ErrorCategory } from "../../utils/errors.js";
+import { annotationAuthorSchema, annotationContentSchema, annotationIdSchema } from "./annotation-shared.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  annotationId: annotationIdSchema,
+  content: annotationContentSchema,
+  author: annotationAuthorSchema,
+  rootPath: rootPathSchema
+};
+async function annotationReplyHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), reply = await new AnnotationStore(model.rootPath).addReply(args.annotationId, {
+      author: args.author?.trim() || "Anonymous",
+      content: args.content
+    });
+    if (!reply)
+      throw new CLIError(`Annotation ${args.annotationId} not found`, ErrorCategory.NOT_FOUND, [
+        'Use "annotation_list" to find existing annotations'
+      ]);
+    return jsonResult(reply);
+  });
+}
+const annotationReplyTool = {
+  name: "annotation_reply",
+  description: "Add a reply to an existing annotation.",
+  inputSchema,
+  handler: annotationReplyHandler
+};
+export {
+  annotationReplyHandler,
+  annotationReplyTool
+};
+//# sourceMappingURL=annotation-reply.js.map

package/dist/mcp/tools/annotation-reply.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/annotation-reply.ts"],
+  "sourcesContent": ["/**\n * annotation_reply \u2014 add a reply to an annotation. Mirrors\n * `POST /api/annotations/:annotationId/replies` on the REST server.\n */\n\nimport type { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { AnnotationStore } from \"../../core/annotation-store.js\";\nimport { CLIError, ErrorCategory } from \"../../utils/errors.js\";\nimport { annotationAuthorSchema, annotationContentSchema, annotationIdSchema } from \"./annotation-shared.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  annotationId: annotationIdSchema,\n  content: annotationContentSchema,\n  author: annotationAuthorSchema,\n  rootPath: rootPathSchema,\n};\n\nexport type AnnotationReplyArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function annotationReplyHandler(args: AnnotationReplyArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const store = new AnnotationStore(model.rootPath);\n    const reply = await store.addReply(args.annotationId, {\n      author: args.author?.trim() || \"Anonymous\",\n      content: args.content,\n    });\n\n    if (!reply) {\n      throw new CLIError(`Annotation ${args.annotationId} not found`, ErrorCategory.NOT_FOUND, [\n        'Use \"annotation_list\" to find existing annotations',\n      ]);\n    }\n\n    return jsonResult(reply);\n  });\n}\n\nexport const annotationReplyTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"annotation_reply\",\n  description: \"Add a reply to an existing annotation.\",\n  inputSchema,\n  handler: annotationReplyHandler,\n};\n"],
+  "mappings": "AAOA,SAAS,uBAAuB;AAChC,SAAS,UAAU,qBAAqB;AACxC,SAAS,wBAAwB,yBAAyB,0BAA0B;AACpF,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AAEvF,MAAM,cAAc;EAClB,cAAc;EACd,SAAS;EACT,QAAQ;EACR,UAAU;;AAKZ,eAAsB,uBAAuB,MAAyB;AACpE,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GAErC,QAAQ,MADA,IAAI,gBAAgB,MAAM,QAAQ,EACtB,SAAS,KAAK,cAAc;MACpD,QAAQ,KAAK,QAAQ,KAAI,KAAM;MAC/B,SAAS,KAAK;KACf;AAED,QAAI,CAAC;AACH,YAAM,IAAI,SAAS,cAAc,KAAK,YAAY,cAAc,cAAc,WAAW;QACvF;OACD;AAGH,WAAO,WAAW,KAAK;EACzB,CAAC;AACH;AAEO,MAAM,sBAA6D;EACxE,MAAM;EACN,aAAa;EACb;EACA,SAAS;;",
+  "names": []
+}

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

@@ -0,0 +1,10 @@
+import { z } from "zod";
+const annotationIdSchema = z.string().min(1).describe("Annotation ID (e.g. 'ann-1700000000000-a1b2c3d4')."), elementIdSchema = z.string().min(1).describe("Target element ID (e.g. 'api.operation.create-order')."), annotationContentSchema = z.string().min(1, "Content is required").max(5e3, "Content too long (max 5000 characters)"), annotationAuthorSchema = z.string().max(100, "Author name too long (max 100 characters)").optional().describe("Author name. Defaults to 'Anonymous'."), annotationTagsSchema = z.array(z.string()).optional().describe("Tags to attach to the annotation.");
+export {
+  annotationAuthorSchema,
+  annotationContentSchema,
+  annotationIdSchema,
+  annotationTagsSchema,
+  elementIdSchema
+};
+//# sourceMappingURL=annotation-shared.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/annotation-shared.ts"],
+  "sourcesContent": ["/**\n * Shared input field schemas for the annotation_* MCP tools.\n */\n\nimport { z } from \"zod\";\n\nexport const annotationIdSchema = z.string().min(1).describe(\"Annotation ID (e.g. 'ann-1700000000000-a1b2c3d4').\");\n\nexport const elementIdSchema = z\n  .string()\n  .min(1)\n  .describe(\"Target element ID (e.g. 'api.operation.create-order').\");\n\nexport const annotationContentSchema = z\n  .string()\n  .min(1, \"Content is required\")\n  .max(5000, \"Content too long (max 5000 characters)\");\n\nexport const annotationAuthorSchema = z\n  .string()\n  .max(100, \"Author name too long (max 100 characters)\")\n  .optional()\n  .describe(\"Author name. Defaults to 'Anonymous'.\");\n\nexport const annotationTagsSchema = z\n  .array(z.string())\n  .optional()\n  .describe(\"Tags to attach to the annotation.\");\n"],
+  "mappings": "AAIA,SAAS,SAAS;AAEX,MAAM,qBAAqB,EAAE,OAAM,EAAG,IAAI,CAAC,EAAE,SAAS,oDAAoD,GAEpG,kBAAkB,EAC5B,OAAM,EACN,IAAI,CAAC,EACL,SAAS,wDAAwD,GAEvD,0BAA0B,EACpC,OAAM,EACN,IAAI,GAAG,qBAAqB,EAC5B,IAAI,KAAM,wCAAwC,GAExC,yBAAyB,EACnC,OAAM,EACN,IAAI,KAAK,2CAA2C,EACpD,SAAQ,EACR,SAAS,uCAAuC,GAEtC,uBAAuB,EACjC,MAAM,EAAE,OAAM,CAAE,EAChB,SAAQ,EACR,SAAS,mCAAmC;",
+  "names": []
+}

package/dist/mcp/tools/annotation-update.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { AnnotationStore } from "../../core/annotation-store.js";
+import { CLIError, ErrorCategory } from "../../utils/errors.js";
+import { annotationContentSchema, annotationIdSchema, annotationTagsSchema } from "./annotation-shared.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  annotationId: annotationIdSchema,
+  content: annotationContentSchema.optional(),
+  tags: annotationTagsSchema,
+  resolved: z.boolean().optional().describe("Mark the annotation resolved or unresolved."),
+  rootPath: rootPathSchema
+};
+async function annotationUpdateHandler(args) {
+  return runTool(async () => {
+    if (args.content === void 0 && args.tags === void 0 && args.resolved === void 0)
+      throw new CLIError("At least one of content, tags, or resolved must be provided", ErrorCategory.USER);
+    const model = await loadModel(args.rootPath), updated = await new AnnotationStore(model.rootPath).update(args.annotationId, {
+      content: args.content,
+      tags: args.tags,
+      resolved: args.resolved
+    });
+    if (!updated)
+      throw new CLIError(`Annotation ${args.annotationId} not found`, ErrorCategory.NOT_FOUND, [
+        'Use "annotation_list" to find existing annotations'
+      ]);
+    return jsonResult(updated);
+  });
+}
+const annotationUpdateTool = {
+  name: "annotation_update",
+  description: "Partially update an annotation's content, tags, or resolved state.",
+  inputSchema,
+  handler: annotationUpdateHandler
+};
+export {
+  annotationUpdateHandler,
+  annotationUpdateTool
+};
+//# sourceMappingURL=annotation-update.js.map

package/dist/mcp/tools/annotation-update.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/annotation-update.ts"],
+  "sourcesContent": ["/**\n * annotation_update \u2014 partially update an annotation's content, tags, or\n * resolved state. Mirrors `PATCH /api/annotations/:annotationId` (and the\n * REST server's equivalently-partial `PUT`) on the REST server.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { AnnotationStore } from \"../../core/annotation-store.js\";\nimport { CLIError, ErrorCategory } from \"../../utils/errors.js\";\nimport { annotationContentSchema, annotationIdSchema, annotationTagsSchema } from \"./annotation-shared.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\n\nconst inputSchema = {\n  annotationId: annotationIdSchema,\n  content: annotationContentSchema.optional(),\n  tags: annotationTagsSchema,\n  resolved: z.boolean().optional().describe(\"Mark the annotation resolved or unresolved.\"),\n  rootPath: rootPathSchema,\n};\n\nexport type AnnotationUpdateArgs = z.infer<z.ZodObject<typeof inputSchema>>;\n\nexport async function annotationUpdateHandler(args: AnnotationUpdateArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    if (args.content === undefined && args.tags === undefined && args.resolved === undefined) {\n      throw new CLIError(\"At least one of content, tags, or resolved must be provided\", ErrorCategory.USER);\n    }\n\n    const model = await loadModel(args.rootPath);\n    const store = new AnnotationStore(model.rootPath);\n    const updated = await store.update(args.annotationId, {\n      content: args.content,\n      tags: args.tags,\n      resolved: args.resolved,\n    });\n\n    if (!updated) {\n      throw new CLIError(`Annotation ${args.annotationId} not found`, ErrorCategory.NOT_FOUND, [\n        'Use \"annotation_list\" to find existing annotations',\n      ]);\n    }\n\n    return jsonResult(updated);\n  });\n}\n\nexport const annotationUpdateTool: McpToolDefinition<typeof inputSchema> = {\n  name: \"annotation_update\",\n  description: \"Partially update an annotation's content, tags, or resolved state.\",\n  inputSchema,\n  handler: annotationUpdateHandler,\n};\n"],
+  "mappings": "AAMA,SAAS,SAAS;AAElB,SAAS,uBAAuB;AAChC,SAAS,UAAU,qBAAqB;AACxC,SAAS,yBAAyB,oBAAoB,4BAA4B;AAClF,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AAEvF,MAAM,cAAc;EAClB,cAAc;EACd,SAAS,wBAAwB,SAAQ;EACzC,MAAM;EACN,UAAU,EAAE,QAAO,EAAG,SAAQ,EAAG,SAAS,6CAA6C;EACvF,UAAU;;AAKZ,eAAsB,wBAAwB,MAA0B;AACtE,SAAO,QAAQ,YAAW;AACxB,QAAI,KAAK,YAAY,UAAa,KAAK,SAAS,UAAa,KAAK,aAAa;AAC7E,YAAM,IAAI,SAAS,+DAA+D,cAAc,IAAI;AAGtG,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GAErC,UAAU,MADF,IAAI,gBAAgB,MAAM,QAAQ,EACpB,OAAO,KAAK,cAAc;MACpD,SAAS,KAAK;MACd,MAAM,KAAK;MACX,UAAU,KAAK;KAChB;AAED,QAAI,CAAC;AACH,YAAM,IAAI,SAAS,cAAc,KAAK,YAAY,cAAc,cAAc,WAAW;QACvF;OACD;AAGH,WAAO,WAAW,OAAO;EAC3B,CAAC;AACH;AAEO,MAAM,uBAA8D;EACzE,MAAM;EACN,aAAa;EACb;EACA,SAAS;;",
+  "names": []
+}

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

@@ -0,0 +1,78 @@
+import { z } from "zod";
+import { AnnotationStore } from "../../core/annotation-store.js";
+import { buildBrief, computeImpact, DEFAULT_HUB_THRESHOLD } from "../../core/changeset-analysis.js";
+import { briefDelta } from "../../core/changeset-brief-delta.js";
+import { describeDrift } from "../../core/changeset-base-index.js";
+import { getErrorMessage } from "../../utils/errors.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+import { loadChangesetGraph } from "./changeset-shared.js";
+const changesetIdSchema = z.string().optional().describe("Changeset ID or name. Defaults to the active changeset."), impactInputSchema = {
+  changesetId: changesetIdSchema,
+  depth: z.number().int().min(1).max(6).optional().describe("Hops to walk out from the changed elements (default 2)."),
+  maxElements: z.number().int().positive().optional().describe("Stop after this many reached elements (default 200)."),
+  from: z.array(z.string()).optional().describe("Element ids or paths to walk from instead of every changed element. Ids the projected model does not have are listed in unknownFrom."),
+  hubThreshold: z.number().int().min(0).optional().describe(`An element with more relationships than this is a hub: listed in hubs with its degree and not walked through (default ${DEFAULT_HUB_THRESHOLD}).`),
+  expandHubs: z.boolean().optional().describe("Walk through hubs too (default false)."),
+  rootPath: rootPathSchema
+};
+async function changesetImpactHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), { changeset, graph } = await loadChangesetGraph(model, args.changesetId), report = computeImpact(graph, {
+      depth: args.depth,
+      maxElements: args.maxElements,
+      from: args.from,
+      hubThreshold: args.hubThreshold,
+      expandHubs: args.expandHubs
+    });
+    return jsonResult({ changeset: { id: changeset.id, name: changeset.name }, ...report });
+  });
+}
+const changesetImpactTool = {
+  name: "changeset_impact",
+  description: "Walk the model outward from everything a changeset adds, changes or removes (relationships included), or from the elements named in `from`, and list the existing elements it reaches, by layer, with how each was reached and its source files, plus how many each hop reached (perHop). These are what the change can break or must update. Hubs (elements with more than hubThreshold relationships) are listed with their degree and not walked through unless expandHubs is set.",
+  inputSchema: impactInputSchema,
+  handler: changesetImpactHandler
+}, briefInputSchema = {
+  changesetId: changesetIdSchema,
+  unwired: z.enum(["summary", "full", "none"]).optional().describe("Unwired connections (catalog connections an added or updated element has no relationship for): summary (default) counts them per layer and lists the ones in layers the change already reaches whose other type the model has (existing or added), counting the rest as typesNotInModel; full lists them all; none omits them."),
+  unwiredLayers: z.array(z.string()).optional().describe("Only show unwired connections whose other end is in these layers (and list them)."),
+  since: z.union([z.number().int().min(-1), z.string().regex(/^(-1|\d+):[0-9a-f]+$/, "a revisionToken from a brief")]).optional().describe("A revision (or, better, the revisionToken) an earlier brief returned. Adds a delta: elements added, removed or updated (with the fields), relationships added or removed, changes unstaged, gaps opened and closed, unwired connections wired, layers newly reached or no longer reached, intent newly traced since then. Unstaging does not invalidate it. With the token, the delta warns when a change up to that revision was rewritten in place since."),
+  rootPath: rootPathSchema
+};
+async function changesetBriefHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), { manager, changeset, graph } = await loadChangesetGraph(model, args.changesetId), annotations = await new AnnotationStore(model.rootPath).list();
+    let drift;
+    if (changeset.status === "staged") {
+      let hash;
+      try {
+        hash = await manager.detectDrift(changeset.id);
+      } catch (error) {
+        hash = { isDrifted: !1, warnings: [`Drift check failed: ${getErrorMessage(error)}`] };
+      }
+      try {
+        drift = await describeDrift(model, graph, hash);
+      } catch (error) {
+        drift = {
+          isDrifted: hash.isDrifted,
+          warnings: [...hash.warnings, `Could not name what drifted: ${getErrorMessage(error)}`]
+        };
+      }
+    }
+    const brief = buildBrief({ graph, annotations, drift, unwired: args.unwired, unwiredLayers: args.unwiredLayers });
+    return args.since === void 0 ? jsonResult(brief, { compact: !0 }) : jsonResult({ ...brief, delta: await briefDelta(model, { graph, brief }, args.since) }, { compact: !0 });
+  });
+}
+const changesetBriefTool = {
+  name: "changeset_brief",
+  description: "Render a changeset as the spec for its change: every added, updated and deleted element by layer with its connections; which layers the change reaches and which it does not; gaps (unconnected additions, missing required relationships, connections its peers have); unwired connections (every catalog connection an added or updated element has no relationship for, by the other end's layer, with how many elements of the other type exist); changes that trace to no goal, requirement or feature; the source files touched; open review annotations; and how the base drifted since the changeset was created (staged adds the base already has are counted as alreadyInBase, apart from the adds). It returns a revision and a revisionToken: pass the token back as since on the next pass to get what changed. Use it to pressure-test a plan and as the input to building it.",
+  inputSchema: briefInputSchema,
+  handler: changesetBriefHandler
+};
+export {
+  changesetBriefHandler,
+  changesetBriefTool,
+  changesetImpactHandler,
+  changesetImpactTool
+};
+//# sourceMappingURL=changeset-analysis-tools.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/changeset-analysis-tools.ts"],
+  "sourcesContent": ["/**\n * changeset_impact, changeset_brief \u2014 pressure-test a planned change against the model.\n * See `cli/src/core/changeset-analysis.ts` and docs/CHANGE_MODELING.md.\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { AnnotationStore } from \"../../core/annotation-store.js\";\nimport { buildBrief, computeImpact, DEFAULT_HUB_THRESHOLD, type BriefDrift } from \"../../core/changeset-analysis.js\";\nimport { briefDelta } from \"../../core/changeset-brief-delta.js\";\nimport { describeDrift } from \"../../core/changeset-base-index.js\";\nimport { getErrorMessage } from \"../../utils/errors.js\";\nimport { jsonResult, loadModel, rootPathSchema, runTool, type McpToolDefinition } from \"./shared.js\";\nimport { loadChangesetGraph } from \"./changeset-shared.js\";\n\nconst changesetIdSchema = z.string().optional().describe(\"Changeset ID or name. Defaults to the active changeset.\");\n\n// ---------------------------------------------------------------------------\n// changeset_impact\n// ---------------------------------------------------------------------------\n\nconst impactInputSchema = {\n  changesetId: changesetIdSchema,\n  depth: z.number().int().min(1).max(6).optional().describe(\"Hops to walk out from the changed elements (default 2).\"),\n  maxElements: z.number().int().positive().optional().describe(\"Stop after this many reached elements (default 200).\"),\n  from: z\n    .array(z.string())\n    .optional()\n    .describe(\n      \"Element ids or paths to walk from instead of every changed element. Ids the projected model does not have \" +\n        \"are listed in unknownFrom.\"\n    ),\n  hubThreshold: z\n    .number()\n    .int()\n    .min(0)\n    .optional()\n    .describe(\n      `An element with more relationships than this is a hub: listed in hubs with its degree and not walked ` +\n        `through (default ${DEFAULT_HUB_THRESHOLD}).`\n    ),\n  expandHubs: z.boolean().optional().describe(\"Walk through hubs too (default false).\"),\n  rootPath: rootPathSchema,\n};\n\nexport type ChangesetImpactArgs = z.infer<z.ZodObject<typeof impactInputSchema>>;\n\nexport async function changesetImpactHandler(args: ChangesetImpactArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const { changeset, graph } = await loadChangesetGraph(model, args.changesetId);\n    const report = computeImpact(graph, {\n      depth: args.depth,\n      maxElements: args.maxElements,\n      from: args.from,\n      hubThreshold: args.hubThreshold,\n      expandHubs: args.expandHubs,\n    });\n    return jsonResult({ changeset: { id: changeset.id, name: changeset.name }, ...report });\n  });\n}\n\nexport const changesetImpactTool: McpToolDefinition<typeof impactInputSchema> = {\n  name: \"changeset_impact\",\n  description:\n    \"Walk the model outward from everything a changeset adds, changes or removes (relationships included), or \" +\n    \"from the elements named in `from`, and list the existing elements it reaches, by layer, with how each was \" +\n    \"reached and its source files, plus how many each hop reached (perHop). These are what the change can break \" +\n    \"or must update. Hubs (elements with more than hubThreshold relationships) are listed with their degree and \" +\n    \"not walked through unless expandHubs is set.\",\n  inputSchema: impactInputSchema,\n  handler: changesetImpactHandler,\n};\n\n// ---------------------------------------------------------------------------\n// changeset_brief\n// ---------------------------------------------------------------------------\n\nconst briefInputSchema = {\n  changesetId: changesetIdSchema,\n  unwired: z\n    .enum([\"summary\", \"full\", \"none\"])\n    .optional()\n    .describe(\n      \"Unwired connections (catalog connections an added or updated element has no relationship for): summary \" +\n        \"(default) counts them per layer and lists the ones in layers the change already reaches whose other type \" +\n        \"the model has (existing or added), counting the rest as typesNotInModel; full lists them all; none omits them.\"\n    ),\n  unwiredLayers: z\n    .array(z.string())\n    .optional()\n    .describe(\"Only show unwired connections whose other end is in these layers (and list them).\"),\n  since: z\n    .union([z.number().int().min(-1), z.string().regex(/^(-1|\\d+):[0-9a-f]+$/, \"a revisionToken from a brief\")])\n    .optional()\n    .describe(\n      \"A revision (or, better, the revisionToken) an earlier brief returned. Adds a delta: elements added, removed \" +\n        \"or updated (with the fields), relationships added or removed, changes unstaged, gaps opened and closed, \" +\n        \"unwired connections wired, layers newly reached or no longer reached, intent newly traced since then. \" +\n        \"Unstaging does not invalidate it. With the token, the delta warns when a change up to that revision was \" +\n        \"rewritten in place since.\"\n    ),\n  rootPath: rootPathSchema,\n};\n\nexport type ChangesetBriefArgs = z.infer<z.ZodObject<typeof briefInputSchema>>;\n\nexport async function changesetBriefHandler(args: ChangesetBriefArgs): Promise<CallToolResult> {\n  return runTool(async () => {\n    const model = await loadModel(args.rootPath);\n    const { manager, changeset, graph } = await loadChangesetGraph(model, args.changesetId);\n\n    const annotations = await new AnnotationStore(model.rootPath).list();\n\n    let drift: BriefDrift | undefined;\n    if (changeset.status === \"staged\") {\n      // Each part is reported on failure and the brief goes on: the hash check, then the structured view.\n      let hash: { isDrifted: boolean; warnings: string[]; baseSnapshotId?: string; currentSnapshotId?: string };\n      try {\n        hash = await manager.detectDrift(changeset.id);\n      } catch (error) {\n        hash = { isDrifted: false, warnings: [`Drift check failed: ${getErrorMessage(error)}`] };\n      }\n      try {\n        drift = await describeDrift(model, graph, hash);\n      } catch (error) {\n        drift = {\n          isDrifted: hash.isDrifted,\n          warnings: [...hash.warnings, `Could not name what drifted: ${getErrorMessage(error)}`],\n        };\n      }\n    }\n\n    const brief = buildBrief({ graph, annotations, drift, unwired: args.unwired, unwiredLayers: args.unwiredLayers });\n    // The brief is the largest result: same JSON, short objects kept on one line.\n    if (args.since === undefined) return jsonResult(brief, { compact: true });\n    return jsonResult({ ...brief, delta: await briefDelta(model, { graph, brief }, args.since) }, { compact: true });\n  });\n}\n\nexport const changesetBriefTool: McpToolDefinition<typeof briefInputSchema> = {\n  name: \"changeset_brief\",\n  description:\n    \"Render a changeset as the spec for its change: every added, updated and deleted element by layer with its \" +\n    \"connections; which layers the change reaches and which it does not; gaps (unconnected additions, missing \" +\n    \"required relationships, connections its peers have); unwired connections (every catalog connection an added \" +\n    \"or updated element has no relationship for, by the other end's layer, with how many elements of the other \" +\n    \"type exist); changes that trace to no goal, requirement or feature; the source files touched; open review \" +\n    \"annotations; and how the base drifted since the changeset was created (staged adds the base already has are \" +\n    \"counted as alreadyInBase, apart from the adds). It returns a revision and a revisionToken: pass the token back \" +\n    \"as since on the next pass to get what changed. Use it to pressure-test a plan and as the input to building it.\",\n  inputSchema: briefInputSchema,\n  handler: changesetBriefHandler,\n};\n"],
+  "mappings": "AAKA,SAAS,SAAS;AAElB,SAAS,uBAAuB;AAChC,SAAS,YAAY,eAAe,6BAA8C;AAClF,SAAS,kBAAkB;AAC3B,SAAS,qBAAqB;AAC9B,SAAS,uBAAuB;AAChC,SAAS,YAAY,WAAW,gBAAgB,eAAuC;AACvF,SAAS,0BAA0B;AAEnC,MAAM,oBAAoB,EAAE,OAAM,EAAG,SAAQ,EAAG,SAAS,yDAAyD,GAM5G,oBAAoB;EACxB,aAAa;EACb,OAAO,EAAE,OAAM,EAAG,IAAG,EAAG,IAAI,CAAC,EAAE,IAAI,CAAC,EAAE,SAAQ,EAAG,SAAS,yDAAyD;EACnH,aAAa,EAAE,OAAM,EAAG,IAAG,EAAG,SAAQ,EAAG,SAAQ,EAAG,SAAS,sDAAsD;EACnH,MAAM,EACH,MAAM,EAAE,OAAM,CAAE,EAChB,SAAQ,EACR,SACC,sIAC8B;EAElC,cAAc,EACX,OAAM,EACN,IAAG,EACH,IAAI,CAAC,EACL,SAAQ,EACR,SACC,yHACsB,qBAAqB,IAAI;EAEnD,YAAY,EAAE,QAAO,EAAG,SAAQ,EAAG,SAAS,wCAAwC;EACpF,UAAU;;AAKZ,eAAsB,uBAAuB,MAAyB;AACpE,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GACrC,EAAE,WAAW,MAAK,IAAK,MAAM,mBAAmB,OAAO,KAAK,WAAW,GACvE,SAAS,cAAc,OAAO;MAClC,OAAO,KAAK;MACZ,aAAa,KAAK;MAClB,MAAM,KAAK;MACX,cAAc,KAAK;MACnB,YAAY,KAAK;KAClB;AACD,WAAO,WAAW,EAAE,WAAW,EAAE,IAAI,UAAU,IAAI,MAAM,UAAU,KAAI,GAAI,GAAG,OAAM,CAAE;EACxF,CAAC;AACH;AAEO,MAAM,sBAAmE;EAC9E,MAAM;EACN,aACE;EAKF,aAAa;EACb,SAAS;GAOL,mBAAmB;EACvB,aAAa;EACb,SAAS,EACN,KAAK,CAAC,WAAW,QAAQ,MAAM,CAAC,EAChC,SAAQ,EACR,SACC,gUAEkH;EAEtH,eAAe,EACZ,MAAM,EAAE,OAAM,CAAE,EAChB,SAAQ,EACR,SAAS,mFAAmF;EAC/F,OAAO,EACJ,MAAM,CAAC,EAAE,OAAM,EAAG,IAAG,EAAG,IAAI,EAAE,GAAG,EAAE,OAAM,EAAG,MAAM,wBAAwB,8BAA8B,CAAC,CAAC,EAC1G,SAAQ,EACR,SACC,6bAI6B;EAEjC,UAAU;;AAKZ,eAAsB,sBAAsB,MAAwB;AAClE,SAAO,QAAQ,YAAW;AACxB,UAAM,QAAQ,MAAM,UAAU,KAAK,QAAQ,GACrC,EAAE,SAAS,WAAW,MAAK,IAAK,MAAM,mBAAmB,OAAO,KAAK,WAAW,GAEhF,cAAc,MAAM,IAAI,gBAAgB,MAAM,QAAQ,EAAE,KAAI;AAElE,QAAI;AACJ,QAAI,UAAU,WAAW,UAAU;AAEjC,UAAI;AACJ,UAAI;AACF,eAAO,MAAM,QAAQ,YAAY,UAAU,EAAE;MAC/C,SAAS,OAAO;AACd,eAAO,EAAE,WAAW,IAAO,UAAU,CAAC,uBAAuB,gBAAgB,KAAK,CAAC,EAAE,EAAC;MACxF;AACA,UAAI;AACF,gBAAQ,MAAM,cAAc,OAAO,OAAO,IAAI;MAChD,SAAS,OAAO;AACd,gBAAQ;UACN,WAAW,KAAK;UAChB,UAAU,CAAC,GAAG,KAAK,UAAU,gCAAgC,gBAAgB,KAAK,CAAC,EAAE;;MAEzF;IACF;AAEA,UAAM,QAAQ,WAAW,EAAE,OAAO,aAAa,OAAO,SAAS,KAAK,SAAS,eAAe,KAAK,cAAa,CAAE;AAEhH,WAAI,KAAK,UAAU,SAAkB,WAAW,OAAO,EAAE,SAAS,GAAI,CAAE,IACjE,WAAW,EAAE,GAAG,OAAO,OAAO,MAAM,WAAW,OAAO,EAAE,OAAO,MAAK,GAAI,KAAK,KAAK,EAAC,GAAI,EAAE,SAAS,GAAI,CAAE;EACjH,CAAC;AACH;AAEO,MAAM,qBAAiE;EAC5E,MAAM;EACN,aACE;EAQF,aAAa;EACb,SAAS;;",
+  "names": []
+}

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

@@ -0,0 +1,184 @@
+import { z } from "zod";
+import { ChangesetGraph } from "../../core/changeset-graph.js";
+import { StagingAreaManager } from "../../core/staging-area.js";
+import { stagedRelationshipChangesAtEnds, stagedRelationshipTriple } from "../../core/relationship-staging.js";
+import { CLIError, ErrorCategory, getErrorMessage } from "../../utils/errors.js";
+import { jsonResult, loadModel, reloadModel, rootPathSchema, runTool } from "./shared.js";
+import { resolveChangeset } from "./changeset-shared.js";
+const changesetIdSchema = z.string().optional().describe("Changeset ID or name. Defaults to the active changeset.");
+function requireStaged(changeset, action) {
+  if (changeset.status !== "staged")
+    throw new CLIError(`Changeset '${changeset.name}' is ${changeset.status}; cannot ${action}`, ErrorCategory.USER, [
+      'Use "changeset_list" to find a staged changeset, or "changeset_create" to start a new one'
+    ]);
+}
+async function asUserError(fn, suggestions) {
+  try {
+    return await fn();
+  } catch (error) {
+    throw error instanceof CLIError ? error : new CLIError(getErrorMessage(error), ErrorCategory.USER, suggestions);
+  }
+}
+function summarize(change) {
+  const triple = change.type.startsWith("relationship-") ? stagedRelationshipTriple(change) : null;
+  return {
+    type: change.type,
+    elementId: change.elementId,
+    layer: change.layerName,
+    ...triple ? { relationship: triple } : {}
+  };
+}
+const updateInputSchema = {
+  changesetId: changesetIdSchema,
+  name: z.string().min(1).optional().describe("New name. Must not be another changeset's name."),
+  description: z.string().optional().describe("New description: the change's intent and what done looks like. An empty string clears it."),
+  rootPath: rootPathSchema
+};
+async function changesetUpdateHandler(args) {
+  return runTool(async () => {
+    if (args.name === void 0 && args.description === void 0)
+      throw new CLIError("Nothing to update", ErrorCategory.USER, ['Pass "name" and/or "description"']);
+    const model = await loadModel(args.rootPath), manager = new StagingAreaManager(model.rootPath, model), changeset = await resolveChangeset(manager, args.changesetId), updated = await asUserError(() => manager.update(changeset.id, { name: args.name, description: args.description }), ['Use "changeset_list" to see the names already taken']);
+    return await reloadModel(args.rootPath), jsonResult({
+      id: updated.id,
+      name: updated.name,
+      ...changeset.name !== updated.name ? { previousName: changeset.name } : {},
+      description: updated.description ?? null,
+      status: updated.status,
+      changes: updated.changes.length
+    });
+  });
+}
+const changesetUpdateTool = {
+  name: "changeset_update",
+  description: "Rename a changeset or change its description (the change's intent). Staged changes are untouched. Defaults to the active changeset.",
+  inputSchema: updateInputSchema,
+  handler: changesetUpdateHandler
+}, unstageInputSchema = {
+  changesetId: changesetIdSchema,
+  elementId: z.string().optional().describe("Drop every staged change to this element (its add, updates or delete). ID or path."),
+  source: z.string().optional().describe("Drop staged relationship changes (adds and deletes) from this element: to target when given, otherwise to any element. The element's own changes are not touched."),
+  target: z.string().optional().describe("Drop staged relationship changes (adds and deletes) to this element: from source when given, otherwise from any element. The element's own changes are not touched."),
+  predicate: z.string().optional().describe("Only relationship changes with this predicate. Omit for any."),
+  keepRelationships: z.boolean().optional().describe("With elementId: keep the staged relationship changes that depend on the element's change. By default, unstaging an element's add also drops staged relationships to it (they would dangle), and unstaging its delete also drops the relationship removals its cascade staged (removals staged before the delete are kept)."),
+  rootPath: rootPathSchema
+};
+function describeEnds(args) {
+  return args.source && args.target ? `from ${args.source} to ${args.target}` : args.source ? `from ${args.source}` : `to ${args.target}`;
+}
+async function changesetUnstageHandler(args) {
+  return runTool(async () => {
+    const byElement = args.elementId !== void 0, byRelationship = args.source !== void 0 || args.target !== void 0;
+    if (byElement === byRelationship)
+      throw new CLIError("Name either an element or a relationship to unstage", ErrorCategory.USER, [
+        `Pass "elementId" to drop an element's staged changes`,
+        'Or pass "source" and/or "target" (and optionally "predicate") to drop staged relationship changes'
+      ]);
+    if (byRelationship && !args.source && !args.target)
+      throw new CLIError('"source" or "target" must not be empty', ErrorCategory.USER);
+    const model = await loadModel(args.rootPath), manager = new StagingAreaManager(model.rootPath, model), changeset = await resolveChangeset(manager, args.changesetId);
+    requireStaged(changeset, "unstage changes");
+    const graph = await ChangesetGraph.build(model, changeset), changes = changeset.changes, keys = /* @__PURE__ */ new Set(), notes = [];
+    if (byElement) {
+      const element = graph.getElement(args.elementId), ids = /* @__PURE__ */ new Set([args.elementId, ...element ? [element.id, element.uuid ?? element.id] : []]), own = changes.filter((c) => !c.type.startsWith("relationship-") && ids.has(c.elementId));
+      for (const change of own)
+        keys.add(change.elementId);
+      const dependentType = own.some((c) => c.type === "add") ? "relationship-add" : own.some((c) => c.type === "delete") ? "relationship-delete" : null, touching = dependentType ? changes.filter((c) => {
+        if (c.type !== dependentType)
+          return !1;
+        const triple = stagedRelationshipTriple(c);
+        return !!triple && (ids.has(triple.source) || ids.has(triple.target) || element && (graph.resolve(triple.source) === element.id || graph.resolve(triple.target) === element.id));
+      }) : [], seq = (c) => c.sequenceNumber ?? changes.indexOf(c), deleteSeqs = own.filter((c) => c.type === "delete").map(seq), firstDelete = deleteSeqs.length > 0 ? Math.min(...deleteSeqs) : -1, dependent = dependentType === "relationship-delete" ? touching.filter((c) => seq(c) > firstDelete) : touching, deliberate = touching.filter((c) => !dependent.includes(c));
+      if (deliberate.length > 0 && notes.push(`${deliberate.length} relationship removal(s) on ${args.elementId} staged before its delete were kept (${deliberate.map((c) => c.elementId).join(", ")}); unstage them by source and target if they should go too`), dependent.length > 0)
+        if (args.keepRelationships)
+          notes.push(`${dependent.length} staged relationship change(s) on ${args.elementId} were kept (keepRelationships)` + (dependentType === "relationship-add" ? "; they will dangle unless the element is staged again" : ""));
+        else
+          for (const change of dependent)
+            keys.add(change.elementId);
+    } else {
+      const matched = stagedRelationshipChangesAtEnds(graph, changeset, {
+        source: args.source || void 0,
+        target: args.target || void 0,
+        predicate: args.predicate
+      }), seq = (c) => c.sequenceNumber ?? changes.indexOf(c), deleteSeq = /* @__PURE__ */ new Map();
+      for (const change of changes) {
+        if (change.type !== "delete")
+          continue;
+        const id = graph.resolve(change.elementId);
+        deleteSeq.set(id, Math.min(deleteSeq.get(id) ?? 1 / 0, seq(change)));
+      }
+      const deletedEndOf = (change) => {
+        if (change.type !== "relationship-delete")
+          return;
+        const triple = stagedRelationshipTriple(change);
+        if (triple)
+          return [graph.resolve(triple.source), graph.resolve(triple.target)].find((end) => deleteSeq.has(end) && deleteSeq.get(end) < seq(change));
+      }, cascaded = matched.filter((c) => deletedEndOf(c) !== void 0), deletedEnds = [...new Set(cascaded.map((c) => deletedEndOf(c)))].join(", "), cascadeList = cascaded.map((c) => c.elementId).join(", "), bothEnds = !!args.source && !!args.target;
+      for (const change of matched)
+        !bothEnds && cascaded.includes(change) || keys.add(change.elementId);
+      cascaded.length > 0 && bothEnds ? notes.push(`Unstaged ${cascaded.length} relationship removal(s) cascaded from the staged delete of ${deletedEnds} (${cascadeList}): those relationships now dangle, so the changeset will not commit until they are removed again or the delete is unstaged ("changeset_unstage" with elementId)`) : cascaded.length > 0 && notes.push(`Kept ${cascaded.length} relationship removal(s) cascaded from the staged delete of ${deletedEnds} (${cascadeList}): dropping them would leave those relationships dangling. Unstage the delete ("changeset_unstage" with elementId) to restore them, or name both source and target to drop one anyway`);
+    }
+    const removed = changes.filter((c) => keys.has(c.elementId));
+    if (removed.length === 0)
+      return jsonResult({
+        status: "not-staged",
+        changeset: changeset.name,
+        message: byElement ? `No staged change to ${args.elementId} in '${changeset.name}'` : `No staged relationship change ${describeEnds(args)}${args.predicate ? ` (${args.predicate})` : ""} in '${changeset.name}'`,
+        suggestions: ['Use "changeset_show" to list the staged changes'],
+        ...notes.length > 0 ? { notes } : {}
+      });
+    for (const key of keys)
+      await manager.unstage(changeset.id, key);
+    return await reloadModel(args.rootPath), jsonResult({
+      status: "unstaged",
+      changeset: changeset.name,
+      unstaged: removed.map(summarize),
+      remainingChanges: changes.length - removed.length,
+      ...notes.length > 0 ? { notes } : {}
+    });
+  });
+}
+const changesetUnstageTool = {
+  name: "changeset_unstage",
+  description: "Undo part of a staged changeset: drop the staged changes to one element (elementId), or the staged relationship adds/deletes between source and target, or every one from source alone or to target alone (optionally one predicate). The base model is not touched. Defaults to the active changeset. Use changeset_show to see what is staged.",
+  inputSchema: unstageInputSchema,
+  handler: changesetUnstageHandler
+}, discardInputSchema = {
+  changesetId: z.string().describe("Changeset ID or name to discard. Required: discard is never implied."),
+  confirm: z.boolean().describe("Must be true. Discarding deletes the changeset's staged changes permanently (only its name, description and a 'discarded' status remain), so confirm only when the plan is to be abandoned."),
+  rootPath: rootPathSchema
+};
+async function changesetDiscardHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), manager = new StagingAreaManager(model.rootPath, model), changeset = await resolveChangeset(manager, args.changesetId);
+    if (requireStaged(changeset, "discard it"), args.confirm !== !0)
+      throw new CLIError(`Discarding '${changeset.name}' deletes its ${changeset.changes.length} staged change(s) permanently`, ErrorCategory.USER, [
+        'Pass "confirm": true to discard it',
+        'Use "changeset_unstage" to drop individual changes instead',
+        'Use "changeset_deactivate" to stop staging into it and keep its changes'
+      ]);
+    const wasActive = await manager.getActiveId() === changeset.id, discardedChanges = changeset.changes.length;
+    return await manager.discard(changeset.id), wasActive && await manager.clearActive(), await reloadModel(args.rootPath), jsonResult({
+      id: changeset.id,
+      name: changeset.name,
+      status: "discarded",
+      discardedChanges,
+      deactivated: wasActive
+    });
+  });
+}
+const changesetDiscardTool = {
+  name: "changeset_discard",
+  description: "Abandon a staged changeset: PERMANENTLY deletes its staged changes and marks it discarded (deactivating it if active). Not recoverable, so it requires confirm: true. The base model is not touched. To undo part of a plan use changeset_unstage; to pause it use changeset_deactivate.",
+  inputSchema: discardInputSchema,
+  handler: changesetDiscardHandler
+};
+export {
+  changesetDiscardHandler,
+  changesetDiscardTool,
+  changesetUnstageHandler,
+  changesetUnstageTool,
+  changesetUpdateHandler,
+  changesetUpdateTool
+};
+//# sourceMappingURL=changeset-editing.js.map