@dexto/tools-plan 1.5.8 → 1.6.1

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.5.8",
+  "version": "1.6.1",
   "description": "Implementation planning tools with session-linked plans",
   "type": "module",
   "main": "./dist/index.js",
@@ -12,26 +12,26 @@
     }
   },
   "files": [
-    "dist",
-    ".dexto-plugin",
-    "skills"
+    "dist"
   ],
   "dependencies": {
     "diff": "^7.0.0",
     "zod": "^3.24.1",
-    "@dexto/core": "1.5.8"
+    "@dexto/agent-config": "1.6.1",
+    "@dexto/core": "1.6.1"
   },
   "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",

package/.dexto-plugin/plugin.json

@@ -1,7 +0,0 @@
-{
-  "name": "plan-tools",
-  "version": "0.1.0",
-  "description": "Implementation planning tools with session-linked plans. Create, read, and update plans tied to your session.",
-  "author": "Dexto",
-  "customToolProviders": ["plan-tools"]
-}

package/dist/tool-provider.d.ts

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

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

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

package/dist/tool-provider.js

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

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

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

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

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

package/dist/tool-provider.test.js

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

package/skills/plan/SKILL.md

@@ -1,102 +0,0 @@
----
-name: plan
-description: Enter planning mode to create and manage implementation plans
-user-invocable: true
----
-
-# Planning Mode - PLAN FIRST, THEN IMPLEMENT
-
-**CRITICAL**: You are in planning mode. You MUST create and get approval for a plan BEFORE writing any code or making any changes.
-
-## MANDATORY WORKFLOW
-
-**DO NOT skip these steps. DO NOT start implementing until the plan is approved.**
-
-1. **Research first** (if needed): Use the explore agent or read relevant files to understand the codebase
-2. **Check for existing plan**: Use `plan_read` to see if a plan exists
-3. **Create/update plan**: Use `plan_create` or `plan_update` to define your approach
-4. **Request review**: Use `plan_review` to get user approval
-5. **WAIT for approval**: Only proceed to implementation after user approves
-6. **Implement**: Execute the approved plan, updating checkboxes as you go
-
-## Research Phase
-
-Before creating your plan, you should understand the codebase:
-
-- **Use the explore agent** (spawn_agent with subagent_type="Explore") to search for relevant code, patterns, and existing implementations
-- **Read key files** to understand the current architecture
-- **Identify dependencies** and files that will need changes
-
-This research informs your plan and prevents wasted effort from incorrect assumptions.
-
-## Available Tools
-
-- **plan_create**: Create a new plan (REQUIRED before any implementation)
-- **plan_read**: Read the current plan
-- **plan_update**: Update the existing plan (shows diff preview)
-- **plan_review**: Request user review - returns approve/iterate/reject with feedback
-
-## WHAT YOU MUST DO NOW
-
-1. **Research**: Use the explore agent or read files to understand the relevant parts of the codebase
-2. **Check plan**: Use `plan_read` to check if a plan already exists
-3. **Create plan**: Use `plan_create` to create a comprehensive plan based on your research
-4. **Get approval**: Use `plan_review` to request user approval
-5. **STOP and WAIT** - do not write any code until the user approves via plan_review
-
-## Plan Structure
-
-```markdown
-# {Title}
-
-## Objective
-{Clear statement of what we're building/fixing}
-
-## Steps
-
-### 1. {Step Name}
-- [ ] {Task description}
-- [ ] {Task description}
-Files: `path/to/file.ts`, `path/to/other.ts`
-
-### 2. {Step Name}
-- [ ] {Task description}
-Files: `path/to/file.ts`
-
-## Considerations
-- {Edge cases to handle}
-- {Error scenarios}
-
-## Success Criteria
-- {How we know we're done}
-```
-
-## Guidelines
-
-- **Break down complex tasks** into clear, sequential steps
-- **Include specific file paths** that will be created or modified
-- **Note dependencies** between steps
-- **Keep plans concise** but complete
-
-## Handling Review Responses
-
-After calling `plan_review`, handle the response:
-
-- **approve**: User approved - proceed with implementation
-- **iterate**: User wants changes - update the plan based on feedback, then call `plan_review` again
-- **reject**: User rejected - ask what they want instead
-
-## DO NOT
-
-- ❌ Start writing code before creating a plan
-- ❌ Skip the plan_review step
-- ❌ Assume approval - wait for explicit user response
-- ❌ Make changes outside the approved plan without updating it first
-
----
-
-**START NOW**:
-1. Research the codebase using the explore agent if needed
-2. Use `plan_read` to check for an existing plan
-3. Use `plan_create` to create your plan
-4. Use `plan_review` to get approval before any implementation