@dexto/tools-plan 1.5.7

package/dist/plan-service.test.js

@@ -0,0 +1,220 @@
+/**
+ * Plan Service Tests
+ *
+ * Tests for the PlanService CRUD operations and error handling.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import { PlanService } from './plan-service.js';
+import { PlanErrorCode } from './errors.js';
+import { DextoRuntimeError } from '@dexto/core';
+// Create mock logger
+const createMockLogger = () => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    createChild: vi.fn().mockReturnThis(),
+});
+describe('PlanService', () => {
+    let mockLogger;
+    let tempDir;
+    let planService;
+    beforeEach(async () => {
+        mockLogger = createMockLogger();
+        // Create temp directory for testing
+        const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dexto-plan-test-'));
+        tempDir = await fs.realpath(rawTempDir);
+        planService = new PlanService({ basePath: tempDir }, mockLogger);
+        vi.clearAllMocks();
+    });
+    afterEach(async () => {
+        // Cleanup temp directory
+        try {
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    });
+    describe('exists', () => {
+        it('should return false for non-existent plan', async () => {
+            const exists = await planService.exists('non-existent-session');
+            expect(exists).toBe(false);
+        });
+        it('should return true for existing plan', async () => {
+            const sessionId = 'test-session';
+            await planService.create(sessionId, '# Test Plan');
+            const exists = await planService.exists(sessionId);
+            expect(exists).toBe(true);
+        });
+    });
+    describe('create', () => {
+        it('should create a new plan with content and metadata', async () => {
+            const sessionId = 'test-session';
+            const content = '# Implementation Plan\n\n## Steps\n1. First step';
+            const title = 'Test Plan';
+            const plan = await planService.create(sessionId, content, { title });
+            expect(plan.content).toBe(content);
+            expect(plan.meta.sessionId).toBe(sessionId);
+            expect(plan.meta.status).toBe('draft');
+            expect(plan.meta.title).toBe(title);
+            expect(plan.meta.createdAt).toBeGreaterThan(0);
+            expect(plan.meta.updatedAt).toBeGreaterThan(0);
+        });
+        it('should throw error when plan already exists', async () => {
+            const sessionId = 'test-session';
+            await planService.create(sessionId, '# First Plan');
+            try {
+                await planService.create(sessionId, '# Second Plan');
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DextoRuntimeError);
+                expect(error.code).toBe(PlanErrorCode.PLAN_ALREADY_EXISTS);
+            }
+        });
+        it('should store plan files on disk', async () => {
+            const sessionId = 'test-session';
+            const content = '# Test Plan';
+            await planService.create(sessionId, content);
+            // Verify plan.md exists
+            const planPath = path.join(tempDir, sessionId, 'plan.md');
+            const storedContent = await fs.readFile(planPath, 'utf-8');
+            expect(storedContent).toBe(content);
+            // Verify plan-meta.json exists
+            const metaPath = path.join(tempDir, sessionId, 'plan-meta.json');
+            const metaContent = await fs.readFile(metaPath, 'utf-8');
+            const meta = JSON.parse(metaContent);
+            expect(meta.sessionId).toBe(sessionId);
+        });
+    });
+    describe('read', () => {
+        it('should return null for non-existent plan', async () => {
+            const plan = await planService.read('non-existent-session');
+            expect(plan).toBeNull();
+        });
+        it('should read existing plan with content and metadata', async () => {
+            const sessionId = 'test-session';
+            const content = '# Test Plan';
+            const title = 'My Plan';
+            await planService.create(sessionId, content, { title });
+            const plan = await planService.read(sessionId);
+            expect(plan).not.toBeNull();
+            expect(plan.content).toBe(content);
+            expect(plan.meta.sessionId).toBe(sessionId);
+            expect(plan.meta.title).toBe(title);
+        });
+        it('should handle invalid metadata schema gracefully', async () => {
+            const sessionId = 'test-session';
+            await planService.create(sessionId, '# Test');
+            // Write valid JSON but invalid schema (missing required fields)
+            const metaPath = path.join(tempDir, sessionId, 'plan-meta.json');
+            await fs.writeFile(metaPath, JSON.stringify({ invalidField: 'value' }));
+            const plan = await planService.read(sessionId);
+            // Should return with default metadata
+            expect(plan).not.toBeNull();
+            expect(plan.meta.sessionId).toBe(sessionId);
+            expect(plan.meta.status).toBe('draft');
+            expect(mockLogger.warn).toHaveBeenCalled();
+        });
+        it('should return null for corrupted JSON metadata', async () => {
+            const sessionId = 'test-session';
+            await planService.create(sessionId, '# Test');
+            // Corrupt the metadata with invalid JSON
+            const metaPath = path.join(tempDir, sessionId, 'plan-meta.json');
+            await fs.writeFile(metaPath, '{ invalid json }');
+            const plan = await planService.read(sessionId);
+            // Should return null and log error
+            expect(plan).toBeNull();
+            expect(mockLogger.error).toHaveBeenCalled();
+        });
+    });
+    describe('update', () => {
+        it('should update plan content', async () => {
+            const sessionId = 'test-session';
+            await planService.create(sessionId, '# Original Content');
+            const result = await planService.update(sessionId, '# Updated Content');
+            expect(result.oldContent).toBe('# Original Content');
+            expect(result.newContent).toBe('# Updated Content');
+            expect(result.meta.updatedAt).toBeGreaterThan(0);
+        });
+        it('should preserve metadata when updating content', async () => {
+            const sessionId = 'test-session';
+            const plan = await planService.create(sessionId, '# Original', { title: 'My Title' });
+            const originalCreatedAt = plan.meta.createdAt;
+            await planService.update(sessionId, '# Updated');
+            const updatedPlan = await planService.read(sessionId);
+            expect(updatedPlan.meta.title).toBe('My Title');
+            expect(updatedPlan.meta.createdAt).toBe(originalCreatedAt);
+        });
+        it('should throw error when plan does not exist', async () => {
+            try {
+                await planService.update('non-existent', '# Content');
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DextoRuntimeError);
+                expect(error.code).toBe(PlanErrorCode.PLAN_NOT_FOUND);
+            }
+        });
+    });
+    describe('updateMeta', () => {
+        it('should update plan status', async () => {
+            const sessionId = 'test-session';
+            await planService.create(sessionId, '# Plan');
+            const meta = await planService.updateMeta(sessionId, { status: 'approved' });
+            expect(meta.status).toBe('approved');
+        });
+        it('should update plan title', async () => {
+            const sessionId = 'test-session';
+            await planService.create(sessionId, '# Plan');
+            const meta = await planService.updateMeta(sessionId, { title: 'New Title' });
+            expect(meta.title).toBe('New Title');
+        });
+        it('should throw error when plan does not exist', async () => {
+            try {
+                await planService.updateMeta('non-existent', { status: 'approved' });
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DextoRuntimeError);
+                expect(error.code).toBe(PlanErrorCode.PLAN_NOT_FOUND);
+            }
+        });
+    });
+    describe('delete', () => {
+        it('should delete existing plan', async () => {
+            const sessionId = 'test-session';
+            await planService.create(sessionId, '# Plan');
+            await planService.delete(sessionId);
+            const exists = await planService.exists(sessionId);
+            expect(exists).toBe(false);
+        });
+        it('should throw error when plan does not exist', async () => {
+            try {
+                await planService.delete('non-existent');
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DextoRuntimeError);
+                expect(error.code).toBe(PlanErrorCode.PLAN_NOT_FOUND);
+            }
+        });
+        it('should remove plan directory from disk', async () => {
+            const sessionId = 'test-session';
+            await planService.create(sessionId, '# Plan');
+            const planDir = path.join(tempDir, sessionId);
+            await planService.delete(sessionId);
+            try {
+                await fs.access(planDir);
+                expect.fail('Directory should not exist');
+            }
+            catch {
+                // Expected - directory should not exist
+            }
+        });
+    });
+});

package/dist/tool-provider.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Plan Tools Provider
+ *
+ * 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';
+import type { CustomToolProvider } from '@dexto/core';
+/**
+ * Configuration schema for Plan tools provider
+ */
+declare const PlanToolsConfigSchema: z.ZodObject<{
+    type: z.ZodLiteral<"plan-tools">;
+    basePath: z.ZodDefault<z.ZodString>;
+    enabledTools: z.ZodOptional<z.ZodArray<z.ZodEnum<["plan_create", "plan_read", "plan_update", "plan_review"]>, "many">>;
+}, "strict", z.ZodTypeAny, {
+    type: "plan-tools";
+    basePath: string;
+    enabledTools?: ("plan_create" | "plan_read" | "plan_update" | "plan_review")[] | undefined;
+}, {
+    type: "plan-tools";
+    basePath?: string | undefined;
+    enabledTools?: ("plan_create" | "plan_read" | "plan_update" | "plan_review")[] | undefined;
+}>;
+type PlanToolsConfig = z.output<typeof PlanToolsConfigSchema>;
+/**
+ * Plan tools provider
+ *
+ * Provides implementation planning tools:
+ * - plan_create: Create a new plan with markdown content
+ * - plan_read: Read the current plan
+ * - plan_update: Update existing plan (shows diff preview)
+ * - plan_review: Request user review of the plan (shows plan with approval options)
+ *
+ * Plans are stored in .dexto/plans/{sessionId}/ with:
+ * - plan.md: Markdown content with checkboxes (- [ ] and - [x])
+ * - plan-meta.json: Metadata (status, title, timestamps)
+ */
+export declare const planToolsProvider: CustomToolProvider<'plan-tools', PlanToolsConfig>;
+export {};
+//# sourceMappingURL=tool-provider.d.ts.map

package/dist/tool-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-provider.d.ts","sourceRoot":"","sources":["../src/tool-provider.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAGH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,kBAAkB,EAAqC,MAAM,aAAa,CAAC;AAazF;;GAEG;AACH,QAAA,MAAM,qBAAqB;;;;;;;;;;;;EAcd,CAAC;AAEd,KAAK,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE9D;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,iBAAiB,EAAE,kBAAkB,CAAC,YAAY,EAAE,eAAe,CAwC/E,CAAC"}

package/dist/tool-provider.js

@@ -0,0 +1,81 @@
+/**
+ * Plan Tools Provider
+ *
+ * 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 * as path from 'node:path';
+import { z } from 'zod';
+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';
+/**
+ * Available plan tool names for enabledTools configuration
+ */
+const PLAN_TOOL_NAMES = ['plan_create', 'plan_read', 'plan_update', 'plan_review'];
+/**
+ * Configuration schema for Plan tools provider
+ */
+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();
+/**
+ * Plan tools provider
+ *
+ * Provides implementation planning tools:
+ * - plan_create: Create a new plan with markdown content
+ * - plan_read: Read the current plan
+ * - plan_update: Update existing plan (shows diff preview)
+ * - plan_review: Request user review of the plan (shows plan with approval options)
+ *
+ * Plans are stored in .dexto/plans/{sessionId}/ with:
+ * - plan.md: Markdown content with checkboxes (- [ ] and - [x])
+ * - plan-meta.json: Metadata (status, title, timestamps)
+ */
+export const planToolsProvider = {
+    type: 'plan-tools',
+    configSchema: PlanToolsConfigSchema,
+    create: (config, context) => {
+        const { logger } = context;
+        // Resolve base path (relative to cwd or absolute)
+        const basePath = path.isAbsolute(config.basePath)
+            ? config.basePath
+            : path.join(process.cwd(), config.basePath);
+        logger.debug(`Creating PlanService with basePath: ${basePath}`);
+        const planService = new PlanService({ basePath }, logger);
+        // Build tool map for selective enabling
+        const toolCreators = {
+            plan_create: () => createPlanCreateTool(planService),
+            plan_read: () => createPlanReadTool(planService),
+            plan_update: () => createPlanUpdateTool(planService),
+            plan_review: () => createPlanReviewTool(planService),
+        };
+        // Determine which tools to create
+        const toolsToCreate = config.enabledTools ?? PLAN_TOOL_NAMES;
+        if (config.enabledTools) {
+            logger.debug(`Creating subset of plan tools: ${toolsToCreate.join(', ')}`);
+        }
+        // Create and return only the enabled tools
+        return toolsToCreate.map((toolName) => toolCreators[toolName]());
+    },
+    metadata: {
+        displayName: 'Plan Tools',
+        description: 'Create and manage implementation plans linked to sessions',
+        category: 'planning',
+    },
+};

package/dist/tool-provider.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Plan Tools Provider Tests
+ *
+ * Tests for the planToolsProvider configuration and tool creation.
+ */
+export {};
+//# sourceMappingURL=tool-provider.test.d.ts.map

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

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

package/dist/tool-provider.test.js

@@ -0,0 +1,185 @@
+/**
+ * Plan Tools Provider Tests
+ *
+ * Tests for the planToolsProvider configuration and tool creation.
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import * as os from 'node:os';
+import { planToolsProvider } from './tool-provider.js';
+// Create mock logger
+const createMockLogger = () => ({
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    createChild: vi.fn().mockReturnThis(),
+});
+// Create mock context with logger and minimal agent
+const createMockContext = (logger) => ({
+    logger: logger,
+    agent: {}, // Minimal mock - provider only uses logger
+});
+describe('planToolsProvider', () => {
+    let mockLogger;
+    let tempDir;
+    let originalCwd;
+    beforeEach(async () => {
+        mockLogger = createMockLogger();
+        // Create temp directory for testing
+        const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dexto-provider-test-'));
+        tempDir = await fs.realpath(rawTempDir);
+        // Store original cwd and mock process.cwd to return temp dir
+        originalCwd = process.cwd();
+        vi.spyOn(process, 'cwd').mockReturnValue(tempDir);
+        vi.clearAllMocks();
+    });
+    afterEach(async () => {
+        // Restore mocked process.cwd
+        vi.mocked(process.cwd).mockRestore();
+        try {
+            await fs.rm(tempDir, { recursive: true, force: true });
+        }
+        catch {
+            // Ignore cleanup errors
+        }
+    });
+    describe('provider metadata', () => {
+        it('should have correct type', () => {
+            expect(planToolsProvider.type).toBe('plan-tools');
+        });
+        it('should have metadata', () => {
+            expect(planToolsProvider.metadata).toBeDefined();
+            expect(planToolsProvider.metadata?.displayName).toBe('Plan Tools');
+            expect(planToolsProvider.metadata?.category).toBe('planning');
+        });
+    });
+    describe('config schema', () => {
+        it('should validate minimal config', () => {
+            const result = planToolsProvider.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 = planToolsProvider.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 = planToolsProvider.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 = planToolsProvider.configSchema.safeParse({
+                type: 'plan-tools',
+                enabledTools: ['invalid_tool'],
+            });
+            expect(result.success).toBe(false);
+        });
+        it('should reject unknown properties', () => {
+            const result = planToolsProvider.configSchema.safeParse({
+                type: 'plan-tools',
+                unknownProp: 'value',
+            });
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('create', () => {
+        it('should create all tools by default', () => {
+            const config = planToolsProvider.configSchema.parse({
+                type: 'plan-tools',
+            });
+            const tools = planToolsProvider.create(config, createMockContext(mockLogger));
+            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 = planToolsProvider.configSchema.parse({
+                type: 'plan-tools',
+                enabledTools: ['plan_create', 'plan_read'],
+            });
+            const tools = planToolsProvider.create(config, createMockContext(mockLogger));
+            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 create single tool', () => {
+            const config = planToolsProvider.configSchema.parse({
+                type: 'plan-tools',
+                enabledTools: ['plan_update'],
+            });
+            const tools = planToolsProvider.create(config, createMockContext(mockLogger));
+            expect(tools).toHaveLength(1);
+            expect(tools[0].id).toBe('plan_update');
+        });
+        it('should use relative basePath from cwd', () => {
+            const config = planToolsProvider.configSchema.parse({
+                type: 'plan-tools',
+                basePath: '.dexto/plans',
+            });
+            planToolsProvider.create(config, createMockContext(mockLogger));
+            // Verify debug log was called with resolved path
+            expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining(path.join(tempDir, '.dexto/plans')));
+        });
+        it('should use absolute basePath as-is', () => {
+            const absolutePath = '/absolute/path/to/plans';
+            const config = planToolsProvider.configSchema.parse({
+                type: 'plan-tools',
+                basePath: absolutePath,
+            });
+            planToolsProvider.create(config, createMockContext(mockLogger));
+            expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining(absolutePath));
+        });
+        it('should log when creating subset of tools', () => {
+            const config = planToolsProvider.configSchema.parse({
+                type: 'plan-tools',
+                enabledTools: ['plan_create'],
+            });
+            planToolsProvider.create(config, createMockContext(mockLogger));
+            expect(mockLogger.debug).toHaveBeenCalledWith(expect.stringContaining('Creating subset of plan tools'));
+        });
+    });
+    describe('tool descriptions', () => {
+        it('should have descriptions for all tools', () => {
+            const config = planToolsProvider.configSchema.parse({
+                type: 'plan-tools',
+            });
+            const tools = planToolsProvider.create(config, createMockContext(mockLogger));
+            for (const tool of tools) {
+                expect(tool.description).toBeDefined();
+                expect(tool.description.length).toBeGreaterThan(0);
+            }
+        });
+        it('should have input schemas for all tools', () => {
+            const config = planToolsProvider.configSchema.parse({
+                type: 'plan-tools',
+            });
+            const tools = planToolsProvider.create(config, createMockContext(mockLogger));
+            for (const tool of tools) {
+                expect(tool.inputSchema).toBeDefined();
+            }
+        });
+    });
+});

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

@@ -0,0 +1,13 @@
+/**
+ * Plan Create Tool
+ *
+ * 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';
+/**
+ * Creates the plan_create tool
+ */
+export declare function createPlanCreateTool(planService: PlanService): InternalTool;
+//# sourceMappingURL=plan-create-tool.d.ts.map

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

@@ -0,0 +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"}

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

@@ -0,0 +1,72 @@
+/**
+ * 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,
+                },
+            };
+        },
+    };
+}

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

@@ -0,0 +1,7 @@
+/**
+ * Plan Create Tool Tests
+ *
+ * Tests for the plan_create tool including preview generation.
+ */
+export {};
+//# sourceMappingURL=plan-create-tool.test.d.ts.map

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

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