@dexto/tools-plan 1.5.8 → 1.6.1

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.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Plan Tools Factory Tests
+ *
+ * Validates the plan tools factory schema and tool creation.
+ */
+export {};
+//# sourceMappingURL=tool-factory.test.d.ts.map

package/dist/tool-factory.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-factory.test.d.ts","sourceRoot":"","sources":["../src/tool-factory.test.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/tool-factory.test.js

@@ -0,0 +1,95 @@
+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("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

@@ -4,10 +4,22 @@
  * Creates a new implementation plan for the current session.
  * Shows a preview for approval before saving.
  */
-import type { InternalTool } from '@dexto/core';
-import type { PlanService } from '../plan-service.js';
+import { z } from 'zod';
+import type { Tool } from '@dexto/core';
+import type { PlanServiceGetter } from '../plan-service-getter.js';
+declare const PlanCreateInputSchema: z.ZodObject<{
+    title: z.ZodString;
+    content: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    title: string;
+    content: string;
+}, {
+    title: string;
+    content: string;
+}>;
 /**
  * Creates the plan_create tool
  */
-export declare function createPlanCreateTool(planService: PlanService): InternalTool;
+export declare function createPlanCreateTool(getPlanService: PlanServiceGetter): Tool<typeof PlanCreateInputSchema>;
+export {};
 //# sourceMappingURL=plan-create-tool.d.ts.map

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;AAGH,OAAO,KAAK,EAAE,YAAY,EAAyC,MAAM,aAAa,CAAC;AACvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAgBtD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,WAAW,GAAG,YAAY,CAgE3E"}
+{"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"}

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

@@ -1,72 +1,78 @@
-/**
- * Plan Create Tool
- *
- * Creates a new implementation plan for the current session.
- * Shows a preview for approval before saving.
- */
-import { z } from 'zod';
-import { PlanError } from '../errors.js';
-const PlanCreateInputSchema = z
-    .object({
-    title: z.string().describe('Plan title (e.g., "Add User Authentication")'),
-    content: z
-        .string()
-        .describe('Plan content in markdown format. Use - [ ] and - [x] for checkboxes to track progress.'),
-})
-    .strict();
-/**
- * Creates the plan_create tool
- */
-export function createPlanCreateTool(planService) {
-    return {
-        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,
-        /**
-         * Generate preview for approval UI
-         */
-        generatePreview: async (input, context) => {
-            const { content } = input;
-            if (!context?.sessionId) {
-                throw PlanError.sessionIdRequired();
-            }
-            // Check if plan already exists
-            const exists = await planService.exists(context.sessionId);
-            if (exists) {
-                throw PlanError.planAlreadyExists(context.sessionId);
-            }
-            // Return preview for approval UI
-            const lineCount = content.split('\n').length;
-            const planPath = planService.getPlanPath(context.sessionId);
-            return {
-                type: 'file',
-                path: planPath,
-                operation: 'create',
-                content,
-                size: content.length,
-                lineCount,
-            };
-        },
-        execute: async (input, context) => {
-            const { title, content } = input;
-            if (!context?.sessionId) {
-                throw PlanError.sessionIdRequired();
-            }
-            const plan = await planService.create(context.sessionId, content, { title });
-            const planPath = planService.getPlanPath(context.sessionId);
-            return {
-                success: true,
-                path: planPath,
-                status: plan.meta.status,
-                title: plan.meta.title,
-                _display: {
-                    type: 'file',
-                    path: planPath,
-                    operation: 'create',
-                    size: content.length,
-                    lineCount: content.split('\n').length,
-                },
-            };
-        },
-    };
+import { z } from "zod";
+import { createLocalToolCallHeader, defineTool, truncateForHeader } from "@dexto/core";
+import { PlanError } from "../errors.js";
+const PlanCreateInputSchema = z.object({
+  title: z.string().describe('Plan title (e.g., "Add User Authentication")'),
+  content: z.string().describe(
+    "Plan content in markdown format. Use - [ ] and - [x] for checkboxes to track progress."
+  )
+}).strict();
+function createPlanCreateTool(getPlanService) {
+  return 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) => createLocalToolCallHeader({
+        title: "Create Plan",
+        argsText: truncateForHeader(input.title, 140)
+      }),
+      /**
+       * Generate preview for approval UI
+       */
+      preview: async (input, context) => {
+        const { content } = input;
+        if (!context.sessionId) {
+          throw PlanError.sessionIdRequired();
+        }
+        const resolvedPlanService = await getPlanService(context);
+        const exists = await resolvedPlanService.exists(context.sessionId);
+        if (exists) {
+          throw 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 PlanError.sessionIdRequired();
+      }
+      const resolvedPlanService = await getPlanService(context);
+      const exists = await resolvedPlanService.exists(context.sessionId);
+      if (exists) {
+        throw 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
+      };
+    }
+  });
 }
+export {
+  createPlanCreateTool
+};

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

@@ -0,0 +1,174 @@
+"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 __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 import_vitest = require("vitest");
+var path = __toESM(require("node:path"), 1);
+var fs = __toESM(require("node:fs/promises"), 1);
+var os = __toESM(require("node:os"), 1);
+var import_plan_create_tool = require("./plan-create-tool.js");
+var import_plan_service = require("../plan-service.js");
+var import_errors = require("../errors.js");
+var import_core = require("@dexto/core");
+const createMockLogger = () => {
+  const logger = {
+    debug: import_vitest.vi.fn(),
+    silly: import_vitest.vi.fn(),
+    info: import_vitest.vi.fn(),
+    warn: import_vitest.vi.fn(),
+    error: import_vitest.vi.fn(),
+    trackException: import_vitest.vi.fn(),
+    createChild: import_vitest.vi.fn(() => logger),
+    createFileOnlyChild: import_vitest.vi.fn(() => logger),
+    setLevel: import_vitest.vi.fn(),
+    getLevel: import_vitest.vi.fn(() => "debug"),
+    getLogFilePath: import_vitest.vi.fn(() => null),
+    destroy: import_vitest.vi.fn(async () => void 0)
+  };
+  return logger;
+};
+function createToolContext(logger, overrides = {}) {
+  return { logger, ...overrides };
+}
+(0, import_vitest.describe)("plan_create tool", () => {
+  let logger;
+  let tempDir;
+  let planService;
+  (0, import_vitest.beforeEach)(async () => {
+    logger = createMockLogger();
+    const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-plan-create-test-"));
+    tempDir = await fs.realpath(rawTempDir);
+    planService = new import_plan_service.PlanService({ basePath: tempDir }, logger);
+    import_vitest.vi.clearAllMocks();
+  });
+  (0, import_vitest.afterEach)(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  (0, import_vitest.describe)("generatePreview", () => {
+    (0, import_vitest.it)("should return FileDisplayData for new plan", async () => {
+      const tool = (0, import_plan_create_tool.createPlanCreateTool)(async () => planService);
+      const sessionId = "test-session";
+      const content = "# Implementation Plan\n\n## Steps\n1. First step";
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
+      const preview = await previewFn(
+        { title: "Test Plan", content },
+        createToolContext(logger, { sessionId })
+      );
+      (0, import_vitest.expect)(preview.type).toBe("file");
+      (0, import_vitest.expect)(preview.title).toBe("Create Plan");
+      (0, import_vitest.expect)(preview.operation).toBe("create");
+      (0, import_vitest.expect)(preview.path).toContain(sessionId);
+      (0, import_vitest.expect)(preview.path).toMatch(/plan\.md$/);
+      (0, import_vitest.expect)(preview.content).toBe(content);
+      (0, import_vitest.expect)(preview.lineCount).toBe(4);
+    });
+    (0, import_vitest.it)("should throw error when sessionId is missing", async () => {
+      const tool = (0, import_plan_create_tool.createPlanCreateTool)(async () => planService);
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
+      try {
+        await previewFn({ title: "Test", content: "# Plan" }, createToolContext(logger));
+        import_vitest.expect.fail("Should have thrown an error");
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_core.DextoRuntimeError);
+        (0, import_vitest.expect)(error.code).toBe(import_errors.PlanErrorCode.SESSION_ID_REQUIRED);
+      }
+    });
+    (0, import_vitest.it)("should throw error when plan already exists", async () => {
+      const tool = (0, import_plan_create_tool.createPlanCreateTool)(async () => planService);
+      const sessionId = "test-session";
+      const previewFn = tool.presentation?.preview;
+      (0, import_vitest.expect)(previewFn).toBeDefined();
+      await planService.create(sessionId, "# Existing Plan");
+      try {
+        await previewFn(
+          { title: "New Plan", content: "# New Content" },
+          createToolContext(logger, { sessionId })
+        );
+        import_vitest.expect.fail("Should have thrown an error");
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_core.DextoRuntimeError);
+        (0, import_vitest.expect)(error.code).toBe(import_errors.PlanErrorCode.PLAN_ALREADY_EXISTS);
+      }
+    });
+  });
+  (0, import_vitest.describe)("execute", () => {
+    (0, import_vitest.it)("should create plan and return success", async () => {
+      const tool = (0, import_plan_create_tool.createPlanCreateTool)(async () => planService);
+      const sessionId = "test-session";
+      const content = "# Implementation Plan";
+      const title = "My Plan";
+      const result = await tool.execute(
+        { title, content },
+        createToolContext(logger, { sessionId })
+      );
+      (0, import_vitest.expect)(result.success).toBe(true);
+      (0, import_vitest.expect)(result.path).toContain(sessionId);
+      (0, import_vitest.expect)(result.path).toMatch(/plan\.md$/);
+      (0, import_vitest.expect)(result.status).toBe("draft");
+      (0, import_vitest.expect)(result.title).toBe(title);
+    });
+    (0, import_vitest.it)("should throw error when plan already exists", async () => {
+      const tool = (0, import_plan_create_tool.createPlanCreateTool)(async () => planService);
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Existing Plan");
+      try {
+        await tool.execute(
+          { title: "New Plan", content: "# New content" },
+          createToolContext(logger, { sessionId })
+        );
+        import_vitest.expect.fail("Should have thrown an error");
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_core.DextoRuntimeError);
+        (0, import_vitest.expect)(error.code).toBe(import_errors.PlanErrorCode.PLAN_ALREADY_EXISTS);
+      }
+    });
+    (0, import_vitest.it)("should throw error when sessionId is missing", async () => {
+      const tool = (0, import_plan_create_tool.createPlanCreateTool)(async () => planService);
+      try {
+        await tool.execute({ title: "Test", content: "# Plan" }, createToolContext(logger));
+        import_vitest.expect.fail("Should have thrown an error");
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_core.DextoRuntimeError);
+        (0, import_vitest.expect)(error.code).toBe(import_errors.PlanErrorCode.SESSION_ID_REQUIRED);
+      }
+    });
+    (0, import_vitest.it)("should include _display data in result", async () => {
+      const tool = (0, import_plan_create_tool.createPlanCreateTool)(async () => planService);
+      const sessionId = "test-session";
+      const content = "# Plan\n## Steps";
+      const result = await tool.execute(
+        { title: "Plan", content },
+        createToolContext(logger, { sessionId })
+      );
+      (0, import_vitest.expect)(result._display).toBeDefined();
+      (0, import_vitest.expect)(result._display.type).toBe("file");
+      (0, import_vitest.expect)(result._display.title).toBe("Create Plan");
+      (0, import_vitest.expect)(result._display.operation).toBe("create");
+      (0, import_vitest.expect)(result._display.lineCount).toBe(2);
+    });
+  });
+});