@dexto/tools-plan 1.6.0 → 1.6.2

package/dist/tool-factory-config.cjs

@@ -0,0 +1,38 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tool_factory_config_exports = {};
+__export(tool_factory_config_exports, {
+  PLAN_TOOL_NAMES: () => PLAN_TOOL_NAMES,
+  PlanToolsConfigSchema: () => PlanToolsConfigSchema
+});
+module.exports = __toCommonJS(tool_factory_config_exports);
+var import_zod = require("zod");
+const PLAN_TOOL_NAMES = ["plan_create", "plan_read", "plan_update", "plan_review"];
+const PlanToolsConfigSchema = import_zod.z.object({
+  type: import_zod.z.literal("plan-tools"),
+  basePath: import_zod.z.string().default(".dexto/plans").describe("Base directory for plan storage (relative to working directory)"),
+  enabledTools: import_zod.z.array(import_zod.z.enum(PLAN_TOOL_NAMES)).optional().describe(
+    `Subset of tools to enable. If not specified, all tools are enabled. Available: ${PLAN_TOOL_NAMES.join(", ")}`
+  )
+}).strict();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PLAN_TOOL_NAMES,
+  PlanToolsConfigSchema
+});

package/dist/tool-factory-config.js

@@ -1,30 +1,13 @@
-/**
- * Plan Tools Factory
- *
- * Provides implementation planning tools:
- * - plan_create: Create a new plan for the session
- * - plan_read: Read the current plan
- * - plan_update: Update the existing plan
- * - plan_review: Request user review of the plan (shows plan content with approval options)
- */
-import { z } from 'zod';
-/**
- * Available plan tool names for enabledTools configuration
- */
-export const PLAN_TOOL_NAMES = ['plan_create', 'plan_read', 'plan_update', 'plan_review'];
-/**
- * Configuration schema for Plan tools factory
- */
-export const PlanToolsConfigSchema = z
-    .object({
-    type: z.literal('plan-tools'),
-    basePath: z
-        .string()
-        .default('.dexto/plans')
-        .describe('Base directory for plan storage (relative to working directory)'),
-    enabledTools: z
-        .array(z.enum(PLAN_TOOL_NAMES))
-        .optional()
-        .describe(`Subset of tools to enable. If not specified, all tools are enabled. Available: ${PLAN_TOOL_NAMES.join(', ')}`),
-})
-    .strict();
+import { z } from "zod";
+const PLAN_TOOL_NAMES = ["plan_create", "plan_read", "plan_update", "plan_review"];
+const PlanToolsConfigSchema = z.object({
+  type: z.literal("plan-tools"),
+  basePath: z.string().default(".dexto/plans").describe("Base directory for plan storage (relative to working directory)"),
+  enabledTools: z.array(z.enum(PLAN_TOOL_NAMES)).optional().describe(
+    `Subset of tools to enable. If not specified, all tools are enabled. Available: ${PLAN_TOOL_NAMES.join(", ")}`
+  )
+}).strict();
+export {
+  PLAN_TOOL_NAMES,
+  PlanToolsConfigSchema
+};

package/dist/tool-factory.cjs

@@ -0,0 +1,71 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tool_factory_exports = {};
+__export(tool_factory_exports, {
+  planToolsFactory: () => planToolsFactory
+});
+module.exports = __toCommonJS(tool_factory_exports);
+var path = __toESM(require("node:path"), 1);
+var import_plan_service = require("./plan-service.js");
+var import_plan_create_tool = require("./tools/plan-create-tool.js");
+var import_plan_read_tool = require("./tools/plan-read-tool.js");
+var import_plan_update_tool = require("./tools/plan-update-tool.js");
+var import_plan_review_tool = require("./tools/plan-review-tool.js");
+var import_tool_factory_config = require("./tool-factory-config.js");
+const planToolsFactory = {
+  configSchema: import_tool_factory_config.PlanToolsConfigSchema,
+  metadata: {
+    displayName: "Plan Tools",
+    description: "Create and manage implementation plans linked to sessions",
+    category: "planning"
+  },
+  create: (config) => {
+    const basePath = path.isAbsolute(config.basePath) ? config.basePath : path.join(process.cwd(), config.basePath);
+    let planService;
+    const getPlanService = async (context) => {
+      if (planService) {
+        return planService;
+      }
+      planService = new import_plan_service.PlanService({ basePath }, context.logger);
+      return planService;
+    };
+    const toolCreators = {
+      plan_create: () => (0, import_plan_create_tool.createPlanCreateTool)(getPlanService),
+      plan_read: () => (0, import_plan_read_tool.createPlanReadTool)(getPlanService),
+      plan_update: () => (0, import_plan_update_tool.createPlanUpdateTool)(getPlanService),
+      plan_review: () => (0, import_plan_review_tool.createPlanReviewTool)(getPlanService)
+    };
+    const toolsToCreate = config.enabledTools ?? import_tool_factory_config.PLAN_TOOL_NAMES;
+    return toolsToCreate.map((toolName) => toolCreators[toolName]());
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  planToolsFactory
+});

package/dist/tool-factory.js

@@ -1,36 +1,40 @@
-import * as path from 'node:path';
-import { PlanService } from './plan-service.js';
-import { createPlanCreateTool } from './tools/plan-create-tool.js';
-import { createPlanReadTool } from './tools/plan-read-tool.js';
-import { createPlanUpdateTool } from './tools/plan-update-tool.js';
-import { createPlanReviewTool } from './tools/plan-review-tool.js';
-import { PLAN_TOOL_NAMES, PlanToolsConfigSchema, } from './tool-factory-config.js';
-export const planToolsFactory = {
-    configSchema: PlanToolsConfigSchema,
-    metadata: {
-        displayName: 'Plan Tools',
-        description: 'Create and manage implementation plans linked to sessions',
-        category: 'planning',
-    },
-    create: (config) => {
-        const basePath = path.isAbsolute(config.basePath)
-            ? config.basePath
-            : path.join(process.cwd(), config.basePath);
-        let planService;
-        const getPlanService = async (context) => {
-            if (planService) {
-                return planService;
-            }
-            planService = new PlanService({ basePath }, context.logger);
-            return planService;
-        };
-        const toolCreators = {
-            plan_create: () => createPlanCreateTool(getPlanService),
-            plan_read: () => createPlanReadTool(getPlanService),
-            plan_update: () => createPlanUpdateTool(getPlanService),
-            plan_review: () => createPlanReviewTool(getPlanService),
-        };
-        const toolsToCreate = config.enabledTools ?? PLAN_TOOL_NAMES;
-        return toolsToCreate.map((toolName) => toolCreators[toolName]());
-    },
+import * as path from "node:path";
+import { PlanService } from "./plan-service.js";
+import { createPlanCreateTool } from "./tools/plan-create-tool.js";
+import { createPlanReadTool } from "./tools/plan-read-tool.js";
+import { createPlanUpdateTool } from "./tools/plan-update-tool.js";
+import { createPlanReviewTool } from "./tools/plan-review-tool.js";
+import {
+  PLAN_TOOL_NAMES,
+  PlanToolsConfigSchema
+} from "./tool-factory-config.js";
+const planToolsFactory = {
+  configSchema: PlanToolsConfigSchema,
+  metadata: {
+    displayName: "Plan Tools",
+    description: "Create and manage implementation plans linked to sessions",
+    category: "planning"
+  },
+  create: (config) => {
+    const basePath = path.isAbsolute(config.basePath) ? config.basePath : path.join(process.cwd(), config.basePath);
+    let planService;
+    const getPlanService = async (context) => {
+      if (planService) {
+        return planService;
+      }
+      planService = new PlanService({ basePath }, context.logger);
+      return planService;
+    };
+    const toolCreators = {
+      plan_create: () => createPlanCreateTool(getPlanService),
+      plan_read: () => createPlanReadTool(getPlanService),
+      plan_update: () => createPlanUpdateTool(getPlanService),
+      plan_review: () => createPlanReviewTool(getPlanService)
+    };
+    const toolsToCreate = config.enabledTools ?? PLAN_TOOL_NAMES;
+    return toolsToCreate.map((toolName) => toolCreators[toolName]());
+  }
+};
+export {
+  planToolsFactory
 };

package/dist/tool-factory.test.cjs

@@ -0,0 +1,96 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_tool_factory = require("./tool-factory.js");
+(0, import_vitest.describe)("planToolsFactory", () => {
+  (0, import_vitest.describe)("factory metadata", () => {
+    (0, import_vitest.it)("should have metadata", () => {
+      (0, import_vitest.expect)(import_tool_factory.planToolsFactory.metadata).toBeDefined();
+      (0, import_vitest.expect)(import_tool_factory.planToolsFactory.metadata?.displayName).toBe("Plan Tools");
+      (0, import_vitest.expect)(import_tool_factory.planToolsFactory.metadata?.category).toBe("planning");
+    });
+  });
+  (0, import_vitest.describe)("config schema", () => {
+    (0, import_vitest.it)("should validate minimal config", () => {
+      const result = import_tool_factory.planToolsFactory.configSchema.safeParse({
+        type: "plan-tools"
+      });
+      (0, import_vitest.expect)(result.success).toBe(true);
+      if (result.success) {
+        (0, import_vitest.expect)(result.data.basePath).toBe(".dexto/plans");
+      }
+    });
+    (0, import_vitest.it)("should validate config with custom basePath", () => {
+      const result = import_tool_factory.planToolsFactory.configSchema.safeParse({
+        type: "plan-tools",
+        basePath: "/custom/path"
+      });
+      (0, import_vitest.expect)(result.success).toBe(true);
+      if (result.success) {
+        (0, import_vitest.expect)(result.data.basePath).toBe("/custom/path");
+      }
+    });
+    (0, import_vitest.it)("should validate config with enabledTools", () => {
+      const result = import_tool_factory.planToolsFactory.configSchema.safeParse({
+        type: "plan-tools",
+        enabledTools: ["plan_create", "plan_read"]
+      });
+      (0, import_vitest.expect)(result.success).toBe(true);
+      if (result.success) {
+        (0, import_vitest.expect)(result.data.enabledTools).toEqual(["plan_create", "plan_read"]);
+      }
+    });
+    (0, import_vitest.it)("should reject invalid tool names", () => {
+      const result = import_tool_factory.planToolsFactory.configSchema.safeParse({
+        type: "plan-tools",
+        enabledTools: ["invalid_tool"]
+      });
+      (0, import_vitest.expect)(result.success).toBe(false);
+    });
+    (0, import_vitest.it)("should reject unknown properties", () => {
+      const result = import_tool_factory.planToolsFactory.configSchema.safeParse({
+        type: "plan-tools",
+        unknownProp: "value"
+      });
+      (0, import_vitest.expect)(result.success).toBe(false);
+    });
+  });
+  (0, import_vitest.describe)("create", () => {
+    (0, import_vitest.it)("should create all tools by default", () => {
+      const config = import_tool_factory.planToolsFactory.configSchema.parse({
+        type: "plan-tools"
+      });
+      const tools = import_tool_factory.planToolsFactory.create(config);
+      (0, import_vitest.expect)(tools).toHaveLength(4);
+      const toolIds = tools.map((t) => t.id);
+      (0, import_vitest.expect)(toolIds).toContain("plan_create");
+      (0, import_vitest.expect)(toolIds).toContain("plan_read");
+      (0, import_vitest.expect)(toolIds).toContain("plan_update");
+      (0, import_vitest.expect)(toolIds).toContain("plan_review");
+    });
+    (0, import_vitest.it)("should create only enabled tools", () => {
+      const config = import_tool_factory.planToolsFactory.configSchema.parse({
+        type: "plan-tools",
+        enabledTools: ["plan_create", "plan_read"]
+      });
+      const tools = import_tool_factory.planToolsFactory.create(config);
+      (0, import_vitest.expect)(tools).toHaveLength(2);
+      const toolIds = tools.map((t) => t.id);
+      (0, import_vitest.expect)(toolIds).toContain("plan_create");
+      (0, import_vitest.expect)(toolIds).toContain("plan_read");
+      (0, import_vitest.expect)(toolIds).not.toContain("plan_update");
+    });
+  });
+  (0, import_vitest.describe)("tool definitions", () => {
+    (0, import_vitest.it)("should have descriptions and input schemas for all tools", () => {
+      const config = import_tool_factory.planToolsFactory.configSchema.parse({
+        type: "plan-tools"
+      });
+      const tools = import_tool_factory.planToolsFactory.create(config);
+      for (const tool of tools) {
+        (0, import_vitest.expect)(tool.description).toBeDefined();
+        (0, import_vitest.expect)(tool.description.length).toBeGreaterThan(0);
+        (0, import_vitest.expect)(tool.inputSchema).toBeDefined();
+      }
+    });
+  });
+});

package/dist/tool-factory.test.js

@@ -1,100 +1,95 @@
-/**
- * Plan Tools Factory Tests
- *
- * Validates the plan tools factory schema and tool creation.
- */
-import { describe, it, expect } from 'vitest';
-import { planToolsFactory } from './tool-factory.js';
-describe('planToolsFactory', () => {
-    describe('factory metadata', () => {
-        it('should have metadata', () => {
-            expect(planToolsFactory.metadata).toBeDefined();
-            expect(planToolsFactory.metadata?.displayName).toBe('Plan Tools');
-            expect(planToolsFactory.metadata?.category).toBe('planning');
-        });
+import { describe, it, expect } from "vitest";
+import { planToolsFactory } from "./tool-factory.js";
+describe("planToolsFactory", () => {
+  describe("factory metadata", () => {
+    it("should have metadata", () => {
+      expect(planToolsFactory.metadata).toBeDefined();
+      expect(planToolsFactory.metadata?.displayName).toBe("Plan Tools");
+      expect(planToolsFactory.metadata?.category).toBe("planning");
     });
-    describe('config schema', () => {
-        it('should validate minimal config', () => {
-            const result = planToolsFactory.configSchema.safeParse({
-                type: 'plan-tools',
-            });
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.basePath).toBe('.dexto/plans');
-            }
-        });
-        it('should validate config with custom basePath', () => {
-            const result = planToolsFactory.configSchema.safeParse({
-                type: 'plan-tools',
-                basePath: '/custom/path',
-            });
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.basePath).toBe('/custom/path');
-            }
-        });
-        it('should validate config with enabledTools', () => {
-            const result = planToolsFactory.configSchema.safeParse({
-                type: 'plan-tools',
-                enabledTools: ['plan_create', 'plan_read'],
-            });
-            expect(result.success).toBe(true);
-            if (result.success) {
-                expect(result.data.enabledTools).toEqual(['plan_create', 'plan_read']);
-            }
-        });
-        it('should reject invalid tool names', () => {
-            const result = planToolsFactory.configSchema.safeParse({
-                type: 'plan-tools',
-                enabledTools: ['invalid_tool'],
-            });
-            expect(result.success).toBe(false);
-        });
-        it('should reject unknown properties', () => {
-            const result = planToolsFactory.configSchema.safeParse({
-                type: 'plan-tools',
-                unknownProp: 'value',
-            });
-            expect(result.success).toBe(false);
-        });
+  });
+  describe("config schema", () => {
+    it("should validate minimal config", () => {
+      const result = planToolsFactory.configSchema.safeParse({
+        type: "plan-tools"
+      });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.basePath).toBe(".dexto/plans");
+      }
     });
-    describe('create', () => {
-        it('should create all tools by default', () => {
-            const config = planToolsFactory.configSchema.parse({
-                type: 'plan-tools',
-            });
-            const tools = planToolsFactory.create(config);
-            expect(tools).toHaveLength(4);
-            const toolIds = tools.map((t) => t.id);
-            expect(toolIds).toContain('plan_create');
-            expect(toolIds).toContain('plan_read');
-            expect(toolIds).toContain('plan_update');
-            expect(toolIds).toContain('plan_review');
-        });
-        it('should create only enabled tools', () => {
-            const config = planToolsFactory.configSchema.parse({
-                type: 'plan-tools',
-                enabledTools: ['plan_create', 'plan_read'],
-            });
-            const tools = planToolsFactory.create(config);
-            expect(tools).toHaveLength(2);
-            const toolIds = tools.map((t) => t.id);
-            expect(toolIds).toContain('plan_create');
-            expect(toolIds).toContain('plan_read');
-            expect(toolIds).not.toContain('plan_update');
-        });
+    it("should validate config with custom basePath", () => {
+      const result = planToolsFactory.configSchema.safeParse({
+        type: "plan-tools",
+        basePath: "/custom/path"
+      });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.basePath).toBe("/custom/path");
+      }
     });
-    describe('tool definitions', () => {
-        it('should have descriptions and input schemas for all tools', () => {
-            const config = planToolsFactory.configSchema.parse({
-                type: 'plan-tools',
-            });
-            const tools = planToolsFactory.create(config);
-            for (const tool of tools) {
-                expect(tool.description).toBeDefined();
-                expect(tool.description.length).toBeGreaterThan(0);
-                expect(tool.inputSchema).toBeDefined();
-            }
-        });
+    it("should validate config with enabledTools", () => {
+      const result = planToolsFactory.configSchema.safeParse({
+        type: "plan-tools",
+        enabledTools: ["plan_create", "plan_read"]
+      });
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.enabledTools).toEqual(["plan_create", "plan_read"]);
+      }
     });
+    it("should reject invalid tool names", () => {
+      const result = planToolsFactory.configSchema.safeParse({
+        type: "plan-tools",
+        enabledTools: ["invalid_tool"]
+      });
+      expect(result.success).toBe(false);
+    });
+    it("should reject unknown properties", () => {
+      const result = planToolsFactory.configSchema.safeParse({
+        type: "plan-tools",
+        unknownProp: "value"
+      });
+      expect(result.success).toBe(false);
+    });
+  });
+  describe("create", () => {
+    it("should create all tools by default", () => {
+      const config = planToolsFactory.configSchema.parse({
+        type: "plan-tools"
+      });
+      const tools = planToolsFactory.create(config);
+      expect(tools).toHaveLength(4);
+      const toolIds = tools.map((t) => t.id);
+      expect(toolIds).toContain("plan_create");
+      expect(toolIds).toContain("plan_read");
+      expect(toolIds).toContain("plan_update");
+      expect(toolIds).toContain("plan_review");
+    });
+    it("should create only enabled tools", () => {
+      const config = planToolsFactory.configSchema.parse({
+        type: "plan-tools",
+        enabledTools: ["plan_create", "plan_read"]
+      });
+      const tools = planToolsFactory.create(config);
+      expect(tools).toHaveLength(2);
+      const toolIds = tools.map((t) => t.id);
+      expect(toolIds).toContain("plan_create");
+      expect(toolIds).toContain("plan_read");
+      expect(toolIds).not.toContain("plan_update");
+    });
+  });
+  describe("tool definitions", () => {
+    it("should have descriptions and input schemas for all tools", () => {
+      const config = planToolsFactory.configSchema.parse({
+        type: "plan-tools"
+      });
+      const tools = planToolsFactory.create(config);
+      for (const tool of tools) {
+        expect(tool.description).toBeDefined();
+        expect(tool.description.length).toBeGreaterThan(0);
+        expect(tool.inputSchema).toBeDefined();
+      }
+    });
+  });
 });

package/dist/tools/plan-create-tool.cjs

@@ -0,0 +1,102 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_create_tool_exports = {};
+__export(plan_create_tool_exports, {
+  createPlanCreateTool: () => createPlanCreateTool
+});
+module.exports = __toCommonJS(plan_create_tool_exports);
+var import_zod = require("zod");
+var import_core = require("@dexto/core");
+var import_errors = require("../errors.js");
+const PlanCreateInputSchema = import_zod.z.object({
+  title: import_zod.z.string().describe('Plan title (e.g., "Add User Authentication")'),
+  content: import_zod.z.string().describe(
+    "Plan content in markdown format. Use - [ ] and - [x] for checkboxes to track progress."
+  )
+}).strict();
+function createPlanCreateTool(getPlanService) {
+  return (0, import_core.defineTool)({
+    id: "plan_create",
+    description: "Create a new implementation plan for the current session. Shows the plan for approval before saving. Use markdown format for the plan content with clear steps and file references.",
+    inputSchema: PlanCreateInputSchema,
+    presentation: {
+      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+        title: "Create Plan",
+        argsText: (0, import_core.truncateForHeader)(input.title, 140)
+      }),
+      /**
+       * Generate preview for approval UI
+       */
+      preview: async (input, context) => {
+        const { content } = input;
+        if (!context.sessionId) {
+          throw import_errors.PlanError.sessionIdRequired();
+        }
+        const resolvedPlanService = await getPlanService(context);
+        const exists = await resolvedPlanService.exists(context.sessionId);
+        if (exists) {
+          throw import_errors.PlanError.planAlreadyExists(context.sessionId);
+        }
+        const lineCount = content.split("\n").length;
+        const planPath = resolvedPlanService.getPlanPath(context.sessionId);
+        return {
+          type: "file",
+          title: "Create Plan",
+          path: planPath,
+          operation: "create",
+          content,
+          size: Buffer.byteLength(content, "utf8"),
+          lineCount
+        };
+      }
+    },
+    async execute(input, context) {
+      const { title, content } = input;
+      if (!context.sessionId) {
+        throw import_errors.PlanError.sessionIdRequired();
+      }
+      const resolvedPlanService = await getPlanService(context);
+      const exists = await resolvedPlanService.exists(context.sessionId);
+      if (exists) {
+        throw import_errors.PlanError.planAlreadyExists(context.sessionId);
+      }
+      const plan = await resolvedPlanService.create(context.sessionId, content, { title });
+      const planPath = resolvedPlanService.getPlanPath(context.sessionId);
+      const _display = {
+        type: "file",
+        title: "Create Plan",
+        path: planPath,
+        operation: "create",
+        size: Buffer.byteLength(content, "utf8"),
+        lineCount: content.split("\n").length
+      };
+      return {
+        success: true,
+        path: planPath,
+        status: plan.meta.status,
+        title: plan.meta.title,
+        _display
+      };
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPlanCreateTool
+});

package/dist/tools/plan-create-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"plan-create-tool.d.ts","sourceRoot":"","sources":["../../src/tools/plan-create-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAyC,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAGnE,QAAA,MAAM,qBAAqB;;;;;;;;;EASd,CAAC;AAEd;;GAEG;AACH,wBAAgB,oBAAoB,CAChC,cAAc,EAAE,iBAAiB,GAClC,IAAI,CAAC,OAAO,qBAAqB,CAAC,CA0EpC"}
+{"version":3,"file":"plan-create-tool.d.ts","sourceRoot":"","sources":["../../src/tools/plan-create-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAyC,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAGnE,QAAA,MAAM,qBAAqB;;;;;;;;;EASd,CAAC;AAEd;;GAEG;AACH,wBAAgB,oBAAoB,CAChC,cAAc,EAAE,iBAAiB,GAClC,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAkFpC"}