@dexto/tools-plan 1.5.8 → 1.6.1

package/dist/plan-service.test.js

@@ -1,220 +1,204 @@
-/**
- * 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
+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";
 const createMockLogger = () => ({
-    debug: vi.fn(),
-    info: vi.fn(),
-    warn: vi.fn(),
-    error: vi.fn(),
-    createChild: vi.fn().mockReturnThis(),
+  debug: vi.fn(),
+  silly: vi.fn(),
+  info: vi.fn(),
+  warn: vi.fn(),
+  error: vi.fn(),
+  trackException: vi.fn(),
+  createChild: vi.fn().mockReturnThis(),
+  setLevel: vi.fn(),
+  getLevel: vi.fn(() => "debug"),
+  getLogFilePath: vi.fn(() => null),
+  destroy: vi.fn(async () => void 0)
 });
-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
-            }
-        });
+describe("PlanService", () => {
+  let mockLogger;
+  let tempDir;
+  let planService;
+  beforeEach(async () => {
+    mockLogger = createMockLogger();
+    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 () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  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);
+      const planPath = path.join(tempDir, sessionId, "plan.md");
+      const storedContent = await fs.readFile(planPath, "utf-8");
+      expect(storedContent).toBe(content);
+      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");
+      const metaPath = path.join(tempDir, sessionId, "plan-meta.json");
+      await fs.writeFile(metaPath, JSON.stringify({ invalidField: "value" }));
+      const plan = await planService.read(sessionId);
+      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");
+      const metaPath = path.join(tempDir, sessionId, "plan-meta.json");
+      await fs.writeFile(metaPath, "{ invalid json }");
+      const plan = await planService.read(sessionId);
+      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 {
+      }
+    });
+  });
 });

package/dist/tool-factory-config.cjs

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

package/dist/tool-factory-config.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Plan Tools Factory
+ *
+ * Provides implementation planning tools:
+ * - plan_create: Create a new plan for the session
+ * - plan_read: Read the current plan
+ * - plan_update: Update the existing plan
+ * - plan_review: Request user review of the plan (shows plan content with approval options)
+ */
+import { z } from 'zod';
+/**
+ * Available plan tool names for enabledTools configuration
+ */
+export declare const PLAN_TOOL_NAMES: readonly ["plan_create", "plan_read", "plan_update", "plan_review"];
+/**
+ * Configuration schema for Plan tools factory
+ */
+export 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;
+}>;
+export type PlanToolsConfig = z.output<typeof PlanToolsConfigSchema>;
+//# sourceMappingURL=tool-factory-config.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-factory-config.d.ts","sourceRoot":"","sources":["../src/tool-factory-config.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;GAEG;AACH,eAAO,MAAM,eAAe,qEAAsE,CAAC;AAEnG;;GAEG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;EAcrB,CAAC;AAEd,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/tool-factory-config.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+const PLAN_TOOL_NAMES = ["plan_create", "plan_read", "plan_update", "plan_review"];
+const PlanToolsConfigSchema = z.object({
+  type: z.literal("plan-tools"),
+  basePath: z.string().default(".dexto/plans").describe("Base directory for plan storage (relative to working directory)"),
+  enabledTools: z.array(z.enum(PLAN_TOOL_NAMES)).optional().describe(
+    `Subset of tools to enable. If not specified, all tools are enabled. Available: ${PLAN_TOOL_NAMES.join(", ")}`
+  )
+}).strict();
+export {
+  PLAN_TOOL_NAMES,
+  PlanToolsConfigSchema
+};

package/dist/tool-factory.cjs

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

package/dist/tool-factory.d.ts

@@ -0,0 +1,4 @@
+import type { ToolFactory } from '@dexto/agent-config';
+import { type PlanToolsConfig } from './tool-factory-config.js';
+export declare const planToolsFactory: ToolFactory<PlanToolsConfig>;
+//# sourceMappingURL=tool-factory.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool-factory.d.ts","sourceRoot":"","sources":["../src/tool-factory.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAQvD,OAAO,EAGH,KAAK,eAAe,EACvB,MAAM,0BAA0B,CAAC;AAKlC,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,eAAe,CAiCzD,CAAC"}

package/dist/tool-factory.js

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