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

package/dist/commands/workflow/do.js

@@ -36,19 +36,19 @@ export class DoCommand extends BaseCommand {
         let result = {};
         switch (status) {
             case "setup":
-                result = this.getSetupState(paths.refDir, content, taskId);
+                result = await this.getSetupState(paths.refDir, content, taskId);
                 break;
             case "planning":
-                result = this.getPlanningState(paths.refDir, content, taskId);
+                result = await this.getPlanningState(paths.refDir, content, taskId);
                 break;
             case "implementing":
-                result = this.getImplementState(paths.refDir, content, taskId);
+                result = await this.getImplementState(paths.refDir, content, taskId);
                 break;
             case "verifying":
-                result = this.getVerifyState(paths.refDir, content, taskId);
+                result = await this.getVerifyState(paths.refDir, content, taskId);
                 break;
             case "validating":
-                result = this.getValidateState();
+                result = await this.getValidateState();
                 break;
             case "committing":
                 result = this.getCommitState(feature.id, taskId, task.title);
@@ -99,7 +99,7 @@ export class DoCommand extends BaseCommand {
         }
         return parts.join("\n");
     }
-    getSetupState(refDir, taskContent, taskId) {
+    async getSetupState(refDir, taskContent, taskId) {
         const skill = taskContent.skill || "backend";
         parseTaskId(taskId);
         const outputParts = [];
@@ -124,10 +124,28 @@ export class DoCommand extends BaseCommand {
         outputParts.push("1. Read RETROSPECTIVE to avoid known errors");
         outputParts.push("2. Read AI PROTOCOL to understand workflow rules");
         outputParts.push("3. Review TASK DETAILS and subtasks");
+        // Get LLM guidance if available
+        let llmGuidance = "Read and understand. Do not code yet.";
+        if (this.isLLMAvailable()) {
+            try {
+                const enhancedGuidance = await this.getLLMGuidance({
+                    task: taskContent.title,
+                    status: "setup",
+                    files: taskContent.context,
+                    instructions: "Focus on understanding the task context, not on implementation. Emphasize files to read and patterns to learn.",
+                });
+                if (enhancedGuidance) {
+                    llmGuidance = enhancedGuidance;
+                }
+            }
+            catch {
+                // Use default guidance if LLM call fails
+            }
+        }
         return {
             output: outputParts.join("\n"),
             nextSteps: " When you understand the task, run 'taskflow check' to advance to PLANNING",
-            aiGuidance: "Read and understand. do not code yet.",
+            aiGuidance: llmGuidance,
             contextFiles: [
                 REF_FILES.aiProtocol,
                 REF_FILES.retrospective,
@@ -135,7 +153,7 @@ export class DoCommand extends BaseCommand {
             ],
         };
     }
-    getPlanningState(refDir, taskContent, taskId) {
+    async getPlanningState(refDir, taskContent, taskId) {
         const skill = taskContent.skill || "backend";
         const outputParts = [];
         outputParts.push(colors.infoBold(`${icons.brain} PLANNING STATE - CREATE EXECUTION PLAN`));
@@ -167,6 +185,79 @@ export class DoCommand extends BaseCommand {
         outputParts.push("3. Define implementation approach");
         outputParts.push("4. Order subtasks logically");
         outputParts.push("5. Document your plan");
+        // Get LLM guidance if available
+        let llmGuidance = [
+            "Current Status: PLANNING",
+            "Your Goal: Create a clear, documented plan before coding",
+            "",
+            "PLANNING PROCESS:",
+            "────────────────",
+            "1. SEARCH FIRST:",
+            "   - Find existing implementations to match",
+            "   - Study patterns used in similar code",
+            "   - Identify relevant files and modules",
+            "",
+            "2. CONTEXT REVIEW:",
+            "   - RETROSPECTIVE: Learn what NOT to do",
+            "   - AI PROTOCOL: Understand workflow rules",
+            "   - SKILL GUIDES: Domain-specific patterns",
+            "   - ARCHITECTURE/STANDARDS: Project conventions",
+            "",
+            "3. PLAN CREATION:",
+            "   - List files to modify",
+            "   - Define implementation approach",
+            "   - Order subtasks logically",
+            "   - Note integration points",
+            "   - Plan error handling",
+            "",
+            "4. RISK CHECK:",
+            "   - Check RETROSPECTIVE for similar issues",
+            "   - Identify edge cases",
+            "   - Consider backward compatibility",
+            "",
+            "CRITICAL RULES:",
+            "───────────────",
+            "- Search BEFORE planning",
+            "- Match existing patterns, don't invent new ones",
+            "- Consider all subtasks in your plan",
+            "- Document the approach clearly",
+            "",
+            "DO NOT:",
+            "───────",
+            "- Skip planning and start coding",
+            "- Assume patterns without searching",
+            "- Ignore RETROSPECTIVE warnings",
+            "- Create vague or incomplete plans",
+            "",
+            "WHEN READY:",
+            "────────────",
+            "Run 'taskflow check' to advance to IMPLEMENTING",
+            "Be ready to execute your plan",
+        ].join("\n");
+        if (this.isLLMAvailable()) {
+            try {
+                // Read retrospective to include known error patterns in LLM guidance
+                const retrospectivePath = getRefFilePath(refDir, REF_FILES.retrospective);
+                const retrospectiveContent = loadReferenceFile(retrospectivePath);
+                // Build instructions with retrospective context
+                let instructions = "Focus on planning guidance: files to modify, patterns to follow, subtask order, potential pitfalls. Keep under 200 words.";
+                if (retrospectiveContent) {
+                    instructions += `\n\nIMPORTANT - Learn from known errors in this project:\n${retrospectiveContent}\n\nAvoid repeating these mistakes in your plan.`;
+                }
+                const enhancedGuidance = await this.getLLMGuidance({
+                    task: taskContent.title,
+                    status: "planning",
+                    files: taskContent.context,
+                    instructions,
+                });
+                if (enhancedGuidance) {
+                    llmGuidance = enhancedGuidance;
+                }
+            }
+            catch {
+                // Use default guidance if LLM call fails
+            }
+        }
         return {
             output: outputParts.join("\n"),
             nextSteps: [
@@ -175,54 +266,7 @@ export class DoCommand extends BaseCommand {
                 "3. Complete all planning checklist items",
                 "4. taskflow check (When plan is ready)",
             ].join("\n"),
-            aiGuidance: [
-                "Current Status: PLANNING",
-                "Your Goal: Create a clear, documented plan before coding",
-                "",
-                "PLANNING PROCESS:",
-                "────────────────",
-                "1. SEARCH FIRST:",
-                "   - Find existing implementations to match",
-                "   - Study patterns used in similar code",
-                "   - Identify relevant files and modules",
-                "",
-                "2. CONTEXT REVIEW:",
-                "   - RETROSPECTIVE: Learn what NOT to do",
-                "   - AI PROTOCOL: Understand workflow rules",
-                "   - SKILL GUIDES: Domain-specific patterns",
-                "   - ARCHITECTURE/STANDARDS: Project conventions",
-                "",
-                "3. PLAN CREATION:",
-                "   - List files to modify",
-                "   - Define implementation approach",
-                "   - Order subtasks logically",
-                "   - Note integration points",
-                "   - Plan error handling",
-                "",
-                "4. RISK CHECK:",
-                "   - Check RETROSPECTIVE for similar issues",
-                "   - Identify edge cases",
-                "   - Consider backward compatibility",
-                "",
-                "CRITICAL RULES:",
-                "───────────────",
-                "- Search BEFORE planning",
-                "- Match existing patterns, don't invent new ones",
-                "- Consider all subtasks in your plan",
-                "- Document the approach clearly",
-                "",
-                "DO NOT:",
-                "───────",
-                "- Skip planning and start coding",
-                "- Assume patterns without searching",
-                "- Ignore RETROSPECTIVE warnings",
-                "- Create vague or incomplete plans",
-                "",
-                "WHEN READY:",
-                "────────────",
-                "Run 'taskflow check' to advance to IMPLEMENTING",
-                "Be ready to execute your plan",
-            ].join("\n"),
+            aiGuidance: llmGuidance,
             warnings: [
                 "Most common AI mistake: Skipping planning and writing code immediately",
                 "Always search for existing implementations first",
@@ -230,7 +274,7 @@ export class DoCommand extends BaseCommand {
             ],
         };
     }
-    getImplementState(refDir, taskContent, taskId) {
+    async getImplementState(refDir, taskContent, taskId) {
         const skill = taskContent.skill || "backend";
         const outputParts = [];
         outputParts.push(colors.successBold(`${icons.code} IMPLEMENTING STATE - WRITE CODE NOW`));
@@ -238,6 +282,24 @@ export class DoCommand extends BaseCommand {
         outputParts.push(colors.error("DO NOT: Modify .taskflow/ or tasks/ directly"));
         outputParts.push(this.formatTaskDetails(taskId, taskContent.title, skill, taskContent.description, taskContent.subtasks || [], taskContent.context || []));
         outputParts.push(this.formatReference("AVOID THESE KNOWN ERRORS", getRefFilePath(refDir, REF_FILES.retrospective), colors.error));
+        // Get LLM guidance if available
+        let llmGuidance = "Implement subtasks one by one. Check off subtasks mostly mentally or via subtask command if available.";
+        if (this.isLLMAvailable()) {
+            try {
+                const enhancedGuidance = await this.getLLMGuidance({
+                    task: taskContent.title,
+                    status: "implementing",
+                    files: taskContent.context,
+                    instructions: "Focus on implementation guidance: files to modify, patterns to follow, subtask execution order. Keep under 200 words.",
+                });
+                if (enhancedGuidance) {
+                    llmGuidance = enhancedGuidance;
+                }
+            }
+            catch {
+                // Use default guidance if LLM call fails
+            }
+        }
         return {
             output: outputParts.join("\n"),
             nextSteps: [
@@ -245,10 +307,10 @@ export class DoCommand extends BaseCommand {
                 "2. Test your changes locally",
                 "3. taskflow check  (When ALL subtasks are complete)",
             ].join("\n"),
-            aiGuidance: "Implement subtasks one by one. Check off subtasks mostly mentally or via subtask command if available.",
+            aiGuidance: llmGuidance,
         };
     }
-    getVerifyState(refDir, taskContent, _taskId) {
+    async getVerifyState(refDir, taskContent, _taskId) {
         const outputParts = [];
         outputParts.push(colors.infoBold(`${icons.search} VERIFYING STATE - SELF-REVIEW YOUR CODE`));
         outputParts.push("DO: Review ALL code changes. Verify against checklists.");
@@ -267,6 +329,23 @@ export class DoCommand extends BaseCommand {
             }
         }
         outputParts.push(this.formatReference("CHECK AGAINST RETROSPECTIVE", getRefFilePath(refDir, REF_FILES.retrospective), colors.error));
+        // Get LLM guidance if available
+        let llmGuidance = "Self-review strictly. Don't skip this step.";
+        if (this.isLLMAvailable()) {
+            try {
+                const enhancedGuidance = await this.getLLMGuidance({
+                    task: taskContent.title,
+                    status: "verifying",
+                    instructions: "Focus on self-review guidance: common mistakes to check, patterns to verify. Keep under 200 words.",
+                });
+                if (enhancedGuidance) {
+                    llmGuidance = enhancedGuidance;
+                }
+            }
+            catch {
+                // Use default guidance if LLM call fails
+            }
+        }
         return {
             output: outputParts.join("\n"),
             nextSteps: [
@@ -274,19 +353,35 @@ export class DoCommand extends BaseCommand {
                 "2. Fix any issues found",
                 "3. taskflow check (When self-review is complete)",
             ].join("\n"),
-            aiGuidance: "Self-review strictly. Don't skip this step.",
+            aiGuidance: llmGuidance,
         };
     }
-    getValidateState() {
+    async getValidateState() {
         const outputParts = [];
         outputParts.push(colors.infoBold(`${icons.test} VALIDATING STATE - AUTOMATED CHECKS`));
         outputParts.push("System will run configured checks (format, lint, test, etc.)");
         outputParts.push("", "ON SUCCESS: Advances to COMMITTING");
         outputParts.push("ON FAILURE: Stay in VALIDATING details, fix errors.");
+        // Get LLM guidance if available
+        let llmGuidance = "Run validation. If fails, fix and retry.";
+        if (this.isLLMAvailable()) {
+            try {
+                const enhancedGuidance = await this.getLLMGuidance({
+                    status: "validating",
+                    instructions: "Focus on validation guidance: how to fix errors, error analysis approach. Keep under 200 words.",
+                });
+                if (enhancedGuidance) {
+                    llmGuidance = enhancedGuidance;
+                }
+            }
+            catch {
+                // Use default guidance if LLM call fails
+            }
+        }
         return {
             output: outputParts.join("\n"),
             nextSteps: "Run 'taskflow check' to run validations",
-            aiGuidance: "Run validation. If fails, fix and retry.",
+            aiGuidance: llmGuidance,
         };
     }
     getCommitState(featureId, taskId, taskTitle) {

package/dist/index.d.ts

@@ -4,6 +4,7 @@
  */
 export * from "./cli/index.js";
 export * from "./commands/base.js";
+export * from "./commands/configure.js";
 export * from "./commands/init.js";
 export * from "./commands/prd/create.js";
 export * from "./commands/prd/generate-arch.js";
@@ -23,9 +24,12 @@ export * from "./lib/config-loader.js";
 export * from "./lib/config-paths.js";
 export * from "./lib/data-access.js";
 export * from "./lib/errors.js";
+export * from "./lib/file-validator.js";
 export * from "./lib/git.js";
+export * from "./lib/log-parser.js";
 export * from "./lib/output.js";
 export * from "./lib/retrospective.js";
 export type { ActiveStatus, Criticality, ErrorCategory, Feature, RetrospectiveItem, Story, Subtask, TaskFileContent, TaskflowConfig, TaskRef, TaskStatus, TasksProgress, TimeEntry, } from "./lib/types.js";
 export { parseTaskId, STATUS_TRANSITIONS, TaskStatusSchema, } from "./lib/types.js";
 export * from "./lib/validation.js";
+export * from "./llm/index.js";

package/dist/index.js

@@ -7,6 +7,7 @@ export * from "./cli/index.js";
 // Export command base (includes CommandContext and CommandResult)
 export * from "./commands/base.js";
 // Export all commands
+export * from "./commands/configure.js";
 export * from "./commands/init.js";
 export * from "./commands/prd/create.js";
 export * from "./commands/prd/generate-arch.js";
@@ -29,8 +30,13 @@ export * from "./lib/config-paths.js";
 export * from "./lib/data-access.js";
 // Export errors
 export * from "./lib/errors.js";
+export * from "./lib/file-validator.js";
 export * from "./lib/git.js";
+// Export log parser and file validator
+export * from "./lib/log-parser.js";
 export * from "./lib/output.js";
 export * from "./lib/retrospective.js";
 export { parseTaskId, STATUS_TRANSITIONS, TaskStatusSchema, } from "./lib/types.js";
 export * from "./lib/validation.js";
+// Export LLM providers
+export * from "./llm/index.js";

package/dist/lib/config-paths.js

@@ -118,7 +118,12 @@ export function getProjectIndexPath(tasksDir) {
     return path.join(tasksDir, PROJECT_INDEX_FILE);
 }
 export function getFeatureFilePath(tasksDir, featurePath) {
-    return path.join(tasksDir, featurePath, `${featurePath}.json`);
+    // If the path ends in .json, return it as is (relative to tasksDir)
+    if (featurePath.endsWith(".json")) {
+        return path.join(tasksDir, featurePath);
+    }
+    // Otherwise assume it's a directory and look for a json file with the same name as the directory
+    return path.join(tasksDir, featurePath, `${path.basename(featurePath)}.json`);
 }
 export function getRefFilePath(refDir, filename) {
     return path.join(refDir, filename);

package/dist/lib/file-validator.d.ts

@@ -0,0 +1,119 @@
+/**
+ * File Validator
+ * Validates code files using LLM to provide fix suggestions and guidance
+ */
+import type { LLMProvider } from "../llm/base.js";
+export interface ValidationResult {
+    /**
+     * File path
+     */
+    file: string;
+    /**
+     * Whether file passed validation
+     */
+    passed: boolean;
+    /**
+     * Issues found
+     */
+    issues: ValidationIssue[];
+    /**
+     * Suggestions for fixes
+     */
+    suggestions: string[];
+    /**
+     * Validation summary
+     */
+    summary: string;
+}
+export interface ValidationIssue {
+    /**
+     * Severity of the issue
+     */
+    severity: "error" | "warning" | "info";
+    /**
+     * Line number (if available)
+     */
+    line?: number;
+    /**
+     * Issue description
+     */
+    message: string;
+    /**
+     * Code or type of issue
+     */
+    code?: string;
+    /**
+     * Suggested fix
+     */
+    suggestedFix?: string;
+}
+export interface ValidatorOptions {
+    /**
+     * Provider to use for validation
+     */
+    provider: LLMProvider;
+    /**
+     * Whether to include context in validation
+     */
+    includeContext?: boolean;
+    /**
+     * Whether to provide fix suggestions
+     */
+    provideFixes?: boolean;
+    /**
+     * Maximum issues to report
+     */
+    maxIssues?: number;
+}
+/**
+ * File Validator class
+ * Validates code files using LLM for analysis and fix suggestions
+ */
+export declare class FileValidator {
+    private options;
+    constructor(options: ValidatorOptions);
+    /**
+     * Validate a file
+     */
+    validate(filePath: string): Promise<ValidationResult>;
+    /**
+     * Validate multiple files
+     */
+    validateFiles(filePaths: string[]): Promise<ValidationResult[]>;
+    /**
+     * Validate file content
+     */
+    validateContent(filePath: string, content: string): Promise<ValidationResult>;
+    /**
+     * Create validation prompt
+     */
+    private createValidationPrompt;
+    /**
+     * Truncate content to fit within context limits
+     */
+    private truncateContent;
+    /**
+     * Parse validation response from LLM
+     */
+    private parseValidationResponse;
+    /**
+     * Extract suggestions from issues
+     */
+    private extractSuggestions;
+    /**
+     * Create validation summary
+     */
+    private createSummary;
+    /**
+     * Create fallback result when LLM fails
+     */
+    private createFallbackResult;
+    /**
+     * Format validation result for display
+     */
+    formatResult(result: ValidationResult): string;
+    /**
+     * Format multiple validation results
+     */
+    formatResults(results: ValidationResult[]): string;
+}