@dexto/tools-plan 1.6.0 → 1.6.2

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

@@ -0,0 +1,65 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_read_tool_exports = {};
+__export(plan_read_tool_exports, {
+  createPlanReadTool: () => createPlanReadTool
+});
+module.exports = __toCommonJS(plan_read_tool_exports);
+var import_zod = require("zod");
+var import_core = require("@dexto/core");
+var import_errors = require("../errors.js");
+const PlanReadInputSchema = import_zod.z.object({}).strict();
+function createPlanReadTool(getPlanService) {
+  return (0, import_core.defineTool)({
+    id: "plan_read",
+    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,
+    presentation: {
+      describeHeader: () => (0, import_core.createLocalToolCallHeader)({
+        title: "Read Plan"
+      })
+    },
+    async execute(_input, context) {
+      const resolvedPlanService = await getPlanService(context);
+      if (!context.sessionId) {
+        throw import_errors.PlanError.sessionIdRequired();
+      }
+      const plan = await resolvedPlanService.read(context.sessionId);
+      if (!plan) {
+        return {
+          exists: false,
+          message: `No plan found for this session. Use plan_create to create one.`
+        };
+      }
+      return {
+        exists: true,
+        path: resolvedPlanService.getPlanPath(context.sessionId),
+        content: plan.content,
+        status: plan.meta.status,
+        title: plan.meta.title,
+        createdAt: new Date(plan.meta.createdAt).toISOString(),
+        updatedAt: new Date(plan.meta.updatedAt).toISOString()
+      };
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPlanReadTool
+});

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;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"}
+{"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,CAuClC"}

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

@@ -1,43 +1,41 @@
-/**
- * Plan Read Tool
- *
- * Reads the current implementation plan for the session.
- * No approval needed - read-only operation.
- */
-import { z } from 'zod';
-import { defineTool } from '@dexto/core';
-import { PlanError } from '../errors.js';
+import { z } from "zod";
+import { createLocalToolCallHeader, defineTool } from "@dexto/core";
+import { PlanError } from "../errors.js";
 const PlanReadInputSchema = z.object({}).strict();
-/**
- * Creates the plan_read tool
- */
-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,
-        async execute(_input, context) {
-            const resolvedPlanService = await getPlanService(context);
-            if (!context.sessionId) {
-                throw PlanError.sessionIdRequired();
-            }
-            const plan = await resolvedPlanService.read(context.sessionId);
-            if (!plan) {
-                return {
-                    exists: false,
-                    message: `No plan found for this session. Use plan_create to create one.`,
-                };
-            }
-            return {
-                exists: true,
-                path: resolvedPlanService.getPlanPath(context.sessionId),
-                content: plan.content,
-                status: plan.meta.status,
-                title: plan.meta.title,
-                createdAt: new Date(plan.meta.createdAt).toISOString(),
-                updatedAt: new Date(plan.meta.updatedAt).toISOString(),
-            };
-        },
-    });
+function createPlanReadTool(getPlanService) {
+  return defineTool({
+    id: "plan_read",
+    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,
+    presentation: {
+      describeHeader: () => createLocalToolCallHeader({
+        title: "Read Plan"
+      })
+    },
+    async execute(_input, context) {
+      const resolvedPlanService = await getPlanService(context);
+      if (!context.sessionId) {
+        throw PlanError.sessionIdRequired();
+      }
+      const plan = await resolvedPlanService.read(context.sessionId);
+      if (!plan) {
+        return {
+          exists: false,
+          message: `No plan found for this session. Use plan_create to create one.`
+        };
+      }
+      return {
+        exists: true,
+        path: resolvedPlanService.getPlanPath(context.sessionId),
+        content: plan.content,
+        status: plan.meta.status,
+        title: plan.meta.title,
+        createdAt: new Date(plan.meta.createdAt).toISOString(),
+        updatedAt: new Date(plan.meta.updatedAt).toISOString()
+      };
+    }
+  });
 }
+export {
+  createPlanReadTool
+};

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

@@ -0,0 +1,109 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_vitest = require("vitest");
+var path = __toESM(require("node:path"), 1);
+var fs = __toESM(require("node:fs/promises"), 1);
+var os = __toESM(require("node:os"), 1);
+var import_plan_read_tool = require("./plan-read-tool.js");
+var import_plan_service = require("../plan-service.js");
+var import_errors = require("../errors.js");
+var import_core = require("@dexto/core");
+const createMockLogger = () => {
+  const logger = {
+    debug: import_vitest.vi.fn(),
+    silly: import_vitest.vi.fn(),
+    info: import_vitest.vi.fn(),
+    warn: import_vitest.vi.fn(),
+    error: import_vitest.vi.fn(),
+    trackException: import_vitest.vi.fn(),
+    createChild: import_vitest.vi.fn(() => logger),
+    createFileOnlyChild: import_vitest.vi.fn(() => logger),
+    setLevel: import_vitest.vi.fn(),
+    getLevel: import_vitest.vi.fn(() => "debug"),
+    getLogFilePath: import_vitest.vi.fn(() => null),
+    destroy: import_vitest.vi.fn(async () => void 0)
+  };
+  return logger;
+};
+function createToolContext(logger, overrides = {}) {
+  return { logger, ...overrides };
+}
+(0, import_vitest.describe)("plan_read tool", () => {
+  let logger;
+  let tempDir;
+  let planService;
+  (0, import_vitest.beforeEach)(async () => {
+    logger = createMockLogger();
+    const rawTempDir = await fs.mkdtemp(path.join(os.tmpdir(), "dexto-plan-read-test-"));
+    tempDir = await fs.realpath(rawTempDir);
+    planService = new import_plan_service.PlanService({ basePath: tempDir }, logger);
+    import_vitest.vi.clearAllMocks();
+  });
+  (0, import_vitest.afterEach)(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  (0, import_vitest.describe)("execute", () => {
+    (0, import_vitest.it)("should return exists: false when no plan exists", async () => {
+      const tool = (0, import_plan_read_tool.createPlanReadTool)(async () => planService);
+      const sessionId = "test-session";
+      const result = await tool.execute({}, createToolContext(logger, { sessionId }));
+      (0, import_vitest.expect)(result.exists).toBe(false);
+      (0, import_vitest.expect)(result.message).toContain("No plan found");
+    });
+    (0, import_vitest.it)("should return plan content and metadata when plan exists", async () => {
+      const tool = (0, import_plan_read_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({}, createToolContext(logger, { sessionId }));
+      (0, import_vitest.expect)(result.exists).toBe(true);
+      (0, import_vitest.expect)(result.content).toBe(content);
+      (0, import_vitest.expect)(result.status).toBe("draft");
+      (0, import_vitest.expect)(result.title).toBe(title);
+      (0, import_vitest.expect)(result.path).toBe(path.join(tempDir, sessionId, "plan.md"));
+    });
+    (0, import_vitest.it)("should return ISO timestamps", async () => {
+      const tool = (0, import_plan_read_tool.createPlanReadTool)(async () => planService);
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Plan");
+      const result = await tool.execute({}, createToolContext(logger, { sessionId }));
+      (0, import_vitest.expect)(result.createdAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+      (0, import_vitest.expect)(result.updatedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+    });
+    (0, import_vitest.it)("should throw error when sessionId is missing", async () => {
+      const tool = (0, import_plan_read_tool.createPlanReadTool)(async () => planService);
+      try {
+        await tool.execute({}, createToolContext(logger));
+        import_vitest.expect.fail("Should have thrown an error");
+      } catch (error) {
+        (0, import_vitest.expect)(error).toBeInstanceOf(import_core.DextoRuntimeError);
+        (0, import_vitest.expect)(error.code).toBe(import_errors.PlanErrorCode.SESSION_ID_REQUIRED);
+      }
+    });
+  });
+});

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

@@ -1,95 +1,86 @@
-/**
- * Plan Read Tool Tests
- *
- * Tests for the plan_read tool.
- */
-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 { createPlanReadTool } from './plan-read-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 { createPlanReadTool } from "./plan-read-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_read tool', () => {
-    let logger;
-    let tempDir;
-    let planService;
-    beforeEach(async () => {
-        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 }, logger);
-        vi.clearAllMocks();
+describe("plan_read tool", () => {
+  let logger;
+  let tempDir;
+  let planService;
+  beforeEach(async () => {
+    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 }, logger);
+    vi.clearAllMocks();
+  });
+  afterEach(async () => {
+    try {
+      await fs.rm(tempDir, { recursive: true, force: true });
+    } catch {
+    }
+  });
+  describe("execute", () => {
+    it("should return exists: false when no plan exists", async () => {
+      const tool = createPlanReadTool(async () => planService);
+      const sessionId = "test-session";
+      const result = await tool.execute({}, createToolContext(logger, { sessionId }));
+      expect(result.exists).toBe(false);
+      expect(result.message).toContain("No plan found");
     });
-    afterEach(async () => {
-        try {
-            await fs.rm(tempDir, { recursive: true, force: true });
-        }
-        catch {
-            // Ignore cleanup errors
-        }
+    it("should return plan content and metadata when plan exists", async () => {
+      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({}, 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(path.join(tempDir, sessionId, "plan.md"));
     });
-    describe('execute', () => {
-        it('should return exists: false when no plan exists', async () => {
-            const tool = createPlanReadTool(async () => planService);
-            const sessionId = 'test-session';
-            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(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({}, 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(path.join(tempDir, sessionId, 'plan.md'));
-        });
-        it('should return ISO timestamps', async () => {
-            const tool = createPlanReadTool(async () => planService);
-            const sessionId = 'test-session';
-            await planService.create(sessionId, '# Plan');
-            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(async () => planService);
-            try {
-                await tool.execute({}, 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 return ISO timestamps", async () => {
+      const tool = createPlanReadTool(async () => planService);
+      const sessionId = "test-session";
+      await planService.create(sessionId, "# Plan");
+      const result = await tool.execute({}, createToolContext(logger, { sessionId }));
+      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(async () => planService);
+      try {
+        await tool.execute({}, createToolContext(logger));
+        expect.fail("Should have thrown an error");
+      } catch (error) {
+        expect(error).toBeInstanceOf(DextoRuntimeError);
+        expect(error.code).toBe(PlanErrorCode.SESSION_ID_REQUIRED);
+      }
+    });
+  });
 });

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

@@ -0,0 +1,98 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var plan_review_tool_exports = {};
+__export(plan_review_tool_exports, {
+  createPlanReviewTool: () => createPlanReviewTool
+});
+module.exports = __toCommonJS(plan_review_tool_exports);
+var import_zod = require("zod");
+var import_core = require("@dexto/core");
+var import_errors = require("../errors.js");
+const PlanReviewInputSchema = import_zod.z.object({
+  summary: import_zod.z.string().optional().describe("Brief summary of the plan for context (shown above the plan content)")
+}).strict();
+function createPlanReviewTool(getPlanService) {
+  return (0, import_core.defineTool)({
+    id: "plan_review",
+    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,
+    presentation: {
+      describeHeader: (input) => (0, import_core.createLocalToolCallHeader)({
+        title: "Review Plan",
+        ...input.summary ? { argsText: (0, import_core.truncateForHeader)(input.summary, 140) } : {}
+      }),
+      /**
+       * Generate preview showing the plan content for review.
+       * The ApprovalPrompt component detects plan_review and shows custom options.
+       */
+      preview: async (input, context) => {
+        const resolvedPlanService = await getPlanService(context);
+        const { summary } = input;
+        if (!context.sessionId) {
+          throw import_errors.PlanError.sessionIdRequired();
+        }
+        const plan = await resolvedPlanService.read(context.sessionId);
+        if (!plan) {
+          throw import_errors.PlanError.planNotFound(context.sessionId);
+        }
+        let displayContent = plan.content;
+        if (summary) {
+          displayContent = `## Summary
+${summary}
+
+---
+
+${plan.content}`;
+        }
+        const lineCount = displayContent.split("\n").length;
+        const planPath = resolvedPlanService.getPlanPath(context.sessionId);
+        return {
+          type: "file",
+          title: "Review Plan",
+          path: planPath,
+          operation: "read",
+          // 'read' indicates this is for viewing, not creating/modifying
+          content: displayContent,
+          size: Buffer.byteLength(displayContent, "utf8"),
+          lineCount
+        };
+      }
+    },
+    async execute(_input, context) {
+      const resolvedPlanService = await getPlanService(context);
+      if (!context.sessionId) {
+        throw import_errors.PlanError.sessionIdRequired();
+      }
+      const plan = await resolvedPlanService.read(context.sessionId);
+      if (!plan) {
+        throw import_errors.PlanError.planNotFound(context.sessionId);
+      }
+      await resolvedPlanService.updateMeta(context.sessionId, { status: "approved" });
+      return {
+        approved: true,
+        message: "Plan approved. You may now proceed with implementation.",
+        planStatus: "approved"
+      };
+    }
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createPlanReviewTool
+});

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;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"}
+{"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,CA2EpC"}