@krr2020/taskflow-core 0.1.0-beta.3 → 0.1.0-beta.5

package/dist/commands/workflow/check.js

@@ -1,12 +1,19 @@
 /**
  * Check command - Validate and advance task state
  */
+import { execSync } from "node:child_process";
+import { readdir } from "node:fs/promises";
+import path from "node:path";
 import { ConfigLoader } from "../../lib/config-loader.js";
 import { getRefFilePath, REF_FILES } from "../../lib/config-paths.js";
 import { findActiveTask, loadTasksProgress, updateTaskStatus, } from "../../lib/data-access.js";
 import { NoActiveSessionError } from "../../lib/errors.js";
-import { processValidationOutput } from "../../lib/retrospective.js";
+import { FileValidator, } from "../../lib/file-validator.js";
+import { LogParser } from "../../lib/log-parser.js";
+import { extractNewPatterns, formatNewPatternForDisplay, processValidationOutput, } from "../../lib/retrospective.js";
 import { runValidations } from "../../lib/validation.js";
+import { Phase } from "../../llm/base.js";
+import { ProviderFactory } from "../../llm/factory.js";
 import { BaseCommand } from "../base.js";
 export class CheckCommand extends BaseCommand {
     async execute() {
@@ -25,6 +32,8 @@ export class CheckCommand extends BaseCommand {
         // Handle each status transition
         switch (currentStatus) {
             case "setup":
+                return this.advanceToPlanning(paths.tasksDir, tasksProgress, taskId, content);
+            case "planning":
                 return this.advanceToImplementing(paths.tasksDir, tasksProgress, taskId, content);
             case "implementing":
                 return this.advanceToVerifying(paths.tasksDir, tasksProgress, taskId, content);
@@ -44,14 +53,98 @@ export class CheckCommand extends BaseCommand {
                 return this.failure(`Unknown status: ${currentStatus}`, [`Task ${taskId} has an invalid status`], "Check the task file and fix the status manually.");
         }
     }
+    advanceToPlanning(tasksDir, tasksProgress, taskId, content) {
+        // Advance to planning
+        updateTaskStatus(tasksDir, tasksProgress, taskId, "planning");
+        return this.success([
+            `✓ Status advanced: setup → planning`,
+            `✓ Task ${taskId}: ${content.title}`,
+            "",
+            "Now create your execution plan before writing code.",
+        ].join("\n"), [
+            "1. Create execution plan:",
+            "   - Review all context files (RETROSPECTIVE, AI PROTOCOL, etc.)",
+            "   - Identify files to modify",
+            "   - Determine implementation approach",
+            "   - Plan subtask execution order",
+            "",
+            "2. Check planning checklist:",
+            "   - [ ] Reviewed RETROSPECTIVE for known issues",
+            "   - [ ] Understood task requirements",
+            "   - [ ] Identified affected files and patterns",
+            "   - [ ] Planned implementation approach",
+            "   - [ ] Considered edge cases",
+            "",
+            "3. When plan is ready, run:",
+            "   taskflow check",
+            "   This will advance you to IMPLEMENTING status",
+        ].join("\n"), {
+            aiGuidance: [
+                "Current Status: PLANNING",
+                "Your Goal: Create a clear execution plan",
+                "",
+                "PLANNING CHECKLIST:",
+                "─────────────────────",
+                "1. CONTEXT REVIEW:",
+                "   - Read RETROSPECTIVE - know what NOT to do",
+                "   - Read AI PROTOCOL - understand workflow rules",
+                "   - Review TASK DETAILS - understand requirements",
+                "   - Check SKILL guidelines - domain-specific rules",
+                "   - Review ARCHITECTURE/CODING STANDARDS",
+                "",
+                "2. ANALYSIS:",
+                "   - Search for similar implementations in codebase",
+                "   - Identify patterns to follow",
+                "   - List files to modify",
+                "   - Identify dependencies",
+                "   - Check for library conflicts (verify no similar library exists, check compatibility)",
+                "",
+                "3. PLAN CREATION:",
+                "   - Define implementation approach",
+                "   - Order subtasks logically",
+                "   - Consider error handling needs",
+                "   - Note integration points",
+                "   - Use EARS syntax for acceptance criteria: WHEN [event] THEN [system] SHALL [response]",
+                "   - Present alternatives with pros/cons when multiple approaches exist",
+                "",
+                "4. RISK ASSESSMENT:",
+                "   - Check RETROSPECTIVE for known issues",
+                "   - Identify potential edge cases",
+                "   - Plan for backward compatibility",
+                "   - Ask for explicit approval (yes/approved/LGTM?) before proceeding",
+                "",
+                "OUTPUT DOCUMENT:",
+                "─────────────────",
+                "Create a brief plan covering:",
+                "- Files to modify",
+                "- Implementation approach",
+                "- Patterns to follow",
+                "- Subtask execution order",
+                "- Acceptance criteria (EARS syntax)",
+                "",
+                "ASK ONE QUESTION AT A TIME:",
+                "───────────────────────────",
+                "Build understanding iteratively - ask ONE clarifying question, wait for answer, then ask the next. Do NOT batch questions.",
+                "",
+                "WHEN READY:",
+                "────────────",
+                "Run 'taskflow check' to advance to IMPLEMENTING",
+            ].join("\n"),
+            warnings: [
+                "Do NOT skip planning - it prevents costly mistakes",
+                "Do NOT start coding until plan is complete",
+                "Review RETROSPECTIVE carefully - avoid known errors",
+            ],
+        });
+    }
     advanceToImplementing(tasksDir, tasksProgress, taskId, content) {
         // Advance to implementing
         updateTaskStatus(tasksDir, tasksProgress, taskId, "implementing");
         return this.success([
-            `✓ Status advanced: setup → implementing`,
+            `✓ Status advanced: planning → implementing`,
             `✓ Task ${taskId}: ${content.title}`,
             "",
-            "You may now write code to implement this task.",
+            "You may now write code to implement this task based on your plan.",
         ].join("\n"), [
             "1. Write the code to implement the task",
             "   - Follow the patterns in the codebase",
@@ -77,6 +170,8 @@ export class CheckCommand extends BaseCommand {
                 "3. MATCH PATTERNS - Code should be indistinguishable from existing",
                 "4. HANDLE ERRORS - Every external call needs error handling",
                 "5. NO GUESSING - Verify everything before declaring done",
+                "6. CHECK LIBRARY COMPATIBILITY - Before suggesting new libraries, verify no similar library exists, check compatibility, consider security/maintenance",
+                "7. SECURITY & PERFORMANCE - Consider security implications, performance impact, backward compatibility",
                 "",
                 "Operating Mode Selection:",
                 "- REACTIVE: Simple, clear, single file",
@@ -91,6 +186,23 @@ export class CheckCommand extends BaseCommand {
                 "- Create new patterns when existing ones work",
                 "- Declare done without verifying",
                 "",
+                "3-RETRY LIMIT FOR TESTS:",
+                "────────────────────────",
+                "Automated tests: Implement test, run full suite, fix failures. Max 3 retry attempts. If still failing, STOP and analyze root cause.",
+                "Manual tests: STOP and ask user to verify. Do NOT auto-proceed.",
+                "",
+                "LEARNINGS TRACKING:",
+                "────────────────────",
+                "Track learnings for future tasks: capture only general, project-wide insights (not implementation details, not what you did but what you learned, prevent repeated mistakes).",
+                "",
+                "TECH DEBT REPORTING:",
+                "────────────────────────",
+                "Report after implementation: tech debt introduced, unfinished work, most impactful next step (focus on high-impact items only).",
+                "",
+                "DEFINITION OF DONE:",
+                "────────────────────",
+                "Before declaring complete: functional requirements implemented, tests passing (3-retry limit for automated), lint/type-check pass, documentation updated (if applicable), code reviewed (mandatory), no tech debt or explicitly reported.",
+                "",
                 "WHEN DONE:",
                 "───────────",
                 "Run 'taskflow check' to advance to VERIFYING",
@@ -120,7 +232,7 @@ export class CheckCommand extends BaseCommand {
             "2. Verify all acceptance criteria are met:",
             ...(content.subtasks || []).map((st) => `   [${st.status === "completed" ? "x" : " "}] ${st.id}. ${st.description}`),
             "",
-            "3. Check against .taskflow/ref/RETROSPECTIVE.md:",
+            "3. Check against .taskflow/ref/retrospective.md:",
             "   Ensure you haven't repeated known mistakes",
             "",
             "4. When self-review is complete, run:",
@@ -141,9 +253,17 @@ export class CheckCommand extends BaseCommand {
                 "□ All subtasks completed",
                 "□ Acceptance criteria met",
                 "",
+                "LEARNINGS TRACKING:",
+                "────────────────────",
+                "Capture only general, project-wide insights: not implementation details ('I added a function'), not what you did but what you learned, prevent repeated mistakes in future tasks.",
+                "",
+                "TECH DEBT REPORTING:",
+                "────────────────────────",
+                "Report after implementation: tech debt introduced, unfinished work, most impactful next step (focus on high-impact items only).",
+                "",
                 "RETROSPECTIVE CHECK:",
                 "────────────────────",
-                "Read .taskflow/ref/RETROSPECTIVE.md",
+                "Read .taskflow/ref/retrospective.md",
                 "Confirm you haven't made any known mistakes",
                 "These are errors that have been made before",
                 "Do NOT repeat them",
@@ -206,6 +326,12 @@ export class CheckCommand extends BaseCommand {
                 "3. Lint - check code quality",
                 "4. Tests - verify functionality (if configured)",
                 "",
+                "TEST HANDLING:",
+                "────────────────",
+                "Automated tests: Implement test, run full suite, fix failures. Max 3 retry attempts. If still failing, STOP and analyze root cause.",
+                "Manual tests: STOP and ask user to verify. Do NOT auto-proceed.",
+                "Database tests: Do NOT clean up test data.",
+                "",
                 "IF VALIDATION FAILS:",
                 "────────────────────",
                 "1. Read the error summary in the output",
@@ -228,51 +354,138 @@ export class CheckCommand extends BaseCommand {
         });
     }
     async advanceToCommitting(tasksDir, logsDir, refDir, tasksProgress, taskId, content, validationCommands) {
-        // Run validations
+        // Check if AI validation is enabled
+        const configLoader = new ConfigLoader(this.context.projectRoot);
+        const config = configLoader.load();
+        // Run AI-powered validation if configured
+        if (config.ai?.enabled && config.ai.provider) {
+            const aiResult = await this.runAIValidation(logsDir, Phase.Analysis);
+            if (!aiResult.passed) {
+                return aiResult.result;
+            }
+        }
+        // Run traditional validations
         console.log("\n🧪 Running validations...\n");
         const summary = runValidations(logsDir, taskId, validationCommands);
         // Check for known errors in output
         const retroCheck = processValidationOutput(refDir, summary.allOutput);
         if (!summary.passed) {
+            // Get LLM error analysis if available
+            let llmGuidance = [
+                "Validation Failed - Fix Required",
+                "",
+                retroCheck.knownErrors.length > 0
+                    ? "KNOWN ERRORS DETECTED:"
+                    : "Errors found in validation.",
+                retroCheck.knownErrors.length > 0
+                    ? "You have made mistakes that are already documented."
+                    : "",
+                retroCheck.knownErrors.length > 0
+                    ? "Check the output above for solutions."
+                    : "",
+                retroCheck.knownErrors.length > 0
+                    ? "STOP REPEATING THESE MISTAKES."
+                    : "",
+                "",
+                "How to fix:",
+                "1. Read error messages carefully",
+                "2. Apply solutions from retrospective (if shown)",
+                "3. Fix the code",
+                "4. Re-run: taskflow check",
+                "",
+                "DO NOT bypass validations",
+                "DO NOT use 'any' types to suppress errors",
+                "DO fix the root cause",
+            ].join("\n");
+            // Parse logs and detect new error patterns
+            const logParser = new LogParser();
+            const logFiles = await readdir(logsDir);
+            const parsedErrors = [];
+            for (const logFile of logFiles) {
+                if (logFile.endsWith(".log")) {
+                    try {
+                        const logPath = path.join(logsDir, logFile);
+                        const parseResult = await logParser.parseFile(logPath);
+                        parsedErrors.push(...parseResult.errors);
+                    }
+                    catch {
+                        // Ignore log parsing errors
+                    }
+                }
+            }
+            // Detect NEW error patterns for retrospective
+            let newPatternsDetected = [];
+            if (parsedErrors.length > 0) {
+                const newPatterns = extractNewPatterns(parsedErrors, refDir);
+                if (newPatterns.length > 0) {
+                    newPatternsDetected = newPatterns.map((pattern) => formatNewPatternForDisplay(pattern));
+                }
+            }
+            // Get AI error analysis if LLM available
+            if (this.isLLMAvailable() && parsedErrors.length > 0) {
+                try {
+                    const errors = parsedErrors.map((error) => ({
+                        file: error.file,
+                        message: error.message,
+                        line: error.line ?? undefined,
+                        code: error.code ?? undefined,
+                    }));
+                    const errorAnalysis = await this.getErrorAnalysis(errors);
+                    if (errorAnalysis) {
+                        llmGuidance = [
+                            "AI Error Analysis:",
+                            "───────────────────",
+                            errorAnalysis,
+                            "",
+                            "How to fix:",
+                            "1. Review the AI analysis above",
+                            "2. Apply suggested fixes file-by-file",
+                            "3. Re-run: taskflow check",
+                            "",
+                            retroCheck.knownErrors.length > 0
+                                ? "⚠️  Known errors also detected - see solutions above"
+                                : "",
+                            "",
+                            newPatternsDetected.length > 0
+                                ? "📝 NEW error patterns detected (see warnings below)"
+                                : "",
+                        ].join("\n");
+                    }
+                }
+                catch {
+                    // Fall back to standard guidance
+                }
+            }
+            // Build warnings with new patterns
+            const warnings = [];
+            if (newPatternsDetected.length > 0) {
+                warnings.push("📝 NEW Error Patterns Detected:");
+                warnings.push("");
+                for (const patternDisplay of newPatternsDetected) {
+                    warnings.push(patternDisplay);
+                    warnings.push("");
+                }
+                warnings.push("💡 Consider adding these to retrospective: taskflow retro add");
+                warnings.push("");
+            }
+            const failureOptions = {
+                aiGuidance: llmGuidance,
+            };
+            if (warnings.length > 0) {
+                failureOptions.warnings = warnings;
+            }
             return this.failure("Validation failed", summary.failedChecks.map((check) => `${check} failed`), [
                 "Fix the errors shown above and re-run: taskflow check",
                 "",
                 retroCheck.knownErrors.length > 0
                     ? "⚠️  Known errors detected - see solutions above"
                     : "",
-                retroCheck.hasNewErrors
+                retroCheck.hasNewErrors && newPatternsDetected.length === 0
                     ? "⚠️  New error detected - consider adding to retrospective: taskflow retro add"
                     : "",
                 "",
                 `Full logs: ${logsDir}`,
-            ].join("\n"), {
-                aiGuidance: [
-                    "Validation Failed - Fix Required",
-                    "",
-                    retroCheck.knownErrors.length > 0
-                        ? "KNOWN ERRORS DETECTED:"
-                        : "Errors found in validation.",
-                    retroCheck.knownErrors.length > 0
-                        ? "You have made mistakes that are already documented."
-                        : "",
-                    retroCheck.knownErrors.length > 0
-                        ? "Check the output above for solutions."
-                        : "",
-                    retroCheck.knownErrors.length > 0
-                        ? "STOP REPEATING THESE MISTAKES."
-                        : "",
-                    "",
-                    "How to fix:",
-                    "1. Read error messages carefully",
-                    "2. Apply solutions from retrospective (if shown)",
-                    "3. Fix the code",
-                    "4. Re-run: taskflow check",
-                    "",
-                    "DO NOT bypass validations",
-                    "DO NOT use 'any' types to suppress errors",
-                    "DO fix the root cause",
-                ].join("\n"),
-            });
+            ].join("\n"), failureOptions);
         }
         // All validations passed - advance to committing
         updateTaskStatus(tasksDir, tasksProgress, taskId, "committing");
@@ -316,6 +529,10 @@ export class CheckCommand extends BaseCommand {
                 "- Be specific and concise",
                 "- Focus on user-facing or functional changes",
                 "",
+                "TECH DEBT REPORTING:",
+                "────────────────────────",
+                "Report after implementation: tech debt introduced, unfinished work, most impactful next step (focus on high-impact items only).",
+                "",
                 "WHAT HAPPENS NEXT:",
                 "───────────────────",
                 "1. Git add all changes",
@@ -333,7 +550,237 @@ export class CheckCommand extends BaseCommand {
                 "Commit will run git hooks - they must pass",
                 "Push may fail if remote has changes - pull first if needed",
                 "This action marks the task as completed",
+                "Report any tech debt introduced in commit message or retrospective",
             ],
         });
     }
+    /**
+     * Run AI-powered validation on changed files
+     */
+    async runAIValidation(logsDir, phase) {
+        console.log("\n🤖 Running AI-powered file validation...\n");
+        try {
+            // Get AI config to create provider with correct settings
+            const config = this.configLoader.load();
+            if (!config?.ai || !config.ai.enabled) {
+                throw new Error("AI configuration not enabled");
+            }
+            if (!config.ai.provider) {
+                throw new Error("AI provider not configured");
+            }
+            // Create provider using actual config (cast to AIConfig)
+            const provider = ProviderFactory.createSelector(config.ai);
+            const analysisProvider = provider.getProvider(phase);
+            // Find modified files (git status, recent changes, etc.)
+            const modifiedFiles = await this.findModifiedFiles();
+            if (modifiedFiles.length === 0) {
+                console.log("No modified files found for validation");
+                return {
+                    passed: true,
+                    result: this.success("No files to validate", ""),
+                };
+            }
+            console.log(`Validating ${modifiedFiles.length} file${modifiedFiles.length > 1 ? "s" : ""}...\n`);
+            // Create file validator
+            const validator = new FileValidator({
+                provider: analysisProvider,
+                includeContext: true,
+                provideFixes: true,
+                maxIssues: 10,
+            });
+            // Validate each file
+            const results = [];
+            for (const filePath of modifiedFiles) {
+                try {
+                    const result = await validator.validate(filePath);
+                    results.push(result);
+                }
+                catch (error) {
+                    console.warn(`Failed to validate ${filePath}: ${error.message}`);
+                }
+            }
+            // Check if all files passed
+            const allPassed = results.every((r) => r.passed);
+            // Format and display results
+            const output = this.formatValidationResults(results);
+            console.log(output);
+            if (allPassed) {
+                return {
+                    passed: true,
+                    result: this.success("All files passed AI validation", "Ready to proceed with standard validation"),
+                };
+            }
+            // Parse logs for errors to provide context
+            const logParser = new LogParser();
+            const logFiles = await readdir(logsDir);
+            const errors = [];
+            for (const logFile of logFiles) {
+                if (logFile.endsWith(".log")) {
+                    try {
+                        const logPath = path.join(logsDir, logFile);
+                        const parseResult = await logParser.parseFile(logPath);
+                        errors.push(...parseResult.errors);
+                    }
+                    catch {
+                        // Ignore log parsing errors
+                    }
+                }
+            }
+            // Create AI guidance with error context
+            const errorSummary = this.createErrorSummary(errors);
+            const messages = [
+                "Fix issues shown above and re-run: taskflow check",
+                "",
+                errorSummary,
+                "",
+                "AI-Powered Validation Benefits:",
+                "- Early error detection before compilation",
+                "- Context-aware fix suggestions",
+                "- Pattern-based issue identification",
+                "- Code quality analysis",
+            ];
+            const guidance = [
+                "AI Validation Results",
+                "────────────────────",
+                `Files validated: ${results.length}`,
+                `Files passed: ${results.filter((r) => r.passed).length}`,
+                `Files failed: ${results.filter((r) => !r.passed).length}`,
+                "",
+                "Fix Instructions:",
+                "1. Review issues shown above for each file",
+                "2. Apply suggested fixes",
+                "3. Re-run: taskflow check",
+                "",
+                "If errors persist, check for:",
+                "- Incorrect imports or types",
+                "- Missing dependencies",
+                "- Logic errors or bugs",
+                "- Known patterns in retrospective",
+            ];
+            return {
+                passed: false,
+                result: this.failure("AI validation failed", results.flatMap((r) => r.issues.map((i) => i.message)), messages.join("\n"), {
+                    aiGuidance: guidance.join("\n"),
+                }),
+            };
+        }
+        catch (error) {
+            console.warn(`AI validation failed: ${error.message}`);
+            console.log("Falling back to standard validation\n");
+            // Return passed to fall back to standard validation
+            return {
+                passed: true,
+                result: this.success("AI validation skipped", "Proceeding with standard validation"),
+            };
+        }
+    }
+    /**
+     * Find modified files for validation
+     */
+    async findModifiedFiles() {
+        try {
+            // Get modified, added, and untracked files from git
+            const output = execSync("git status --porcelain --untracked-files=all", {
+                cwd: this.context.projectRoot,
+                encoding: "utf-8",
+            }).trim();
+            if (!output) {
+                return [];
+            }
+            const files = [];
+            const lines = output.split("\n");
+            for (const line of lines) {
+                // Parse git status output format:
+                // XY FILENAME
+                // X = status in index, Y = status in working tree
+                // Status codes: M (modified), A (added), D (deleted), ?? (untracked), etc.
+                const match = line.match(/^(.{2})\s+(.+)$/);
+                if (!match)
+                    continue;
+                const [, status, filePath] = match;
+                if (!status || !filePath)
+                    continue;
+                // Skip deleted files
+                if (status.includes("D"))
+                    continue;
+                // Only validate source files (ts, tsx, js, jsx) but not test files
+                const isSourceFile = /\.(ts|tsx|js|jsx|mjs|cjs)$/.test(filePath);
+                const isTestFile = /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(filePath);
+                if (isSourceFile && !isTestFile) {
+                    // Convert to absolute path
+                    const absolutePath = path.join(this.context.projectRoot, filePath);
+                    files.push(absolutePath);
+                }
+            }
+            return files;
+        }
+        catch (error) {
+            console.warn(`Failed to get modified files: ${error.message}`);
+            return [];
+        }
+    }
+    /**
+     * Create error summary from logs and validation results
+     */
+    createErrorSummary(errors) {
+        if (errors.length === 0) {
+            return "No errors found in logs.";
+        }
+        const grouped = new Map();
+        for (const error of errors) {
+            if (error.file) {
+                const existing = grouped.get(error.file) || [];
+                existing.push(error);
+                grouped.set(error.file, existing);
+            }
+        }
+        const lines = ["Error Summary:", ""];
+        for (const [file, fileErrors] of grouped) {
+            lines.push(`${file}: ${fileErrors.length} error${fileErrors.length > 1 ? "s" : ""}`);
+        }
+        return lines.join("\n");
+    }
+    /**
+     * Format validation results
+     */
+    formatValidationResults(results) {
+        const lines = [];
+        lines.push("=".repeat(80));
+        lines.push("AI-Powered Validation Results");
+        lines.push("=".repeat(80));
+        for (const result of results) {
+            lines.push("");
+            lines.push(`File: ${result.file}`);
+            lines.push(`Status: ${result.passed ? "✓ PASSED" : "✗ FAILED"}`);
+            lines.push(`Summary: ${result.summary}`);
+            if (result.issues.length > 0) {
+                lines.push("");
+                lines.push("Issues:");
+                for (const issue of result.issues) {
+                    const icon = issue.severity === "error"
+                        ? "✗"
+                        : issue.severity === "warning"
+                            ? "⚠"
+                            : "ℹ";
+                    lines.push(`  ${icon} ${issue.message}`);
+                    if (issue.line) {
+                        lines.push(`    Line: ${issue.line}`);
+                    }
+                    if (issue.suggestedFix) {
+                        lines.push(`    Suggested: ${issue.suggestedFix}`);
+                    }
+                }
+            }
+            if (result.suggestions.length > 0) {
+                lines.push("");
+                lines.push("Suggestions:");
+                for (const suggestion of result.suggestions) {
+                    lines.push(`  • ${suggestion}`);
+                }
+            }
+        }
+        lines.push("");
+        lines.push("=".repeat(80));
+        return lines.join("\n");
+    }
 }