@documentation-robotics/cli 0.1.13 → 0.2.0

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-list.js

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

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

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

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

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { StagingAreaManager } from "../../core/staging-area.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."),
+  rootPath: rootPathSchema
+};
+async function changesetShowHandler(args) {
+  return runTool(async () => {
+    const model = await loadModel(args.rootPath), changeset = await new StagingAreaManager(model.rootPath, model).load(args.changesetId);
+    if (!changeset)
+      throw new CLIError(`Changeset ${args.changesetId} not found`, ErrorCategory.NOT_FOUND, [
+        'Use "changeset_list" to see all available changesets'
+      ]);
+    return jsonResult({
+      id: changeset.id,
+      name: changeset.name,
+      description: changeset.description,
+      status: changeset.status,
+      created: changeset.created,
+      modified: changeset.modified,
+      baseSnapshot: changeset.baseSnapshot,
+      stats: changeset.stats,
+      changes: changeset.changes
+    });
+  });
+}
+const changesetShowTool = {
+  name: "changeset_show",
+  description: "Show a single changeset's full detail including its description, stats, and list of changes.",
+  inputSchema,
+  handler: changesetShowHandler
+};
+export {
+  changesetShowHandler,
+  changesetShowTool
+};
+//# sourceMappingURL=changeset-show.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/changeset-show.ts"],
+  "sourcesContent": ["/**\n * changeset_show \u2014 show a single changeset's full detail, including its list\n * of changes. Mirrors the REST `GET /api/changesets/:changesetId` endpoint\n * (see `ChangesetDetailSchema` in `cli/src/server/schemas.ts`).\n */\n\nimport { z } from \"zod\";\nimport type { CallToolResult } from \"@modelcontextprotocol/sdk/types.js\";\nimport { StagingAreaManager } from \"../../core/staging-area.js\";\nimport { 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;;",
+  "names": []
+}

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

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

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

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

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

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

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

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

package/dist/mcp/tools/index.js

@@ -0,0 +1,47 @@
+import { annotationListTool } from "./annotation-list.js";
+import { annotationGetTool } from "./annotation-get.js";
+import { annotationCreateTool } from "./annotation-create.js";
+import { annotationUpdateTool } from "./annotation-update.js";
+import { annotationDeleteTool } from "./annotation-delete.js";
+import { annotationReplyTool } from "./annotation-reply.js";
+import { modelListTool } from "./model-list.js";
+import { modelShowTool } from "./model-show.js";
+import { modelSearchTool } from "./model-search.js";
+import { modelStatsTool } from "./model-stats.js";
+import { modelInfoTool } from "./model-info.js";
+import { modelTraceTool } from "./model-trace.js";
+import { modelAddTool } from "./model-add.js";
+import { modelUpdateTool } from "./model-update.js";
+import { modelDeleteTool } from "./model-delete.js";
+import { modelValidateTool } from "./model-validate.js";
+import { modelExportTool } from "./model-export.js";
+import { modelReloadTool } from "./model-reload.js";
+import { changesetListTool } from "./changeset-list.js";
+import { changesetShowTool } from "./changeset-show.js";
+import { chatStatusTool } from "./chat-status.js";
+import { chatLaunchTool } from "./chat-launch.js";
+export {
+  annotationCreateTool,
+  annotationDeleteTool,
+  annotationGetTool,
+  annotationListTool,
+  annotationReplyTool,
+  annotationUpdateTool,
+  changesetListTool,
+  changesetShowTool,
+  chatLaunchTool,
+  chatStatusTool,
+  modelAddTool,
+  modelDeleteTool,
+  modelExportTool,
+  modelInfoTool,
+  modelListTool,
+  modelReloadTool,
+  modelSearchTool,
+  modelShowTool,
+  modelStatsTool,
+  modelTraceTool,
+  modelUpdateTool,
+  modelValidateTool
+};
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/tools/index.ts"],
+  "sourcesContent": ["export { annotationListTool } from \"./annotation-list.js\";\nexport { annotationGetTool } from \"./annotation-get.js\";\nexport { annotationCreateTool } from \"./annotation-create.js\";\nexport { annotationUpdateTool } from \"./annotation-update.js\";\nexport { annotationDeleteTool } from \"./annotation-delete.js\";\nexport { annotationReplyTool } from \"./annotation-reply.js\";\nexport { modelListTool } from \"./model-list.js\";\nexport { modelShowTool } from \"./model-show.js\";\nexport { modelSearchTool } from \"./model-search.js\";\nexport { modelStatsTool } from \"./model-stats.js\";\nexport { modelInfoTool } from \"./model-info.js\";\nexport { modelTraceTool } from \"./model-trace.js\";\nexport { modelAddTool } from \"./model-add.js\";\nexport { modelUpdateTool } from \"./model-update.js\";\nexport { modelDeleteTool } from \"./model-delete.js\";\nexport { modelValidateTool } from \"./model-validate.js\";\nexport { modelExportTool } from \"./model-export.js\";\nexport { modelReloadTool } from \"./model-reload.js\";\nexport { changesetListTool } from \"./changeset-list.js\";\nexport { changesetShowTool } from \"./changeset-show.js\";\nexport { chatStatusTool } from \"./chat-status.js\";\nexport { chatLaunchTool } from \"./chat-launch.js\";\nexport type { McpToolDefinition } from \"./shared.js\";\n"],
+  "mappings": "AAAA,SAAS,0BAA0B;AACnC,SAAS,yBAAyB;AAClC,SAAS,4BAA4B;AACrC,SAAS,4BAA4B;AACrC,SAAS,4BAA4B;AACrC,SAAS,2BAA2B;AACpC,SAAS,qBAAqB;AAC9B,SAAS,qBAAqB;AAC9B,SAAS,uBAAuB;AAChC,SAAS,sBAAsB;AAC/B,SAAS,qBAAqB;AAC9B,SAAS,sBAAsB;AAC/B,SAAS,oBAAoB;AAC7B,SAAS,uBAAuB;AAChC,SAAS,uBAAuB;AAChC,SAAS,yBAAyB;AAClC,SAAS,uBAAuB;AAChC,SAAS,uBAAuB;AAChC,SAAS,yBAAyB;AAClC,SAAS,yBAAyB;AAClC,SAAS,sBAAsB;AAC/B,SAAS,sBAAsB;",
+  "names": []
+}

package/dist/mcp/tools/model-add.js

@@ -0,0 +1,106 @@
+import { z } from "zod";
+import { Element } from "../../core/element.js";
+import { Layer } from "../../core/layer.js";
+import { MutationHandler } from "../../core/mutation-handler.js";
+import { getAllLayerIds, isValidLayer } from "../../generated/layer-registry.js";
+import { getNodeTypesForLayer, isValidNodeType, normalizeNodeType } from "../../generated/node-types.js";
+import { generateElementId, generateUUID } from "../../utils/id-generator.js";
+import { buildSourceReference, validateSourceReferenceOptions } from "../../utils/source-reference.js";
+import { SchemaValidator } from "../../validators/schema-validator.js";
+import { CLIError, ErrorCategory, findSimilar, formatValidOptions } from "../../utils/errors.js";
+import { jsonResult, loadModel, rootPathSchema, runTool } from "./shared.js";
+const inputSchema = {
+  layer: z.string().describe("Canonical layer name (e.g. 'api', 'data-model')."),
+  type: z.string().describe("Element type within the layer (e.g. 'operation', 'entity')."),
+  name: z.string().describe("Human-readable element name; used to derive the element ID."),
+  description: z.string().optional(),
+  attributes: z.record(z.string(), z.unknown()).optional().describe("Type-specific attributes, validated against the element's spec schema."),
+  sourceFile: z.string().optional().describe("Source file path relative to the repository root."),
+  sourceSymbol: z.string().optional(),
+  sourceProvenance: z.enum(["extracted", "manual", "inferred", "generated"]).optional(),
+  sourceRepoRemote: z.string().optional(),
+  sourceRepoCommit: z.string().optional().describe("Full 40-character Git commit SHA."),
+  rootPath: rootPathSchema
+};
+async function modelAddHandler(args) {
+  return runTool(async () => {
+    if (!isValidLayer(args.layer)) {
+      const validLayers = getAllLayerIds(), similar = findSimilar(args.layer, validLayers, 3), suggestions = [`Use a valid layer name: ${formatValidOptions(validLayers)}`];
+      throw similar.length > 0 && suggestions.unshift(`Did you mean: ${similar.join(" or ")}?`), new CLIError(`Unknown layer "${args.layer}"`, ErrorCategory.USER, suggestions);
+    }
+    if (!isValidNodeType(args.layer, args.type)) {
+      const typeNames = getNodeTypesForLayer(args.layer).map((t) => t.type).sort(), similar = findSimilar(args.type, typeNames, 3), suggestions = [`Valid types for ${args.layer}: ${formatValidOptions(typeNames)}`];
+      throw similar.length > 0 && suggestions.unshift(`Did you mean: ${similar.join(" or ")}?`), new CLIError(`Invalid element type "${args.type}" for layer "${args.layer}"`, ErrorCategory.USER, suggestions);
+    }
+    const resolvedType = normalizeNodeType(args.layer, args.type), elementPath = generateElementId(args.layer, resolvedType, args.name), elementUUID = generateUUID();
+    if (!elementPath.split(".")[2])
+      throw new CLIError(`Cannot generate a valid element ID from name "${args.name}"`, ErrorCategory.USER, [
+        "Element names must contain at least one letter or digit"
+      ]);
+    validateSourceReferenceOptions(args);
+    const model = await loadModel(args.rootPath);
+    let layerObj = await model.getLayer(args.layer), isNewLayer = !1;
+    layerObj || (layerObj = new Layer(args.layer), isNewLayer = !0);
+    const now = (/* @__PURE__ */ new Date()).toISOString(), element = new Element({
+      id: elementUUID,
+      path: elementPath,
+      spec_node_id: `${args.layer}.${resolvedType}`,
+      layer_id: args.layer,
+      type: resolvedType,
+      name: args.name,
+      description: args.description,
+      attributes: args.attributes ?? {},
+      metadata: {
+        created_at: now,
+        updated_at: now,
+        version: 1
+      },
+      layer: args.layer
+    }), sourceRef = buildSourceReference(args);
+    sourceRef && element.setSourceReference(sourceRef);
+    {
+      const schemaValidator = new SchemaValidator(), tempLayer = new Layer(args.layer);
+      tempLayer.addElement(element);
+      const attrValidation = await schemaValidator.validateLayer(tempLayer);
+      if (!attrValidation.isValid()) {
+        const errorMessages = attrValidation.errors.map((e) => `  ${e.message}`).join(`
+`);
+        throw new CLIError(`Element ${elementPath} has invalid attributes:
+${errorMessages}`, ErrorCategory.USER, [
+          `Use "model_info" with layer "${args.layer}" and the spec resource for "${args.type}" to see the required attributes`
+        ]);
+      }
+    }
+    if (layerObj.getElement(elementPath))
+      throw new CLIError(`Element ${elementPath} already exists in ${args.layer} layer`, ErrorCategory.USER, [
+        'Use "model_show" to view the existing element',
+        'Use "model_update" to modify it',
+        'Use "model_delete" to remove it first if you want to recreate it'
+      ]);
+    isNewLayer && model.addLayer(layerObj);
+    const mutationHandler = new MutationHandler(model, elementPath, args.layer);
+    await mutationHandler.executeAdd(element, (elem) => {
+      layerObj.addElement(elem);
+    });
+    const activeChangeset = await mutationHandler.getStagingManager().getActive(), staged = !!(activeChangeset && activeChangeset.status === "staged");
+    return jsonResult({
+      status: staged ? "staged" : "added",
+      changeset: staged ? activeChangeset.name : void 0,
+      id: elementPath,
+      layer: args.layer,
+      type: resolvedType,
+      name: args.name
+    });
+  });
+}
+const modelAddTool = {
+  name: "model_add",
+  description: "Add a new element to a layer, validated against its spec schema.",
+  inputSchema,
+  handler: modelAddHandler
+};
+export {
+  modelAddHandler,
+  modelAddTool
+};
+//# sourceMappingURL=model-add.js.map