@dexto/tools-plan 1.6.0 → 1.6.2

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

@@ -1,163 +1,180 @@
-/**
- * Plan Update Tool Tests
- *
- * Tests for the plan_update tool including diff preview generation.
- */
-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 { createPlanUpdateTool } from './plan-update-tool.js';
-import { PlanService } from '../plan-service.js';
-import { PlanErrorCode } from '../errors.js';
-import { DextoRuntimeError } from '@dexto/core';
-// Create mock logger
+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 { createPlanUpdateTool } from "./plan-update-tool.js";
+import { PlanService } from "../plan-service.js";
+import { PlanErrorCode } from "../errors.js";
+import { DextoRuntimeError } from "@dexto/core";
 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;
+  const logger = {
+    debug: vi.fn(),
+    silly: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    trackException: vi.fn(),
+    createChild: vi.fn(() => logger),
+    createFileOnlyChild: vi.fn(() => logger),
+    setLevel: vi.fn(),
+    getLevel: vi.fn(() => "debug"),
+    getLogFilePath: vi.fn(() => null),
+    destroy: vi.fn(async () => void 0)
+  };
+  return logger;
 };
 function createToolContext(logger, overrides = {}) {
-    return { logger, ...overrides };
+  return { logger, ...overrides };
 }
-describe('plan_update tool', () => {
-    let logger;
-    let tempDir;
-    let planService;
-    beforeEach(async () => {
-        logger = createMockLogger();
-        const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'dexto-plan-update-test-'));
-        tempDir = await fs.realpath(rawTempDir);
-        planService = new PlanService({ basePath: tempDir }, logger);
-        vi.clearAllMocks();
+describe("plan_update tool", () => {
+  let logger;
+  let tempDir;
+  let planService;
+  beforeEach(async () => {
+    logger = createMockLogger();
+    const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-plan-update-test-"));
+    tempDir = await fs.realpath(rawTempDir);
+    planService = new PlanService({ basePath: tempDir }, logger);
+    vi.clearAllMocks();
+  });
+  afterEach(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  describe("generatePreview", () => {
+    it("should return DiffDisplayData with unified diff", async () => {
+      const tool = createPlanUpdateTool(async () => planService);
+      const sessionId = "test-session";
+      const originalContent = "# Plan\n\n## Steps\n1. First step";
+      const newContent = "# Plan\n\n## Steps\n1. First step\n2. Second step";
+      const previewFn = tool.presentation?.preview;
+      expect(previewFn).toBeDefined();
+      await planService.create(sessionId, originalContent);
+      const preview = await previewFn(
+        { content: newContent },
+        createToolContext(logger, { sessionId })
+      );
+      expect(preview.type).toBe("diff");
+      expect(preview.title).toBe("Update Plan");
+      expect(preview.filename).toContain(sessionId);
+      expect(preview.filename).toMatch(/plan\.md$/);
+      expect(preview.unified).toContain("-1. First step");
+      expect(preview.unified).toContain("+1. First step");
+      expect(preview.unified).toContain("+2. Second step");
+      expect(preview.additions).toBeGreaterThan(0);
     });
-    afterEach(async () => {
-        try {
-            await fs.rm(tempDir, { recursive: true, force: true });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
+    it("should throw error when plan does not exist", async () => {
+      const tool = createPlanUpdateTool(async () => planService);
+      const sessionId = "test-session";
+      const previewFn = tool.presentation?.preview;
+      expect(previewFn).toBeDefined();
+      try {
+        await previewFn(
+          { 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_NOT_FOUND);
+      }
     });
-    describe('generatePreview', () => {
-        it('should return DiffDisplayData with unified diff', async () => {
-            const tool = createPlanUpdateTool(async () => planService);
-            const sessionId = 'test-session';
-            const originalContent = '# Plan\n\n## Steps\n1. First step';
-            const newContent = '# Plan\n\n## Steps\n1. First step\n2. Second step';
-            await planService.create(sessionId, originalContent);
-            const preview = (await tool.generatePreview({ content: newContent }, createToolContext(logger, { sessionId })));
-            expect(preview.type).toBe('diff');
-            // Path is now absolute, check it ends with the expected suffix
-            expect(preview.filename).toContain(sessionId);
-            expect(preview.filename).toMatch(/plan\.md$/);
-            expect(preview.unified).toContain('-1. First step');
-            expect(preview.unified).toContain('+1. First step');
-            expect(preview.unified).toContain('+2. Second step');
-            expect(preview.additions).toBeGreaterThan(0);
-        });
-        it('should throw error when plan does not exist', async () => {
-            const tool = createPlanUpdateTool(async () => planService);
-            const sessionId = 'test-session';
-            try {
-                await tool.generatePreview({ 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_NOT_FOUND);
-            }
-        });
-        it('should throw error when sessionId is missing', async () => {
-            const tool = createPlanUpdateTool(async () => planService);
-            try {
-                await tool.generatePreview({ content: '# Content' }, createToolContext(logger));
-                expect.fail('Should have thrown an error');
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(DextoRuntimeError);
-                expect(error.code).toBe(PlanErrorCode.SESSION_ID_REQUIRED);
-            }
-        });
-        it('should show deletions in diff', async () => {
-            const tool = createPlanUpdateTool(async () => planService);
-            const sessionId = 'test-session';
-            const originalContent = '# Plan\n\nLine to remove\nKeep this';
-            const newContent = '# Plan\n\nKeep this';
-            await planService.create(sessionId, originalContent);
-            const preview = (await tool.generatePreview({ content: newContent }, createToolContext(logger, { sessionId })));
-            expect(preview.deletions).toBeGreaterThan(0);
-            expect(preview.unified).toContain('-Line to remove');
-        });
+    it("should throw error when sessionId is missing", async () => {
+      const tool = createPlanUpdateTool(async () => planService);
+      const previewFn = tool.presentation?.preview;
+      expect(previewFn).toBeDefined();
+      try {
+        await previewFn({ content: "# Content" }, createToolContext(logger));
+        expect.fail("Should have thrown an error");
+      } catch (error) {
+        expect(error).toBeInstanceOf(DextoRuntimeError);
+        expect(error.code).toBe(PlanErrorCode.SESSION_ID_REQUIRED);
+      }
     });
-    describe('execute', () => {
-        it('should update plan content and return success', async () => {
-            const tool = createPlanUpdateTool(async () => planService);
-            const sessionId = 'test-session';
-            const originalContent = '# Original Plan';
-            const newContent = '# Updated Plan';
-            await planService.create(sessionId, originalContent);
-            const result = (await tool.execute({ content: newContent }, createToolContext(logger, { sessionId })));
-            expect(result.success).toBe(true);
-            // Path is now absolute, check it ends with the expected suffix
-            expect(result.path).toContain(sessionId);
-            expect(result.path).toMatch(/plan\.md$/);
-            // Verify content was updated
-            const plan = await planService.read(sessionId);
-            expect(plan.content).toBe(newContent);
-        });
-        it('should include _display data with diff', async () => {
-            const tool = createPlanUpdateTool(async () => planService);
-            const sessionId = 'test-session';
-            await planService.create(sessionId, '# Original');
-            const result = (await tool.execute({ content: '# Updated' }, createToolContext(logger, { sessionId })));
-            expect(result._display).toBeDefined();
-            expect(result._display.type).toBe('diff');
-            expect(result._display.unified).toContain('-# Original');
-            expect(result._display.unified).toContain('+# Updated');
-        });
-        it('should throw error when plan does not exist', async () => {
-            const tool = createPlanUpdateTool(async () => planService);
-            const sessionId = 'non-existent';
-            try {
-                await tool.execute({ content: '# Content' }, createToolContext(logger, { sessionId }));
-                expect.fail('Should have thrown an error');
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(DextoRuntimeError);
-                expect(error.code).toBe(PlanErrorCode.PLAN_NOT_FOUND);
-            }
-        });
-        it('should throw error when sessionId is missing', async () => {
-            const tool = createPlanUpdateTool(async () => planService);
-            try {
-                await tool.execute({ content: '# Content' }, createToolContext(logger));
-                expect.fail('Should have thrown an error');
-            }
-            catch (error) {
-                expect(error).toBeInstanceOf(DextoRuntimeError);
-                expect(error.code).toBe(PlanErrorCode.SESSION_ID_REQUIRED);
-            }
-        });
-        it('should preserve plan status after update', async () => {
-            const tool = createPlanUpdateTool(async () => planService);
-            const sessionId = 'test-session';
-            await planService.create(sessionId, '# Plan');
-            await planService.updateMeta(sessionId, { status: 'approved' });
-            await tool.execute({ content: '# Updated Plan' }, createToolContext(logger, { sessionId }));
-            const plan = await planService.read(sessionId);
-            expect(plan.meta.status).toBe('approved');
-        });
+    it("should show deletions in diff", async () => {
+      const tool = createPlanUpdateTool(async () => planService);
+      const sessionId = "test-session";
+      const originalContent = "# Plan\n\nLine to remove\nKeep this";
+      const newContent = "# Plan\n\nKeep this";
+      const previewFn = tool.presentation?.preview;
+      expect(previewFn).toBeDefined();
+      await planService.create(sessionId, originalContent);
+      const preview = await previewFn(
+        { content: newContent },
+        createToolContext(logger, { sessionId })
+      );
+      expect(preview.deletions).toBeGreaterThan(0);
+      expect(preview.unified).toContain("-Line to remove");
     });
+  });
+  describe("execute", () => {
+    it("should update plan content and return success", async () => {
+      const tool = createPlanUpdateTool(async () => planService);
+      const sessionId = "test-session";
+      const originalContent = "# Original Plan";
+      const newContent = "# Updated Plan";
+      await planService.create(sessionId, originalContent);
+      const result = await tool.execute(
+        { content: newContent },
+        createToolContext(logger, { sessionId })
+      );
+      expect(result.success).toBe(true);
+      expect(result.path).toContain(sessionId);
+      expect(result.path).toMatch(/plan\.md$/);
+      const plan = await planService.read(sessionId);
+      expect(plan.content).toBe(newContent);
+    });
+    it("should include _display data with diff", async () => {
+      const tool = createPlanUpdateTool(async () => planService);
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Original");
+      const result = await tool.execute(
+        { content: "# Updated" },
+        createToolContext(logger, { sessionId })
+      );
+      expect(result._display).toBeDefined();
+      expect(result._display.type).toBe("diff");
+      expect(result._display.title).toBe("Update Plan");
+      expect(result._display.unified).toContain("-# Original");
+      expect(result._display.unified).toContain("+# Updated");
+    });
+    it("should throw error when plan does not exist", async () => {
+      const tool = createPlanUpdateTool(async () => planService);
+      const sessionId = "non-existent";
+      try {
+        await tool.execute(
+          { content: "# Content" },
+          createToolContext(logger, { sessionId })
+        );
+        expect.fail("Should have thrown an error");
+      } catch (error) {
+        expect(error).toBeInstanceOf(DextoRuntimeError);
+        expect(error.code).toBe(PlanErrorCode.PLAN_NOT_FOUND);
+      }
+    });
+    it("should throw error when sessionId is missing", async () => {
+      const tool = createPlanUpdateTool(async () => planService);
+      try {
+        await tool.execute({ content: "# Content" }, createToolContext(logger));
+        expect.fail("Should have thrown an error");
+      } catch (error) {
+        expect(error).toBeInstanceOf(DextoRuntimeError);
+        expect(error.code).toBe(PlanErrorCode.SESSION_ID_REQUIRED);
+      }
+    });
+    it("should preserve plan status after update", async () => {
+      const tool = createPlanUpdateTool(async () => planService);
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Plan");
+      await planService.updateMeta(sessionId, { status: "approved" });
+      await tool.execute(
+        { content: "# Updated Plan" },
+        createToolContext(logger, { sessionId })
+      );
+      const plan = await planService.read(sessionId);
+      expect(plan.meta.status).toBe("approved");
+    });
+  });
 });

package/dist/types.cjs

@@ -0,0 +1,44 @@
+"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 types_exports = {};
+__export(types_exports, {
+  PlanMetaSchema: () => PlanMetaSchema,
+  PlanStatusSchema: () => PlanStatusSchema
+});
+module.exports = __toCommonJS(types_exports);
+var import_zod = require("zod");
+const PlanStatusSchema = import_zod.z.enum([
+  "draft",
+  "approved",
+  "in_progress",
+  "completed",
+  "abandoned"
+]);
+const PlanMetaSchema = import_zod.z.object({
+  sessionId: import_zod.z.string().describe("Session ID this plan belongs to"),
+  status: PlanStatusSchema.default("draft").describe("Current plan status"),
+  title: import_zod.z.string().optional().describe("Plan title"),
+  createdAt: import_zod.z.number().describe("Unix timestamp when plan was created"),
+  updatedAt: import_zod.z.number().describe("Unix timestamp when plan was last updated")
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PlanMetaSchema,
+  PlanStatusSchema
+});

package/dist/types.js

@@ -1,26 +1,19 @@
-/**
- * Plan Types and Schemas
- *
- * Defines the structure of plans and their metadata.
- */
-import { z } from 'zod';
-/**
- * Plan status values
- */
-export const PlanStatusSchema = z.enum([
-    'draft',
-    'approved',
-    'in_progress',
-    'completed',
-    'abandoned',
+import { z } from "zod";
+const PlanStatusSchema = z.enum([
+  "draft",
+  "approved",
+  "in_progress",
+  "completed",
+  "abandoned"
 ]);
-/**
- * Plan metadata stored alongside the plan content
- */
-export const PlanMetaSchema = z.object({
-    sessionId: z.string().describe('Session ID this plan belongs to'),
-    status: PlanStatusSchema.default('draft').describe('Current plan status'),
-    title: z.string().optional().describe('Plan title'),
-    createdAt: z.number().describe('Unix timestamp when plan was created'),
-    updatedAt: z.number().describe('Unix timestamp when plan was last updated'),
+const PlanMetaSchema = z.object({
+  sessionId: z.string().describe("Session ID this plan belongs to"),
+  status: PlanStatusSchema.default("draft").describe("Current plan status"),
+  title: z.string().optional().describe("Plan title"),
+  createdAt: z.number().describe("Unix timestamp when plan was created"),
+  updatedAt: z.number().describe("Unix timestamp when plan was last updated")
 });
+export {
+  PlanMetaSchema,
+  PlanStatusSchema
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dexto/tools-plan",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Implementation planning tools with session-linked plans",
   "type": "module",
   "main": "./dist/index.js",
@@ -15,22 +15,23 @@
     "dist"
   ],
   "dependencies": {
-    "diff": "^7.0.0",
+    "diff": "^8.0.3",
     "zod": "^3.24.1",
-    "@dexto/agent-config": "1.6.0",
-    "@dexto/core": "1.6.0"
+    "@dexto/agent-config": "1.6.2",
+    "@dexto/core": "1.6.2"
   },
   "devDependencies": {
     "@types/diff": "^7.0.0",
     "@types/node": "^22.10.5",
     "dotenv": "^16.4.7",
+    "tsup": "^8.0.0",
     "typescript": "^5.7.2",
     "vitest": "^2.1.8"
   },
-  "author": "Dexto",
-  "license": "MIT",
+  "license": "Elastic-2.0",
   "scripts": {
-    "build": "tsc",
+    "build": "tsup && node ../../scripts/clean-tsbuildinfo.mjs && tsc -b tsconfig.json --emitDeclarationOnly",
+    "dev": "tsup --watch",
     "clean": "rm -rf dist",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",