@dexto/tools-plan 1.5.8 → 1.6.0

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

@@ -12,23 +12,35 @@ 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(),
-});
+const createMockLogger = () => {
+    const logger = {
+        debug: vi.fn(),
+        silly: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        trackException: vi.fn(),
+        createChild: vi.fn(() => logger),
+        setLevel: vi.fn(),
+        getLevel: vi.fn(() => 'debug'),
+        getLogFilePath: vi.fn(() => null),
+        destroy: vi.fn(async () => undefined),
+    };
+    return logger;
+};
+function createToolContext(logger, overrides = {}) {
+    return { logger, ...overrides };
+}
 describe('plan_create tool', () => {
-    let mockLogger;
+    let logger;
     let tempDir;
     let planService;
     beforeEach(async () => {
-        mockLogger = createMockLogger();
+        logger = createMockLogger();
         // Create temp directory for testing
         const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dexto-plan-create-test-'));
         tempDir = await fs.realpath(rawTempDir);
-        planService = new PlanService({ basePath: tempDir }, mockLogger);
+        planService = new PlanService({ basePath: tempDir }, logger);
         vi.clearAllMocks();
     });
     afterEach(async () => {
@@ -41,10 +53,10 @@ describe('plan_create tool', () => {
     });
     describe('generatePreview', () => {
         it('should return FileDisplayData for new plan', async () => {
-            const tool = createPlanCreateTool(planService);
+            const tool = createPlanCreateTool(async () => planService);
             const sessionId = 'test-session';
             const content = '# Implementation Plan\n\n## Steps\n1. First step';
-            const preview = (await tool.generatePreview({ title: 'Test Plan', content }, { sessionId }));
+            const preview = (await tool.generatePreview({ title: 'Test Plan', content }, createToolContext(logger, { sessionId })));
             expect(preview.type).toBe('file');
             expect(preview.operation).toBe('create');
             // Path is now absolute, check it ends with the expected suffix
@@ -54,9 +66,9 @@ describe('plan_create tool', () => {
             expect(preview.lineCount).toBe(4);
         });
         it('should throw error when sessionId is missing', async () => {
-            const tool = createPlanCreateTool(planService);
+            const tool = createPlanCreateTool(async () => planService);
             try {
-                await tool.generatePreview({ title: 'Test', content: '# Plan' }, {});
+                await tool.generatePreview({ title: 'Test', content: '# Plan' }, createToolContext(logger));
                 expect.fail('Should have thrown an error');
             }
             catch (error) {
@@ -65,12 +77,12 @@ describe('plan_create tool', () => {
             }
         });
         it('should throw error when plan already exists', async () => {
-            const tool = createPlanCreateTool(planService);
+            const tool = createPlanCreateTool(async () => planService);
             const sessionId = 'test-session';
             // Create existing plan
             await planService.create(sessionId, '# Existing Plan');
             try {
-                await tool.generatePreview({ title: 'New Plan', content: '# New Content' }, { sessionId });
+                await tool.generatePreview({ title: 'New Plan', content: '# New Content' }, createToolContext(logger, { sessionId }));
                 expect.fail('Should have thrown an error');
             }
             catch (error) {
@@ -81,11 +93,11 @@ describe('plan_create tool', () => {
     });
     describe('execute', () => {
         it('should create plan and return success', async () => {
-            const tool = createPlanCreateTool(planService);
+            const tool = createPlanCreateTool(async () => planService);
             const sessionId = 'test-session';
             const content = '# Implementation Plan';
             const title = 'My Plan';
-            const result = (await tool.execute({ title, content }, { sessionId }));
+            const result = (await tool.execute({ title, content }, createToolContext(logger, { sessionId })));
             expect(result.success).toBe(true);
             // Path is now absolute, check it ends with the expected suffix
             expect(result.path).toContain(sessionId);
@@ -93,10 +105,23 @@ describe('plan_create tool', () => {
             expect(result.status).toBe('draft');
             expect(result.title).toBe(title);
         });
+        it('should throw error when plan already exists', async () => {
+            const 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 }));
+                expect.fail('Should have thrown an error');
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(DextoRuntimeError);
+                expect(error.code).toBe(PlanErrorCode.PLAN_ALREADY_EXISTS);
+            }
+        });
         it('should throw error when sessionId is missing', async () => {
-            const tool = createPlanCreateTool(planService);
+            const tool = createPlanCreateTool(async () => planService);
             try {
-                await tool.execute({ title: 'Test', content: '# Plan' }, {});
+                await tool.execute({ title: 'Test', content: '# Plan' }, createToolContext(logger));
                 expect.fail('Should have thrown an error');
             }
             catch (error) {
@@ -105,10 +130,10 @@ describe('plan_create tool', () => {
             }
         });
         it('should include _display data in result', async () => {
-            const tool = createPlanCreateTool(planService);
+            const tool = createPlanCreateTool(async () => planService);
             const sessionId = 'test-session';
             const content = '# Plan\n## Steps';
-            const result = (await tool.execute({ title: 'Plan', content }, { sessionId }));
+            const result = (await tool.execute({ title: 'Plan', content }, createToolContext(logger, { sessionId })));
             expect(result._display).toBeDefined();
             expect(result._display.type).toBe('file');
             expect(result._display.operation).toBe('create');

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

@@ -4,10 +4,13 @@
  * Reads the current implementation plan for the session.
  * No approval needed - read-only operation.
  */
-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 PlanReadInputSchema: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
 /**
  * Creates the plan_read tool
  */
-export declare function createPlanReadTool(planService: PlanService): InternalTool;
+export declare function createPlanReadTool(getPlanService: PlanServiceGetter): Tool<typeof PlanReadInputSchema>;
+export {};
 //# sourceMappingURL=plan-read-tool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"plan-read-tool.d.ts","sourceRoot":"","sources":["../../src/tools/plan-read-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAwB,MAAM,aAAa,CAAC;AACtE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAKtD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,WAAW,EAAE,WAAW,GAAG,YAAY,CAgCzE"}
+{"version":3,"file":"plan-read-tool.d.ts","sourceRoot":"","sources":["../../src/tools/plan-read-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,IAAI,EAAwB,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAGnE,QAAA,MAAM,mBAAmB,iDAAwB,CAAC;AAElD;;GAEG;AACH,wBAAgB,kBAAkB,CAC9B,cAAc,EAAE,iBAAiB,GAClC,IAAI,CAAC,OAAO,mBAAmB,CAAC,CAkClC"}

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

@@ -5,21 +5,24 @@
  * No approval needed - read-only operation.
  */
 import { z } from 'zod';
+import { defineTool } from '@dexto/core';
 import { PlanError } from '../errors.js';
 const PlanReadInputSchema = z.object({}).strict();
 /**
  * Creates the plan_read tool
  */
-export function createPlanReadTool(planService) {
-    return {
+export function createPlanReadTool(getPlanService) {
+    return defineTool({
         id: 'plan_read',
+        displayName: 'Read Plan',
         description: 'Read the current implementation plan for this session. Returns the plan content and metadata including status. Use markdown checkboxes (- [ ] and - [x]) in the content to track progress.',
         inputSchema: PlanReadInputSchema,
-        execute: async (_input, context) => {
-            if (!context?.sessionId) {
+        async execute(_input, context) {
+            const resolvedPlanService = await getPlanService(context);
+            if (!context.sessionId) {
                 throw PlanError.sessionIdRequired();
             }
-            const plan = await planService.read(context.sessionId);
+            const plan = await resolvedPlanService.read(context.sessionId);
             if (!plan) {
                 return {
                     exists: false,
@@ -28,7 +31,7 @@ export function createPlanReadTool(planService) {
             }
             return {
                 exists: true,
-                path: `.dexto/plans/${context.sessionId}/plan.md`,
+                path: resolvedPlanService.getPlanPath(context.sessionId),
                 content: plan.content,
                 status: plan.meta.status,
                 title: plan.meta.title,
@@ -36,5 +39,5 @@ export function createPlanReadTool(planService) {
                 updatedAt: new Date(plan.meta.updatedAt).toISOString(),
             };
         },
-    };
+    });
 }

package/dist/tools/plan-read-tool.test.js

@@ -12,22 +12,34 @@ 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(),
-});
+const createMockLogger = () => {
+    const logger = {
+        debug: vi.fn(),
+        silly: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        trackException: vi.fn(),
+        createChild: vi.fn(() => logger),
+        setLevel: vi.fn(),
+        getLevel: vi.fn(() => 'debug'),
+        getLogFilePath: vi.fn(() => null),
+        destroy: vi.fn(async () => undefined),
+    };
+    return logger;
+};
+function createToolContext(logger, overrides = {}) {
+    return { logger, ...overrides };
+}
 describe('plan_read tool', () => {
-    let mockLogger;
+    let logger;
     let tempDir;
     let planService;
     beforeEach(async () => {
-        mockLogger = createMockLogger();
+        logger = createMockLogger();
         const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dexto-plan-read-test-'));
         tempDir = await fs.realpath(rawTempDir);
-        planService = new PlanService({ basePath: tempDir }, mockLogger);
+        planService = new PlanService({ basePath: tempDir }, logger);
         vi.clearAllMocks();
     });
     afterEach(async () => {
@@ -40,38 +52,38 @@ describe('plan_read tool', () => {
     });
     describe('execute', () => {
         it('should return exists: false when no plan exists', async () => {
-            const tool = createPlanReadTool(planService);
+            const tool = createPlanReadTool(async () => planService);
             const sessionId = 'test-session';
-            const result = (await tool.execute({}, { sessionId }));
+            const result = (await tool.execute({}, createToolContext(logger, { sessionId })));
             expect(result.exists).toBe(false);
             expect(result.message).toContain('No plan found');
         });
         it('should return plan content and metadata when plan exists', async () => {
-            const tool = createPlanReadTool(planService);
+            const tool = createPlanReadTool(async () => planService);
             const sessionId = 'test-session';
             const content = '# My Plan\n\nSome content';
             const title = 'My Plan Title';
             await planService.create(sessionId, content, { title });
-            const result = (await tool.execute({}, { sessionId }));
+            const result = (await tool.execute({}, createToolContext(logger, { sessionId })));
             expect(result.exists).toBe(true);
             expect(result.content).toBe(content);
             expect(result.status).toBe('draft');
             expect(result.title).toBe(title);
-            expect(result.path).toBe(`.dexto/plans/${sessionId}/plan.md`);
+            expect(result.path).toBe(path.join(tempDir, sessionId, 'plan.md'));
         });
         it('should return ISO timestamps', async () => {
-            const tool = createPlanReadTool(planService);
+            const tool = createPlanReadTool(async () => planService);
             const sessionId = 'test-session';
             await planService.create(sessionId, '# Plan');
-            const result = (await tool.execute({}, { sessionId }));
+            const result = (await tool.execute({}, createToolContext(logger, { sessionId })));
             // Should be ISO format
             expect(result.createdAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
             expect(result.updatedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
         });
         it('should throw error when sessionId is missing', async () => {
-            const tool = createPlanReadTool(planService);
+            const tool = createPlanReadTool(async () => planService);
             try {
-                await tool.execute({}, {});
+                await tool.execute({}, createToolContext(logger));
                 expect.fail('Should have thrown an error');
             }
             catch (error) {

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

@@ -8,15 +8,24 @@
  * - Request Changes: Provide feedback for iteration
  * - Reject: Reject the plan entirely
  *
- * Uses the tool confirmation pattern (not elicitation) so the user
+ * Uses the tool approval pattern (not elicitation) so the user
  * can see the full plan content before deciding.
  */
-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 PlanReviewInputSchema: z.ZodObject<{
+    summary: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    summary?: string | undefined;
+}, {
+    summary?: string | undefined;
+}>;
 /**
  * Creates the plan_review tool
  *
- * @param planService - Service for plan operations
+ * @param getPlanService - Getter for the plan service
  */
-export declare function createPlanReviewTool(planService: PlanService): InternalTool;
+export declare function createPlanReviewTool(getPlanService: PlanServiceGetter): Tool<typeof PlanReviewInputSchema>;
+export {};
 //# sourceMappingURL=plan-review-tool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"plan-review-tool.d.ts","sourceRoot":"","sources":["../../src/tools/plan-review-tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAGH,OAAO,KAAK,EAAE,YAAY,EAAyC,MAAM,aAAa,CAAC;AACvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AActD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,WAAW,GAAG,YAAY,CAoE3E"}
+{"version":3,"file":"plan-review-tool.d.ts","sourceRoot":"","sources":["../../src/tools/plan-review-tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;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;;;;;;EAOd,CAAC;AAEd;;;;GAIG;AACH,wBAAgB,oBAAoB,CAChC,cAAc,EAAE,iBAAiB,GAClC,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAoEpC"}

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

@@ -8,10 +8,11 @@
  * - Request Changes: Provide feedback for iteration
  * - Reject: Reject the plan entirely
  *
- * Uses the tool confirmation pattern (not elicitation) so the user
+ * Uses the tool approval pattern (not elicitation) so the user
  * can see the full plan content before deciding.
  */
 import { z } from 'zod';
+import { defineTool } from '@dexto/core';
 import { PlanError } from '../errors.js';
 const PlanReviewInputSchema = z
     .object({
@@ -24,11 +25,12 @@ const PlanReviewInputSchema = z
 /**
  * Creates the plan_review tool
  *
- * @param planService - Service for plan operations
+ * @param getPlanService - Getter for the plan service
  */
-export function createPlanReviewTool(planService) {
-    return {
+export function createPlanReviewTool(getPlanService) {
+    return defineTool({
         id: 'plan_review',
+        displayName: 'Review Plan',
         description: 'Request user review of the current plan. Shows the full plan content for review with options to approve, request changes, or reject. Use after creating or updating a plan to get user approval before implementation.',
         inputSchema: PlanReviewInputSchema,
         /**
@@ -36,12 +38,13 @@ export function createPlanReviewTool(planService) {
          * The ApprovalPrompt component detects plan_review and shows custom options.
          */
         generatePreview: async (input, context) => {
+            const resolvedPlanService = await getPlanService(context);
             const { summary } = input;
-            if (!context?.sessionId) {
+            if (!context.sessionId) {
                 throw PlanError.sessionIdRequired();
             }
             // Read the current plan
-            const plan = await planService.read(context.sessionId);
+            const plan = await resolvedPlanService.read(context.sessionId);
             if (!plan) {
                 throw PlanError.planNotFound(context.sessionId);
             }
@@ -51,7 +54,7 @@ export function createPlanReviewTool(planService) {
                 displayContent = `## Summary\n${summary}\n\n---\n\n${plan.content}`;
             }
             const lineCount = displayContent.split('\n').length;
-            const planPath = planService.getPlanPath(context.sessionId);
+            const planPath = resolvedPlanService.getPlanPath(context.sessionId);
             return {
                 type: 'file',
                 path: planPath,
@@ -61,24 +64,25 @@ export function createPlanReviewTool(planService) {
                 lineCount,
             };
         },
-        execute: async (_input, context) => {
+        async execute(_input, context) {
+            const resolvedPlanService = await getPlanService(context);
             // Tool execution means user approved the plan (selected Approve or Approve + Accept Edits)
             // Request Changes and Reject are handled as denials in the approval flow
-            if (!context?.sessionId) {
+            if (!context.sessionId) {
                 throw PlanError.sessionIdRequired();
             }
             // Read plan to verify it still exists
-            const plan = await planService.read(context.sessionId);
+            const plan = await resolvedPlanService.read(context.sessionId);
             if (!plan) {
                 throw PlanError.planNotFound(context.sessionId);
             }
             // Update plan status to approved
-            await planService.updateMeta(context.sessionId, { status: 'approved' });
+            await resolvedPlanService.updateMeta(context.sessionId, { status: 'approved' });
             return {
                 approved: true,
                 message: 'Plan approved. You may now proceed with implementation.',
                 planStatus: 'approved',
             };
         },
-    };
+    });
 }

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

@@ -4,10 +4,19 @@
  * Updates the implementation plan for the current session.
  * Shows a diff 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 PlanUpdateInputSchema: z.ZodObject<{
+    content: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    content: string;
+}, {
+    content: string;
+}>;
 /**
  * Creates the plan_update tool
  */
-export declare function createPlanUpdateTool(planService: PlanService): InternalTool;
+export declare function createPlanUpdateTool(getPlanService: PlanServiceGetter): Tool<typeof PlanUpdateInputSchema>;
+export {};
 //# sourceMappingURL=plan-update-tool.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"plan-update-tool.d.ts","sourceRoot":"","sources":["../../src/tools/plan-update-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAyC,MAAM,aAAa,CAAC;AACvF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAkCtD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,WAAW,GAAG,YAAY,CAiD3E"}
+{"version":3,"file":"plan-update-tool.d.ts","sourceRoot":"","sources":["../../src/tools/plan-update-tool.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EAAE,IAAI,EAAyC,MAAM,aAAa,CAAC;AAC/E,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAGnE,QAAA,MAAM,qBAAqB;;;;;;EAId,CAAC;AAyBd;;GAEG;AACH,wBAAgB,oBAAoB,CAChC,cAAc,EAAE,iBAAiB,GAClC,IAAI,CAAC,OAAO,qBAAqB,CAAC,CAiDpC"}

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

@@ -6,6 +6,7 @@
  */
 import { z } from 'zod';
 import { createPatch } from 'diff';
+import { defineTool } from '@dexto/core';
 import { PlanError } from '../errors.js';
 const PlanUpdateInputSchema = z
     .object({
@@ -32,35 +33,38 @@ function generateDiffPreview(filePath, originalContent, newContent) {
 /**
  * Creates the plan_update tool
  */
-export function createPlanUpdateTool(planService) {
-    return {
+export function createPlanUpdateTool(getPlanService) {
+    return defineTool({
         id: 'plan_update',
+        displayName: 'Update Plan',
         description: 'Update the existing implementation plan for this session. Shows a diff preview for approval before saving. The plan must already exist (use plan_create first).',
         inputSchema: PlanUpdateInputSchema,
         /**
          * Generate diff preview for approval UI
          */
         generatePreview: async (input, context) => {
+            const resolvedPlanService = await getPlanService(context);
             const { content: newContent } = input;
-            if (!context?.sessionId) {
+            if (!context.sessionId) {
                 throw PlanError.sessionIdRequired();
             }
             // Read existing plan
-            const existing = await planService.read(context.sessionId);
+            const existing = await resolvedPlanService.read(context.sessionId);
             if (!existing) {
                 throw PlanError.planNotFound(context.sessionId);
             }
             // Generate diff preview
-            const planPath = planService.getPlanPath(context.sessionId);
+            const planPath = resolvedPlanService.getPlanPath(context.sessionId);
             return generateDiffPreview(planPath, existing.content, newContent);
         },
-        execute: async (input, context) => {
+        async execute(input, context) {
+            const resolvedPlanService = await getPlanService(context);
             const { content } = input;
-            if (!context?.sessionId) {
+            if (!context.sessionId) {
                 throw PlanError.sessionIdRequired();
             }
-            const result = await planService.update(context.sessionId, content);
-            const planPath = planService.getPlanPath(context.sessionId);
+            const result = await resolvedPlanService.update(context.sessionId, content);
+            const planPath = resolvedPlanService.getPlanPath(context.sessionId);
             return {
                 success: true,
                 path: planPath,
@@ -68,5 +72,5 @@ export function createPlanUpdateTool(planService) {
                 _display: generateDiffPreview(planPath, result.oldContent, result.newContent),
             };
         },
-    };
+    });
 }