task-o-matic 0.0.12 → 0.0.13

package/dist/lib/git-utils.js

@@ -0,0 +1,160 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.captureGitState = captureGitState;
+exports.extractCommitInfo = extractCommitInfo;
+exports.autoCommit = autoCommit;
+exports.commitFile = commitFile;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const chalk_1 = __importDefault(require("chalk"));
+const ai_service_factory_1 = require("../utils/ai-service-factory");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Capture git state (HEAD commit and uncommitted changes)
+ */
+async function captureGitState(execFn = execAsync) {
+    try {
+        const { stdout: headStdout } = await execFn("git rev-parse HEAD");
+        const { stdout: statusStdout } = await execFn("git status --porcelain");
+        return {
+            beforeHead: headStdout.trim(),
+            afterHead: headStdout.trim(),
+            hasUncommittedChanges: statusStdout.trim().length > 0,
+        };
+    }
+    catch (e) {
+        // Git might not be initialized or no commits yet
+        return {};
+    }
+}
+/**
+ * Extract commit message and file list from git state
+ * This function analyzes the actual git state to generate appropriate commit info
+ */
+async function extractCommitInfo(taskId, taskTitle, executionMessage, gitState, execFn = execAsync, aiOps = (0, ai_service_factory_1.getAIOperations)()) {
+    try {
+        // Case 1: Executor created a commit
+        if (gitState.beforeHead !== gitState.afterHead) {
+            console.log(chalk_1.default.blue("📝 Executor created a commit, extracting info..."));
+            const { stdout } = await execFn(`git show --stat --format="%s%n%b" ${gitState.afterHead}`);
+            const lines = stdout.trim().split("\n");
+            const message = lines[0].trim();
+            // Parse files from stat output (e.g. " src/file.ts | 10 +")
+            const files = lines
+                .slice(1)
+                .filter((line) => line.includes("|"))
+                .map((line) => line.split("|")[0].trim());
+            return {
+                message,
+                files,
+            };
+        }
+        // Case 2: Executor left uncommitted changes
+        if (gitState.hasUncommittedChanges) {
+            console.log(chalk_1.default.blue("📝 Uncommitted changes detected, generating commit message..."));
+            // Get the diff to send to AI
+            const { stdout: diff } = await execFn("git diff HEAD");
+            // Get list of changed files
+            const { stdout: status } = await execFn("git status --porcelain");
+            const files = status
+                .split("\n")
+                .filter((line) => line.length > 0)
+                .map((line) => line.substring(3).trim())
+                .filter((file) => file.length > 0);
+            // Use AI to generate commit message based on the diff
+            const prompt = `Based on the following git diff, generate a concise git commit message.
+
+Task: ${taskTitle}
+
+Git Diff:
+${diff.substring(0, 10000)} // Limit diff size
+
+Please respond in JSON format:
+{
+  "message": "concise commit message following conventional commits format"
+}
+
+The commit message should:
+- Follow conventional commits format (feat:, fix:, refactor:, etc.)
+- Be concise and descriptive
+- Focus on what changed
+`;
+            const response = await aiOps.streamText(prompt, undefined, "You are a helpful assistant that generates git commit messages.");
+            // Try to parse JSON from response
+            const jsonMatch = response.match(/\{[\s\S]*\}/);
+            let message = `feat: complete task ${taskTitle}`;
+            if (jsonMatch) {
+                try {
+                    const parsed = JSON.parse(jsonMatch[0]);
+                    if (parsed.message) {
+                        message = parsed.message;
+                    }
+                }
+                catch (e) {
+                    // Ignore parse error
+                }
+            }
+            return {
+                message,
+                files,
+            };
+        }
+        // Case 3: No changes detected
+        return {
+            message: `feat: complete task ${taskTitle}`,
+            files: [],
+        };
+    }
+    catch (error) {
+        console.warn(chalk_1.default.yellow(`⚠️  Failed to extract commit info: ${error instanceof Error ? error.message : "Unknown error"}`));
+        // Fallback commit info
+        return {
+            message: `feat: complete task ${taskTitle}`,
+            files: [],
+        };
+    }
+}
+/**
+ * Auto-commit changes using the provided commit info
+ */
+async function autoCommit(commitInfo, execFn = execAsync) {
+    try {
+        const { message, files } = commitInfo;
+        if (files.length > 0) {
+            // Stage specific files
+            const gitAdd = `git add ${files.join(" ")}`;
+            console.log(chalk_1.default.blue(`📦 Staging files: ${gitAdd}`));
+            await execFn(gitAdd);
+        }
+        else {
+            // Stage all changes
+            console.log(chalk_1.default.blue("📦 Staging all changes"));
+            await execFn("git add .");
+        }
+        // Commit
+        const gitCommit = `git commit -m "${message}"`;
+        console.log(chalk_1.default.blue(`💾 Committing: ${message}`));
+        await execFn(gitCommit);
+        console.log(chalk_1.default.green("✅ Changes committed successfully\n"));
+    }
+    catch (error) {
+        console.warn(chalk_1.default.yellow(`⚠️  Auto-commit failed: ${error instanceof Error ? error.message : "Unknown error"}\n`));
+    }
+}
+/**
+ * Commit a specific file with a custom message
+ */
+async function commitFile(filePath, message, execFn = execAsync) {
+    try {
+        console.log(chalk_1.default.blue(`📦 Staging file: ${filePath}`));
+        await execFn(`git add ${filePath}`);
+        await execFn(`git commit -m "${message}"`);
+        console.log(chalk_1.default.green("✅ File committed successfully"));
+    }
+    catch (e) {
+        console.warn(chalk_1.default.yellow(`⚠️  Failed to commit file: ${e instanceof Error ? e.message : "Unknown error"}`));
+    }
+}

package/dist/lib/task-execution-core.d.ts

@@ -0,0 +1,7 @@
+import { TaskExecutionConfig, TaskExecutionResult } from "../types";
+/**
+ * Execute a single task with all features (retry, planning, review, etc.)
+ * This is the core unified execution logic used by both execute and execute-loop commands
+ */
+export declare function executeTaskCore(taskId: string, config: TaskExecutionConfig): Promise<TaskExecutionResult>;
+//# sourceMappingURL=task-execution-core.d.ts.map

package/dist/lib/task-execution-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-execution-core.d.ts","sourceRoot":"","sources":["../../src/lib/task-execution-core.ts"],"names":[],"mappings":"AACA,OAAO,EACL,mBAAmB,EACnB,mBAAmB,EAKpB,MAAM,UAAU,CAAC;AAWlB;;;GAGG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,mBAAmB,CAAC,CA+D9B"}

package/dist/lib/task-execution-core.js

@@ -0,0 +1,360 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeTaskCore = executeTaskCore;
+const tasks_1 = require("../services/tasks");
+const executor_factory_1 = require("./executors/executor-factory");
+const validation_1 = require("./validation");
+const ai_service_factory_1 = require("../utils/ai-service-factory");
+const hooks_1 = require("./hooks");
+const prompt_builder_1 = require("./prompt-builder");
+const task_planning_1 = require("./task-planning");
+const task_review_1 = require("./task-review");
+const git_utils_1 = require("./git-utils");
+const chalk_1 = __importDefault(require("chalk"));
+/**
+ * Execute a single task with all features (retry, planning, review, etc.)
+ * This is the core unified execution logic used by both execute and execute-loop commands
+ */
+async function executeTaskCore(taskId, config) {
+    const { tool, executorConfig, customMessage, verificationCommands = [], enableRetry = false, maxRetries = 3, tryModels, enablePlanPhase = false, planModel, reviewPlan = false, enableReviewPhase = false, reviewModel, autoCommit: enableAutoCommit = false, executeSubtasks = true, dry = false, } = config;
+    // Load task
+    const task = await tasks_1.taskService.getTask(taskId);
+    if (!task) {
+        throw new Error(`Task with ID ${taskId} not found`);
+    }
+    // Check if task has subtasks and should execute them recursively
+    if (executeSubtasks && !customMessage) {
+        const subtasks = await tasks_1.taskService.getSubtasks(taskId);
+        if (subtasks.length > 0) {
+            return await executeTaskWithSubtasks(task, subtasks, config);
+        }
+    }
+    // ----------------------------------------------------------------------
+    // PLANNING PHASE
+    // ----------------------------------------------------------------------
+    let planContent;
+    if (enablePlanPhase) {
+        const planningResult = await (0, task_planning_1.executePlanningPhase)(task, tool, {
+            planModel,
+            reviewPlan,
+            autoCommit: enableAutoCommit,
+            dry,
+        });
+        if (planningResult.success && planningResult.planContent) {
+            planContent = planningResult.planContent;
+        }
+    }
+    // ----------------------------------------------------------------------
+    // EXECUTION PHASE (with optional retry logic)
+    // ----------------------------------------------------------------------
+    const attempts = [];
+    if (enableRetry) {
+        // Execute with retry logic
+        return await executeTaskWithRetry(task, config, attempts, planContent);
+    }
+    else {
+        // Execute once without retry (simpler path for execute command)
+        return await executeSingleAttempt(task, config, attempts, planContent, 1, maxRetries);
+    }
+}
+/**
+ * Execute task with subtasks recursively
+ */
+async function executeTaskWithSubtasks(task, subtasks, config) {
+    const { dry } = config;
+    console.log(chalk_1.default.blue(`📋 Task has ${subtasks.length} subtasks, executing recursively...`));
+    const subtaskResults = [];
+    let allSuccess = true;
+    // Execute subtasks one by one
+    for (let i = 0; i < subtasks.length; i++) {
+        const subtask = subtasks[i];
+        console.log(chalk_1.default.cyan(`\n[${i + 1}/${subtasks.length}] Executing subtask: ${subtask.title} (${subtask.id})`));
+        try {
+            const result = await executeTaskCore(subtask.id, config);
+            subtaskResults.push(result);
+            if (!result.success) {
+                allSuccess = false;
+                console.error(chalk_1.default.red(`❌ Failed to execute subtask ${subtask.id}: ${subtask.title}`));
+                break; // Stop on first failure
+            }
+        }
+        catch (error) {
+            allSuccess = false;
+            console.error(chalk_1.default.red(`❌ Failed to execute subtask ${subtask.id}: ${error instanceof Error ? error.message : "Unknown error"}`));
+            break;
+        }
+    }
+    // After all subtasks are done (or on failure), update the main task status
+    if (!dry) {
+        if (allSuccess) {
+            await tasks_1.taskService.setTaskStatus(task.id, "completed");
+            console.log(chalk_1.default.green(`✅ Main task ${task.title} completed after all subtasks`));
+        }
+        else {
+            await tasks_1.taskService.setTaskStatus(task.id, "todo");
+            console.log(chalk_1.default.red(`❌ Main task ${task.title} failed due to subtask failure, status reset to todo`));
+        }
+    }
+    return {
+        success: allSuccess,
+        attempts: [], // Parent task doesn't have its own attempts
+        subtaskResults,
+    };
+}
+/**
+ * Execute task with retry logic
+ */
+async function executeTaskWithRetry(task, config, attempts, planContent) {
+    const { tool, maxRetries = 3, tryModels, verificationCommands = [], enableReviewPhase = false, reviewModel, autoCommit: enableAutoCommit = false, dry = false, } = config;
+    let currentAttempt = 1;
+    let lastError;
+    while (currentAttempt <= maxRetries) {
+        // Determine which executor and model to use for this attempt
+        let currentExecutor = tool;
+        let currentModel;
+        if (tryModels && tryModels.length > 0) {
+            const modelConfigIndex = Math.min(currentAttempt - 1, tryModels.length - 1);
+            const modelConfig = tryModels[modelConfigIndex];
+            if (modelConfig.executor) {
+                currentExecutor = modelConfig.executor;
+            }
+            if (modelConfig.model) {
+                currentModel = modelConfig.model;
+            }
+        }
+        console.log(chalk_1.default.blue(`\n🎯 Attempt ${currentAttempt}/${maxRetries} for task: ${task.title} (${task.id})`));
+        if (currentModel) {
+            console.log(chalk_1.default.cyan(`   Using executor: ${currentExecutor} with model: ${currentModel}`));
+        }
+        else {
+            console.log(chalk_1.default.cyan(`   Using executor: ${currentExecutor}`));
+        }
+        // Build retry context if this is a retry attempt
+        let retryContext = "";
+        if (currentAttempt > 1 && lastError) {
+            const retryParts = [];
+            retryParts.push(`# RETRY ATTEMPT ${currentAttempt}/${maxRetries}\n\n`);
+            if (currentModel) {
+                retryParts.push(`**Note**: You are ${currentExecutor} using the ${currentModel} model. This is a more capable model than the previous attempt.\n\n`);
+            }
+            retryParts.push(`## Previous Attempt Failed With Error:\n\n${lastError}\n\n`);
+            retryParts.push(`Please analyze the error carefully and fix it. The error might be due to:\n`);
+            retryParts.push(`- Syntax errors\n`);
+            retryParts.push(`- Logic errors\n`);
+            retryParts.push(`- Missing dependencies or imports\n`);
+            retryParts.push(`- Incorrect configuration\n`);
+            retryParts.push(`- Build or test failures\n\n`);
+            retryParts.push(`Please fix the error above and complete the task successfully.\n\n`);
+            retryContext = retryParts.join("");
+        }
+        // Update executor config for this attempt
+        const attemptConfig = {
+            ...config,
+            tool: currentExecutor,
+            executorConfig: {
+                ...config.executorConfig,
+                model: currentModel,
+                continueLastSession: currentAttempt > 1, // Resume session on retries
+            },
+        };
+        try {
+            const result = await executeSingleAttempt(task, attemptConfig, attempts, planContent, currentAttempt, maxRetries, retryContext);
+            // Check if all verifications passed
+            const allVerificationsPassed = result.attempts[result.attempts.length - 1]
+                ?.verificationResults?.every((r) => r.success) ?? true;
+            if (!allVerificationsPassed) {
+                const failedVerification = result.attempts[result.attempts.length - 1]
+                    ?.verificationResults?.find((r) => !r.success);
+                lastError = `Verification command "${failedVerification?.command}" failed:\n${failedVerification?.error}`;
+                currentAttempt++;
+                continue;
+            }
+            // ----------------------------------------------------------------------
+            // AI REVIEW PHASE
+            // ----------------------------------------------------------------------
+            if (enableReviewPhase && !dry) {
+                const reviewResult = await (0, task_review_1.executeReviewPhase)(task, {
+                    reviewModel,
+                    planContent,
+                    dry,
+                });
+                if (!reviewResult.approved) {
+                    lastError = `AI Review Failed:\n${reviewResult.feedback}`;
+                    console.log(chalk_1.default.red(`❌ AI Review Rejected Changes: ${reviewResult.feedback}`));
+                    currentAttempt++;
+                    continue;
+                }
+                else {
+                    console.log(chalk_1.default.green(`✅ AI Review Approved: ${reviewResult.feedback}`));
+                    result.reviewFeedback = reviewResult.feedback;
+                }
+            }
+            // Success! Return the result
+            return result;
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error.message : String(error);
+            console.log(chalk_1.default.red(`❌ Task execution failed on attempt ${currentAttempt}: ${lastError}`));
+            if (!dry && currentAttempt < maxRetries) {
+                await tasks_1.taskService.setTaskStatus(task.id, "todo");
+                console.log(chalk_1.default.yellow("⏸  Task status reset to todo for retry"));
+            }
+            currentAttempt++;
+        }
+    }
+    // All retries exhausted
+    if (!dry) {
+        await tasks_1.taskService.setTaskStatus(task.id, "todo");
+        console.log(chalk_1.default.red("❌ All retry attempts exhausted, task status reset to todo"));
+    }
+    return {
+        success: false,
+        attempts,
+    };
+}
+/**
+ * Execute a single attempt of the task
+ */
+async function executeSingleAttempt(task, config, attempts, planContent, attemptNumber, maxRetries, retryContext) {
+    const { tool, executorConfig, customMessage, verificationCommands = [], autoCommit: enableAutoCommit = false, dry = false, } = config;
+    const attemptStartTime = Date.now();
+    console.log(chalk_1.default.blue(`🎯 ${dry ? "DRY RUN" : "Executing"} task: ${task.title} (${task.id})`));
+    // Capture git state before execution
+    const gitStateBefore = await (0, git_utils_1.captureGitState)();
+    // Build execution message
+    let executionMessage;
+    if (customMessage) {
+        // Use custom message override
+        executionMessage = customMessage;
+        console.log(chalk_1.default.cyan("📝 Using custom execution message"));
+    }
+    else {
+        // Build comprehensive execution message with full context
+        const contextBuilder = (0, ai_service_factory_1.getContextBuilder)();
+        const taskContext = await contextBuilder.buildContext(task.id);
+        // Get task plan if available
+        const storedPlanData = await tasks_1.taskService.getTaskPlan(task.id);
+        let finalPlan;
+        if (planContent) {
+            finalPlan = `${planContent}\n\nPlease follow this plan to implement the task.`;
+        }
+        else if (storedPlanData) {
+            finalPlan = storedPlanData.plan;
+        }
+        // Build execution prompt using PromptBuilder
+        const promptResult = prompt_builder_1.PromptBuilder.buildExecutionPrompt({
+            taskTitle: task.title,
+            taskDescription: task.description,
+            taskPlan: finalPlan,
+            stack: taskContext.stack,
+            documentation: taskContext.documentation,
+            retryContext,
+        });
+        if (!promptResult.success) {
+            throw new Error(`Failed to build execution prompt: ${promptResult.error}`);
+        }
+        executionMessage = promptResult.prompt;
+    }
+    // Update task status to in-progress
+    if (!dry) {
+        await tasks_1.taskService.setTaskStatus(task.id, "in-progress");
+        console.log(chalk_1.default.yellow("⏳ Task status updated to in-progress"));
+    }
+    // Emit execution:start event
+    await hooks_1.hooks.emit("execution:start", { taskId: task.id, tool });
+    try {
+        // Create executor and run
+        const executor = executor_factory_1.ExecutorFactory.create(tool, executorConfig);
+        // Log session resumption if applicable
+        if (executorConfig?.continueLastSession && attemptNumber > 1) {
+            console.log(chalk_1.default.cyan("🔄 Resuming previous session to provide error feedback to AI"));
+        }
+        await executor.execute(executionMessage, dry, executorConfig);
+        // Run verification commands
+        const verificationResults = await (0, validation_1.runValidations)(verificationCommands, dry);
+        const allVerificationsPassed = verificationResults.every((r) => r.success);
+        if (!allVerificationsPassed) {
+            const failedVerification = verificationResults.find((r) => !r.success);
+            const error = `Verification command "${failedVerification?.command}" failed:\n${failedVerification?.error}`;
+            attempts.push({
+                attemptNumber,
+                success: false,
+                error,
+                executor: tool,
+                model: executorConfig?.model,
+                verificationResults,
+                timestamp: Date.now() - attemptStartTime,
+            });
+            console.log(chalk_1.default.red(`❌ Task execution failed verification on attempt ${attemptNumber}`));
+            throw new Error(error);
+        }
+        // Extract commit info if enabled
+        let commitInfo;
+        if (enableAutoCommit && !dry) {
+            console.log(chalk_1.default.blue("📝 Extracting commit information..."));
+            const gitStateAfter = await (0, git_utils_1.captureGitState)();
+            const gitState = {
+                beforeHead: gitStateBefore.beforeHead || "",
+                afterHead: gitStateAfter.afterHead || "",
+                hasUncommittedChanges: gitStateAfter.hasUncommittedChanges || false,
+            };
+            commitInfo = await (0, git_utils_1.extractCommitInfo)(task.id, task.title, executionMessage, gitState);
+            console.log(chalk_1.default.green(`✅ Commit message: ${commitInfo.message}`));
+            if (commitInfo.files.length > 0) {
+                console.log(chalk_1.default.green(`📁 Changed files: ${commitInfo.files.join(", ")}`));
+            }
+            // Auto-commit the changes
+            await (0, git_utils_1.autoCommit)(commitInfo);
+        }
+        // Update task status to completed
+        if (!dry) {
+            await tasks_1.taskService.setTaskStatus(task.id, "completed");
+            console.log(chalk_1.default.green("✅ Task execution completed successfully"));
+        }
+        // Record successful attempt
+        attempts.push({
+            attemptNumber,
+            success: true,
+            executor: tool,
+            model: executorConfig?.model,
+            verificationResults,
+            commitInfo,
+            timestamp: Date.now() - attemptStartTime,
+        });
+        // Emit execution:end event
+        await hooks_1.hooks.emit("execution:end", { taskId: task.id, success: true });
+        return {
+            success: true,
+            attempts,
+            commitInfo,
+            planContent,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // Record failed attempt if not already recorded
+        if (attempts.length === 0 || attempts[attempts.length - 1].attemptNumber !== attemptNumber) {
+            attempts.push({
+                attemptNumber,
+                success: false,
+                error: errorMessage,
+                executor: tool,
+                model: executorConfig?.model,
+                timestamp: Date.now() - attemptStartTime,
+            });
+        }
+        // Emit execution:error event
+        await hooks_1.hooks.emit("execution:error", {
+            taskId: task.id,
+            error: error instanceof Error ? error : new Error(String(error)),
+        });
+        if (!dry) {
+            await tasks_1.taskService.setTaskStatus(task.id, "todo");
+            console.log(chalk_1.default.red("❌ Task execution failed, status reset to todo"));
+        }
+        throw error;
+    }
+}

package/dist/lib/task-execution.d.ts

@@ -1,3 +1,7 @@
 import { ExecuteTaskOptions } from "../types";
+/**
+ * Execute a task using an external coding assistant
+ * This is the simplified entry point that delegates to the unified core
+ */
 export declare function executeTask(options: ExecuteTaskOptions): Promise<void>;
 //# sourceMappingURL=task-execution.d.ts.map

package/dist/lib/task-execution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task-execution.d.ts","sourceRoot":"","sources":["../../src/lib/task-execution.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAgC,MAAM,UAAU,CAAC;AA0J5E,wBAAsB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAgF5E"}
+{"version":3,"file":"task-execution.d.ts","sourceRoot":"","sources":["../../src/lib/task-execution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAEnB,MAAM,UAAU,CAAC;AAGlB;;;GAGG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiD5E"}