profclaw 2.0.0 → 2.3.0

package/dist/chat/execution/tools/code-tools.js

@@ -0,0 +1,353 @@
+/**
+ * Code Tools
+ *
+ * Development workflow tools: lint, typecheck, build, format, dependency audit.
+ * These complement the existing file-ops, git, and exec tools to enable
+ * full coding agent workflows.
+ */
+import { z } from 'zod';
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve, join } from 'node:path';
+// Helper: run a command and capture output
+async function runCommand(cmd, args, options = {}) {
+    const timeout = options.timeout || 60000;
+    const maxOutput = options.maxOutput || 200000;
+    return new Promise((resolve) => {
+        const proc = spawn(cmd, args, {
+            cwd: options.cwd || process.cwd(),
+            shell: false,
+            timeout,
+            env: { ...process.env, FORCE_COLOR: '0', NO_COLOR: '1' },
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout?.on('data', (chunk) => {
+            if (stdout.length < maxOutput)
+                stdout += chunk.toString();
+        });
+        proc.stderr?.on('data', (chunk) => {
+            if (stderr.length < maxOutput)
+                stderr += chunk.toString();
+        });
+        proc.on('close', (code) => {
+            resolve({ code: code ?? 1, stdout, stderr });
+        });
+        proc.on('error', (err) => {
+            resolve({ code: 1, stdout, stderr: err.message });
+        });
+    });
+}
+// Detect package manager
+function detectPackageManager(cwd) {
+    if (existsSync(join(cwd, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (existsSync(join(cwd, 'yarn.lock')))
+        return 'yarn';
+    if (existsSync(join(cwd, 'bun.lockb')))
+        return 'bun';
+    return 'npm';
+}
+function detectProject(cwd) {
+    const pkgPath = join(cwd, 'package.json');
+    const info = {
+        hasTypeScript: existsSync(join(cwd, 'tsconfig.json')),
+        hasEslint: existsSync(join(cwd, '.eslintrc.json')) || existsSync(join(cwd, '.eslintrc.js')) || existsSync(join(cwd, 'eslint.config.js')) || existsSync(join(cwd, 'eslint.config.mjs')),
+        hasPrettier: existsSync(join(cwd, '.prettierrc')) || existsSync(join(cwd, '.prettierrc.json')) || existsSync(join(cwd, 'prettier.config.js')),
+        hasBiome: existsSync(join(cwd, 'biome.json')),
+        scripts: {},
+        packageManager: detectPackageManager(cwd),
+    };
+    try {
+        if (existsSync(pkgPath)) {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            info.scripts = (pkg.scripts || {});
+            const deps = { ...(pkg.dependencies || {}), ...(pkg.devDependencies || {}) };
+            if (deps.typescript)
+                info.hasTypeScript = true;
+            if (deps.eslint)
+                info.hasEslint = true;
+            if (deps.prettier)
+                info.hasPrettier = true;
+            if (deps['@biomejs/biome'])
+                info.hasBiome = true;
+        }
+    }
+    catch { /* empty */ }
+    return info;
+}
+// === TypeCheck Tool ===
+const TypeCheckParams = z.object({
+    path: z.string().optional().describe('Specific file or directory to check. Defaults to project root.'),
+});
+export const typeCheckTool = {
+    name: 'typecheck',
+    description: 'Run TypeScript type checking (tsc --noEmit). Reports type errors without compiling. Use after editing TypeScript files.',
+    category: 'execution',
+    parameters: TypeCheckParams,
+    securityLevel: 'safe',
+    async execute(context, params) {
+        const cwd = params.path ? resolve(context.workdir, params.path) : context.workdir;
+        const project = detectProject(cwd);
+        if (!project.hasTypeScript) {
+            return { success: true, output: 'No tsconfig.json found - not a TypeScript project.' };
+        }
+        const result = await runCommand('npx', ['tsc', '--noEmit', '--pretty'], { cwd, timeout: 120000 });
+        const errors = result.stdout.split('\n').filter((l) => l.includes('error TS')).length;
+        if (result.code === 0) {
+            return { success: true, output: 'Type check passed - no errors.' };
+        }
+        return {
+            success: false,
+            output: `${errors} type error(s) found:\n\n${result.stdout.slice(0, 5000)}`,
+            error: { code: 'TYPE_ERRORS', message: `${errors} type error(s)` },
+        };
+    },
+};
+// === Lint Tool ===
+const LintParams = z.object({
+    path: z.string().optional().describe('File or directory to lint. Defaults to project root.'),
+    fix: z.boolean().optional().describe('Auto-fix fixable issues.'),
+});
+export const lintTool = {
+    name: 'lint',
+    description: 'Run linter (ESLint, Biome, or project lint script). Detects the linter automatically. Use --fix to auto-fix.',
+    category: 'execution',
+    parameters: LintParams,
+    securityLevel: 'safe',
+    async execute(context, params) {
+        const cwd = context.workdir;
+        const project = detectProject(cwd);
+        const target = params.path || '.';
+        const fixFlag = params.fix ? '--fix' : '';
+        // Try project lint script first
+        if (project.scripts.lint) {
+            const pm = project.packageManager;
+            const result = await runCommand(pm, ['run', 'lint', ...(fixFlag ? ['--', fixFlag] : [])], { cwd, timeout: 120000 });
+            if (result.code === 0) {
+                return { success: true, output: 'Lint passed - no issues.' };
+            }
+            return {
+                success: false,
+                output: `Lint issues:\n\n${(result.stdout + result.stderr).slice(0, 5000)}`,
+                error: { code: 'LINT_ERRORS', message: 'Lint found issues' },
+            };
+        }
+        // Try Biome
+        if (project.hasBiome) {
+            const args = params.fix ? ['check', '--write', target] : ['check', target];
+            const result = await runCommand('npx', ['@biomejs/biome', ...args], { cwd });
+            if (result.code === 0) {
+                return { success: true, output: 'Biome check passed.' };
+            }
+            return {
+                success: false,
+                output: `Biome issues:\n\n${(result.stdout + result.stderr).slice(0, 5000)}`,
+                error: { code: 'LINT_ERRORS', message: 'Biome found issues' },
+            };
+        }
+        // Try ESLint
+        if (project.hasEslint) {
+            const args = [target, '--format', 'stylish', ...(fixFlag ? [fixFlag] : [])];
+            const result = await runCommand('npx', ['eslint', ...args], { cwd });
+            if (result.code === 0) {
+                return { success: true, output: 'ESLint passed - no issues.' };
+            }
+            return {
+                success: false,
+                output: `ESLint issues:\n\n${(result.stdout + result.stderr).slice(0, 5000)}`,
+                error: { code: 'LINT_ERRORS', message: 'ESLint found issues' },
+            };
+        }
+        return { success: true, output: 'No linter configured (eslint, biome, or lint script).' };
+    },
+};
+// === Build Tool ===
+const BuildParams = z.object({
+    script: z.string().optional().describe('Build script name to run. Defaults to "build".'),
+});
+export const buildTool = {
+    name: 'build',
+    description: 'Run the project build command. Auto-detects package manager and build script.',
+    category: 'execution',
+    parameters: BuildParams,
+    securityLevel: 'moderate',
+    async execute(context, params) {
+        const cwd = context.workdir;
+        const project = detectProject(cwd);
+        const scriptName = params.script || 'build';
+        if (!project.scripts[scriptName]) {
+            return {
+                success: false,
+                output: `No "${scriptName}" script found in package.json. Available scripts: ${Object.keys(project.scripts).join(', ')}`,
+                error: { code: 'NO_BUILD_SCRIPT', message: `Script "${scriptName}" not found` },
+            };
+        }
+        const pm = project.packageManager;
+        const result = await runCommand(pm, ['run', scriptName], { cwd, timeout: 300000 });
+        if (result.code === 0) {
+            return { success: true, output: `Build succeeded.\n${result.stdout.slice(-500)}` };
+        }
+        return {
+            success: false,
+            output: `Build failed:\n\n${(result.stdout + result.stderr).slice(0, 5000)}`,
+            error: { code: 'BUILD_FAILED', message: 'Build failed' },
+        };
+    },
+};
+// === Format Tool ===
+const FormatParams = z.object({
+    path: z.string().optional().describe('File or directory to format. Defaults to current changes.'),
+});
+export const formatTool = {
+    name: 'format',
+    description: 'Auto-format code using Prettier, Biome, or project format script.',
+    category: 'execution',
+    parameters: FormatParams,
+    securityLevel: 'moderate',
+    async execute(context, params) {
+        const cwd = context.workdir;
+        const project = detectProject(cwd);
+        const target = params.path || '.';
+        if (project.scripts.format) {
+            const result = await runCommand(project.packageManager, ['run', 'format'], { cwd });
+            return {
+                success: result.code === 0,
+                output: result.code === 0 ? 'Formatted.' : `Format failed:\n${(result.stdout + result.stderr).slice(0, 2000)}`,
+            };
+        }
+        if (project.hasBiome) {
+            const result = await runCommand('npx', ['@biomejs/biome', 'format', '--write', target], { cwd });
+            return { success: result.code === 0, output: result.code === 0 ? 'Biome formatted.' : `Biome format failed:\n${result.stderr.slice(0, 2000)}` };
+        }
+        if (project.hasPrettier) {
+            const result = await runCommand('npx', ['prettier', '--write', target], { cwd });
+            return { success: result.code === 0, output: result.code === 0 ? 'Prettier formatted.' : `Prettier failed:\n${result.stderr.slice(0, 2000)}` };
+        }
+        return { success: true, output: 'No formatter configured (prettier, biome, or format script).' };
+    },
+};
+// === Project Info Tool ===
+const ProjectInfoParams = z.object({});
+export const projectInfoTool = {
+    name: 'project_info',
+    description: 'Detect project type, dependencies, scripts, and tooling. Use to understand the codebase before making changes.',
+    category: 'execution',
+    parameters: ProjectInfoParams,
+    securityLevel: 'safe',
+    async execute(context) {
+        const cwd = context.workdir;
+        const project = detectProject(cwd);
+        const lines = [];
+        lines.push(`Package manager: ${project.packageManager}`);
+        lines.push(`TypeScript: ${project.hasTypeScript ? 'yes' : 'no'}`);
+        lines.push(`Linter: ${project.hasBiome ? 'Biome' : project.hasEslint ? 'ESLint' : 'none'}`);
+        lines.push(`Formatter: ${project.hasBiome ? 'Biome' : project.hasPrettier ? 'Prettier' : 'none'}`);
+        if (Object.keys(project.scripts).length > 0) {
+            lines.push('');
+            lines.push('Scripts:');
+            for (const [name, cmd] of Object.entries(project.scripts)) {
+                lines.push(`  ${name}: ${cmd.slice(0, 80)}`);
+            }
+        }
+        // Check for common config files
+        const configs = [];
+        const configFiles = [
+            'tsconfig.json', 'package.json', '.eslintrc.json', 'eslint.config.js',
+            'biome.json', '.prettierrc', 'vitest.config.ts', 'jest.config.ts',
+            'Dockerfile', 'docker-compose.yml', '.github/workflows',
+            'CLAUDE.md', 'AGENTS.md', 'README.md',
+        ];
+        for (const f of configFiles) {
+            if (existsSync(join(cwd, f)))
+                configs.push(f);
+        }
+        if (configs.length > 0) {
+            lines.push('');
+            lines.push(`Config files: ${configs.join(', ')}`);
+        }
+        return {
+            success: true,
+            output: lines.join('\n'),
+            data: project,
+        };
+    },
+};
+// === Create PR Tool ===
+const CreatePrParams = z.object({
+    title: z.string().describe('PR title'),
+    body: z.string().optional().describe('PR description/body'),
+    base: z.string().optional().describe('Base branch (default: main)'),
+    draft: z.boolean().optional().describe('Create as draft PR'),
+});
+export const createPrTool = {
+    name: 'create_pr',
+    description: 'Create a GitHub Pull Request from the current branch. Requires gh CLI authenticated.',
+    category: 'execution',
+    parameters: CreatePrParams,
+    securityLevel: 'moderate',
+    requiresApproval: true,
+    async execute(context, params) {
+        const cwd = context.workdir;
+        // Check gh is available
+        const ghCheck = await runCommand('gh', ['auth', 'status'], { cwd, timeout: 5000 });
+        if (ghCheck.code !== 0) {
+            return {
+                success: false,
+                output: 'GitHub CLI (gh) is not installed or not authenticated. Run: gh auth login',
+                error: { code: 'GH_NOT_CONFIGURED', message: 'gh CLI not available' },
+            };
+        }
+        // Get current branch
+        const branchResult = await runCommand('git', ['branch', '--show-current'], { cwd });
+        const branch = branchResult.stdout.trim();
+        if (!branch || branch === 'main' || branch === 'master') {
+            return {
+                success: false,
+                output: `Cannot create PR from ${branch || 'detached HEAD'}. Create a feature branch first.`,
+                error: { code: 'WRONG_BRANCH', message: 'Cannot PR from main/master' },
+            };
+        }
+        // Push branch
+        const pushResult = await runCommand('git', ['push', '-u', 'origin', branch], { cwd, timeout: 30000 });
+        if (pushResult.code !== 0 && !pushResult.stderr.includes('Everything up-to-date')) {
+            return {
+                success: false,
+                output: `Failed to push branch: ${pushResult.stderr.slice(0, 500)}`,
+                error: { code: 'PUSH_FAILED', message: 'git push failed' },
+            };
+        }
+        // Create PR
+        const prArgs = ['pr', 'create', '--title', params.title];
+        if (params.body)
+            prArgs.push('--body', params.body);
+        if (params.base)
+            prArgs.push('--base', params.base);
+        if (params.draft)
+            prArgs.push('--draft');
+        const prResult = await runCommand('gh', prArgs, { cwd, timeout: 15000 });
+        if (prResult.code === 0) {
+            const prUrl = prResult.stdout.trim();
+            return {
+                success: true,
+                output: `PR created: ${prUrl}`,
+                data: { url: prUrl, branch, title: params.title },
+            };
+        }
+        return {
+            success: false,
+            output: `Failed to create PR: ${(prResult.stdout + prResult.stderr).slice(0, 1000)}`,
+            error: { code: 'PR_CREATE_FAILED', message: 'gh pr create failed' },
+        };
+    },
+};
+// Export all
+export const codeTools = [
+    typeCheckTool,
+    lintTool,
+    buildTool,
+    formatTool,
+    projectInfoTool,
+    createPrTool,
+];
+//# sourceMappingURL=code-tools.js.map

package/dist/chat/execution/tools/complete-task.d.ts

@@ -27,7 +27,7 @@ declare const CompleteTaskParamsSchema: z.ZodObject<{
     nextSteps: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     confidence: z.ZodDefault<z.ZodEnum<["high", "medium", "low"]>>;
 }, "strip", z.ZodTypeAny, {
-    confidence: "medium" | "high" | "low";
+    confidence: "medium" | "low" | "high";
     summary: string;
     artifacts?: {
         type: "commit" | "file" | "comment" | "other" | "ticket" | "pr" | "project";
@@ -38,7 +38,7 @@ declare const CompleteTaskParamsSchema: z.ZodObject<{
     nextSteps?: string[] | undefined;
 }, {
     summary: string;
-    confidence?: "medium" | "high" | "low" | undefined;
+    confidence?: "medium" | "low" | "high" | undefined;
     artifacts?: {
         type: "commit" | "file" | "comment" | "other" | "ticket" | "pr" | "project";
         id: string;

package/dist/chat/execution/tools/cron-tool.d.ts

@@ -14,7 +14,7 @@ declare const CronCreateParamsSchema: z.ZodObject<{
     description: z.ZodOptional<z.ZodString>;
     cron: z.ZodOptional<z.ZodString>;
     interval: z.ZodOptional<z.ZodNumber>;
-    type: z.ZodDefault<z.ZodEnum<["http", "tool", "script"]>>;
+    type: z.ZodDefault<z.ZodEnum<["http", "tool", "script", "agent_session"]>>;
     url: z.ZodOptional<z.ZodString>;
     method: z.ZodOptional<z.ZodEnum<["GET", "POST", "PUT", "DELETE"]>>;
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -24,42 +24,54 @@ declare const CronCreateParamsSchema: z.ZodObject<{
     command: z.ZodOptional<z.ZodString>;
     args: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
     workdir: z.ZodOptional<z.ZodString>;
+    prompt: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    effort: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
+    deliverTo: z.ZodOptional<z.ZodString>;
     maxRuns: z.ZodOptional<z.ZodNumber>;
     maxFailures: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
     name: string;
-    type: "tool" | "script" | "http";
+    type: "tool" | "script" | "http" | "agent_session";
     description?: string | undefined;
+    prompt?: string | undefined;
     url?: string | undefined;
+    model?: string | undefined;
     maxRuns?: number | undefined;
     maxFailures?: number | undefined;
     args?: string[] | undefined;
     method?: "GET" | "POST" | "PUT" | "DELETE" | undefined;
     cron?: string | undefined;
     body?: unknown;
-    command?: string | undefined;
-    headers?: Record<string, string> | undefined;
     tool?: string | undefined;
+    command?: string | undefined;
+    effort?: "medium" | "low" | "high" | undefined;
     workdir?: string | undefined;
+    headers?: Record<string, string> | undefined;
     interval?: number | undefined;
     toolParams?: Record<string, unknown> | undefined;
+    deliverTo?: string | undefined;
 }, {
     name: string;
     description?: string | undefined;
-    type?: "tool" | "script" | "http" | undefined;
+    prompt?: string | undefined;
+    type?: "tool" | "script" | "http" | "agent_session" | undefined;
     url?: string | undefined;
+    model?: string | undefined;
     maxRuns?: number | undefined;
     maxFailures?: number | undefined;
     args?: string[] | undefined;
     method?: "GET" | "POST" | "PUT" | "DELETE" | undefined;
     cron?: string | undefined;
     body?: unknown;
-    command?: string | undefined;
-    headers?: Record<string, string> | undefined;
     tool?: string | undefined;
+    command?: string | undefined;
+    effort?: "medium" | "low" | "high" | undefined;
     workdir?: string | undefined;
+    headers?: Record<string, string> | undefined;
     interval?: number | undefined;
     toolParams?: Record<string, unknown> | undefined;
+    deliverTo?: string | undefined;
 }>;
 export type CronCreateParams = z.infer<typeof CronCreateParamsSchema>;
 export interface CronCreateResult {
@@ -167,21 +179,25 @@ export interface CronHistoryResult {
 export declare const cronHistoryTool: ToolDefinition<CronHistoryParams, CronHistoryResult>;
 export declare const cronTools: (ToolDefinition<{
     name: string;
-    type: "tool" | "script" | "http";
+    type: "tool" | "script" | "http" | "agent_session";
     description?: string | undefined;
+    prompt?: string | undefined;
     url?: string | undefined;
+    model?: string | undefined;
     maxRuns?: number | undefined;
     maxFailures?: number | undefined;
     args?: string[] | undefined;
     method?: "GET" | "POST" | "PUT" | "DELETE" | undefined;
     cron?: string | undefined;
     body?: unknown;
-    command?: string | undefined;
-    headers?: Record<string, string> | undefined;
     tool?: string | undefined;
+    command?: string | undefined;
+    effort?: "medium" | "low" | "high" | undefined;
     workdir?: string | undefined;
+    headers?: Record<string, string> | undefined;
     interval?: number | undefined;
     toolParams?: Record<string, unknown> | undefined;
+    deliverTo?: string | undefined;
 }, CronCreateResult> | ToolDefinition<{
     limit: number;
     type?: "message" | "tool" | "script" | "http" | undefined;

package/dist/chat/execution/tools/cron-tool.js

@@ -18,8 +18,8 @@ const CronCreateParamsSchema = z.object({
         .describe('Cron expression (e.g., "*/5 * * * *" for every 5 minutes, "0 9 * * 1-5" for 9am weekdays)'),
     interval: z.number().min(1000).optional()
         .describe('Alternative: interval in milliseconds (minimum 1000ms = 1 second)'),
-    type: z.enum(['http', 'tool', 'script']).default('http')
-        .describe('Job type: http (webhook), tool (execute a tool), script (run command)'),
+    type: z.enum(['http', 'tool', 'script', 'agent_session']).default('http')
+        .describe('Job type: http (webhook), tool (execute a tool), script (run command), agent_session (run AI agent with prompt)'),
     url: z.string().url().optional()
         .describe('For HTTP jobs: URL to call'),
     method: z.enum(['GET', 'POST', 'PUT', 'DELETE']).optional()
@@ -37,7 +37,17 @@ const CronCreateParamsSchema = z.object({
     args: z.array(z.string()).optional()
         .describe('For script jobs: Command arguments'),
     workdir: z.string().optional()
-        .describe('For script jobs: Working directory'),
+        .describe('For script/agent_session jobs: Working directory'),
+    // Agent session params
+    prompt: z.string().optional()
+        .describe('For agent_session jobs: The prompt/instruction for the AI agent to execute'),
+    model: z.string().optional()
+        .describe('For agent_session jobs: AI model to use (e.g., sonnet, opus)'),
+    effort: z.enum(['low', 'medium', 'high']).optional()
+        .describe('For agent_session jobs: Thinking effort level'),
+    // Delivery
+    deliverTo: z.string().optional()
+        .describe('Deliver results to this target (e.g., "telegram:<chat_id>" or "slack:#channel")'),
     maxRuns: z.number().min(1).optional()
         .describe('Stop job after this many runs'),
     maxFailures: z.number().min(1).optional()
@@ -149,6 +159,40 @@ Or use \`interval\` for fixed millisecond intervals.`,
                         workdir: params.workdir || context.workdir,
                     };
                     break;
+                case 'agent_session':
+                    if (!params.prompt) {
+                        return {
+                            success: false,
+                            error: {
+                                code: 'MISSING_PROMPT',
+                                message: 'Agent session jobs require a prompt parameter',
+                            },
+                        };
+                    }
+                    payload = {
+                        prompt: params.prompt,
+                        model: params.model,
+                        effort: params.effort || 'medium',
+                        workdir: params.workdir || context.workdir,
+                    };
+                    break;
+            }
+            // Parse delivery target (format: "telegram:chatId" or "slack:#channel")
+            let delivery;
+            if (params.deliverTo) {
+                const [channelType, ...targetParts] = params.deliverTo.split(':');
+                const target = targetParts.join(':');
+                const validTypes = ['slack', 'webhook', 'email', 'telegram', 'discord'];
+                if (channelType && target && validTypes.includes(channelType)) {
+                    delivery = {
+                        channels: [{
+                                type: channelType,
+                                target,
+                                onSuccess: true,
+                                onFailure: true,
+                            }],
+                    };
+                }
             }
             const job = await createScheduledJob({
                 name: params.name,
@@ -157,6 +201,7 @@ Or use \`interval\` for fixed millisecond intervals.`,
                 intervalMs: params.interval,
                 jobType: params.type,
                 payload,
+                delivery,
                 createdBy: 'ai',
                 maxRuns: params.maxRuns,
                 maxFailures: params.maxFailures,

package/dist/chat/execution/tools/decompose-task.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Decompose Task Tool
+ *
+ * Splits a large task into smaller, independently-executable subtasks and
+ * persists the plan to .profclaw/plans/ so it can be resumed across multiple
+ * profClaw sessions.
+ */
+import { z } from 'zod';
+import type { ToolDefinition } from '../types.js';
+declare const DecomposeTaskParamsSchema: z.ZodObject<{
+    originalTask: z.ZodString;
+    subtasks: z.ZodArray<z.ZodObject<{
+        description: z.ZodString;
+        estimatedSteps: z.ZodNumber;
+        files: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        dependencies: z.ZodOptional<z.ZodArray<z.ZodNumber, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        description: string;
+        estimatedSteps: number;
+        files?: string[] | undefined;
+        dependencies?: number[] | undefined;
+    }, {
+        description: string;
+        estimatedSteps: number;
+        files?: string[] | undefined;
+        dependencies?: number[] | undefined;
+    }>, "many">;
+    currentProgress: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    subtasks: {
+        description: string;
+        estimatedSteps: number;
+        files?: string[] | undefined;
+        dependencies?: number[] | undefined;
+    }[];
+    originalTask: string;
+    currentProgress?: string | undefined;
+}, {
+    subtasks: {
+        description: string;
+        estimatedSteps: number;
+        files?: string[] | undefined;
+        dependencies?: number[] | undefined;
+    }[];
+    originalTask: string;
+    currentProgress?: string | undefined;
+}>;
+export type DecomposeTaskParams = z.infer<typeof DecomposeTaskParamsSchema>;
+interface DecomposeTaskResult {
+    planId: string;
+    planFile: string;
+    subtaskCount: number;
+    resumeCommand: string;
+    summary: string;
+}
+export declare const decomposeTaskTool: ToolDefinition<DecomposeTaskParams, DecomposeTaskResult>;
+export default decomposeTaskTool;
+//# sourceMappingURL=decompose-task.d.ts.map