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

package/dist/commands/prd/generate-arch.d.ts

@@ -1,5 +1,5 @@
 /**
- * PRD Generate Architecture command - Generate CODING-STANDARDS.md and ARCHITECTURE-RULES.md
+ * PRD Generate Architecture command - Generate coding-standards.md and architecture-rules.md
  */
 import { BaseCommand, type CommandResult } from "../base.js";
 export declare class PrdGenerateArchCommand extends BaseCommand {

package/dist/commands/prd/generate-arch.js

@@ -1,5 +1,5 @@
 /**
- * PRD Generate Architecture command - Generate CODING-STANDARDS.md and ARCHITECTURE-RULES.md
+ * PRD Generate Architecture command - Generate coding-standards.md and architecture-rules.md
  */
 import fs from "node:fs";
 import path from "node:path";
@@ -40,10 +40,10 @@ export class PrdGenerateArchCommand extends BaseCommand {
         if (codingStandardsExist || architectureRulesExist) {
             return this.failure("Architecture files already exist", [
                 codingStandardsExist
-                    ? `CODING-STANDARDS.md exists at: ${codingStandardsPath}`
+                    ? `coding-standards.md exists at: ${codingStandardsPath}`
                     : "",
                 architectureRulesExist
-                    ? `ARCHITECTURE-RULES.md exists at: ${architectureRulesPath}`
+                    ? `architecture-rules.md exists at: ${architectureRulesPath}`
                     : "",
             ].filter((s) => s.length > 0), [
                 "Options:",
@@ -54,6 +54,7 @@ export class PrdGenerateArchCommand extends BaseCommand {
         }
         // Read PRD content
         const _prdContent = fs.readFileSync(prdFilePath, "utf-8");
+        void _prdContent; // Intentionally unused - PRD content is loaded for reference
         return this.success([
             `PRD loaded: ${prdFile}`,
             "",
@@ -121,7 +122,7 @@ export class PrdGenerateArchCommand extends BaseCommand {
                 "- Component patterns (HOCs, hooks, render props)",
                 "- Build and bundling setup",
                 "",
-                "STEP 3: CREATE CODING-STANDARDS.md",
+                "STEP 3: CREATE coding-standards.md",
                 "────────────────────────────────────",
                 `File to create: ${codingStandardsPath}`,
                 "",
@@ -156,7 +157,7 @@ export class PrdGenerateArchCommand extends BaseCommand {
                 "   - JSDoc requirements",
                 "   - README standards",
                 "",
-                "STEP 4: CREATE ARCHITECTURE-RULES.md",
+                "STEP 4: CREATE architecture-rules.md",
                 "──────────────────────────────────────",
                 `File to create: ${architectureRulesPath}`,
                 "",

package/dist/commands/retro/list.js

@@ -46,7 +46,7 @@ export class RetroListCommand extends BaseCommand {
             if (!acc[entry.category]) {
                 acc[entry.category] = [];
             }
-            acc[entry.category].push(entry);
+            acc[entry.category]?.push(entry);
             return acc;
         }, {});
         // Format output
@@ -136,13 +136,13 @@ export class RetroListCommand extends BaseCommand {
         for (const line of lines) {
             // Category header: ### TYPE_ERROR
             const categoryMatch = line.match(/^###\s+(.+)/);
-            if (categoryMatch) {
+            if (categoryMatch?.[1]) {
                 currentCategory = categoryMatch[1].toLowerCase().replace(/\s+/g, "_");
                 continue;
             }
             // Entry header: #### TE001: Pattern text (count: 5)
             const entryMatch = line.match(/^####\s+([A-Z]+\d+):\s+(.+?)\s+\(count:\s*(\d+)\)/i);
-            if (entryMatch) {
+            if (entryMatch?.[1] && entryMatch[2] && entryMatch[3]) {
                 // Save previous entry if exists
                 if (currentEntry?.id) {
                     entries.push(currentEntry);
@@ -151,19 +151,20 @@ export class RetroListCommand extends BaseCommand {
                     id: entryMatch[1],
                     category: currentCategory,
                     pattern: entryMatch[2],
+                    solution: "", // Required field, will be set when solution is found
                     count: parseInt(entryMatch[3], 10),
                 };
                 continue;
             }
             // Solution line: **Solution:** text
             const solutionMatch = line.match(/^\*\*Solution:\*\*\s+(.+)/);
-            if (solutionMatch && currentEntry) {
+            if (solutionMatch?.[1] && currentEntry) {
                 currentEntry.solution = solutionMatch[1];
                 continue;
             }
             // Example line: **Example:** text
             const exampleMatch = line.match(/^\*\*Example:\*\*\s+(.+)/);
-            if (exampleMatch && currentEntry) {
+            if (exampleMatch?.[1] && currentEntry) {
                 currentEntry.example = exampleMatch[1];
             }
         }

package/dist/commands/tasks/generate.d.ts

@@ -3,5 +3,5 @@
  */
 import { BaseCommand, type CommandResult } from "../base.js";
 export declare class TasksGenerateCommand extends BaseCommand {
-    execute(prdFile: string): Promise<CommandResult>;
+    execute(prdFile?: string): Promise<CommandResult>;
 }

package/dist/commands/tasks/generate.js

@@ -11,65 +11,101 @@ export class TasksGenerateCommand extends BaseCommand {
         const configLoader = new ConfigLoader(this.context.projectRoot);
         const config = configLoader.load();
         const paths = configLoader.getPaths();
-        // Validate PRD file parameter
-        if (!prdFile || prdFile.trim().length === 0) {
-            return this.failure("PRD file is required", ["You must specify the PRD file to generate tasks from"], [
-                "Generate tasks from a PRD:",
-                "  taskflow tasks generate <prd-filename>",
-                "",
-                "Example:",
-                "  taskflow tasks generate 2024-01-15-user-auth.md",
-            ].join("\n"));
-        }
         // Resolve PRD file path
         const prdsDir = path.join(paths.tasksDir, "prds");
-        const prdFilePath = path.join(prdsDir, prdFile);
-        // Check if PRD file exists
-        if (!fs.existsSync(prdFilePath)) {
+        const prdFilePath = prdFile ? path.join(prdsDir, prdFile) : null;
+        // Scan for all PRDs if no file specified
+        let availablePrds = [];
+        if (fs.existsSync(prdsDir)) {
+            availablePrds = fs.readdirSync(prdsDir).filter((f) => f.endsWith(".md"));
+        }
+        // Validate PRD file parameter
+        if (prdFile &&
+            availablePrds.length > 0 &&
+            !availablePrds.includes(prdFile)) {
             return this.failure("PRD file not found", [`PRD file does not exist: ${prdFilePath}`], [
-                "Available options:",
+                "Available PRDs:",
+                ...availablePrds.map((p) => `  - ${p}`),
+                "",
+                "Options:",
                 "1. Check the filename and try again",
-                "2. List PRD files in tasks/prds/",
+                "2. Run without arguments to see all PRDs",
                 "3. Create a new PRD: taskflow prd create <feature-name>",
             ].join("\n"));
         }
+        if (availablePrds.length === 0) {
+            return this.failure("No PRDs found", ["No PRD files found in tasks/prds/"], [
+                "Create a PRD first:",
+                "  taskflow prd create <feature-name>",
+                "",
+                "Then generate tasks from it.",
+            ].join("\n"));
+        }
+        // Check if tasks already exist (don't block, just inform AI)
+        const progressFilePath = path.join(paths.tasksDir, "tasks-progress.json");
         // Check if architecture files exist
         const codingStandardsPath = getRefFilePath(paths.refDir, REF_FILES.codingStandards);
         const architectureRulesPath = getRefFilePath(paths.refDir, REF_FILES.architectureRules);
         const codingStandardsExist = fs.existsSync(codingStandardsPath);
         const architectureRulesExist = fs.existsSync(architectureRulesPath);
-        if (!codingStandardsExist || !architectureRulesExist) {
-            return this.failure("Architecture files missing", [
-                !codingStandardsExist ? "CODING-STANDARDS.md not found" : "",
-                !architectureRulesExist ? "ARCHITECTURE-RULES.md not found" : "",
-                "",
-                "These files must exist before generating tasks.",
-            ].filter((s) => s.length > 0), [
-                "Generate architecture files first:",
-                `  taskflow prd generate-arch ${prdFile}`,
-                "",
-                "This will create:",
-                "  - CODING-STANDARDS.md",
-                "  - ARCHITECTURE-RULES.md",
-                "",
-                "Then you can generate tasks.",
+        // Build output messages
+        const outputParts = [];
+        if (availablePrds.length > 1 && !prdFile) {
+            outputParts.push([
+                "AVAILABLE PRDs:",
+                "─────────────────",
+                ...availablePrds.map((p, i) => `  [${i + 1}] ${p} ${fs.existsSync(progressFilePath) ? "(tasks generated ✓)" : ""}`),
+                "",
+                "DECISION NEEDED:",
+                "─────────────────",
+                "AI Agent should:",
+                "  1. Analyze project context",
+                "  2. Determine which PRD(s) to generate tasks for",
+                "  3. Consider: Is this adding features to existing project?",
+                "  4. Select appropriate PRD or combine multiple PRDs",
+                "",
+                "OPTIONS:",
+                "─────────",
+                "  - Generate tasks for specific PRD: taskflow tasks generate <filename>",
+                "  - Generate for all ready PRDs (if appropriate)",
+                "  - Combine related PRDs into one feature set",
             ].join("\n"));
         }
-        // Check if tasks already exist
-        const progressFilePath = path.join(paths.tasksDir, "tasks-progress.json");
-        if (fs.existsSync(progressFilePath)) {
-            return this.failure("Tasks already exist", [
-                "Task breakdown already exists in this project",
-                `File: ${progressFilePath}`,
-            ], [
-                "Options:",
-                "1. Review existing tasks: taskflow status",
-                "2. Delete tasks-progress.json to regenerate (CAUTION: loses all progress)",
-                "3. Manually add new features to the existing structure",
+        else if (prdFile) {
+            outputParts.push(`PRD loaded: ${prdFile}`);
+            if (!codingStandardsExist || !architectureRulesExist) {
+                outputParts.push("⚠️  Architecture files missing - Run: taskflow prd generate-arch");
+            }
+            outputParts.push([
+                codingStandardsExist
+                    ? "✓ coding-standards.md found"
+                    : "⚠️  coding-standards.md missing",
+                architectureRulesExist
+                    ? "✓ architecture-rules.md found"
+                    : "⚠️  architecture-rules.md missing",
             ].join("\n"));
+            outputParts.push("");
+            outputParts.push("TASK:");
+            outputParts.push("─".repeat(60));
+            outputParts.push("Generate a complete task breakdown from PRD.", "Create features, stories, and tasks with proper dependencies.");
+        }
+        // Add existing tasks warning if applicable
+        const existingTasks = fs.existsSync(progressFilePath);
+        if (existingTasks) {
+            outputParts.push("");
+            outputParts.push("⚠️  EXISTING TASKS DETECTED:");
+            outputParts.push("───────────────────────────────");
+            outputParts.push(`File: ${progressFilePath} exists`);
+            outputParts.push("");
+            outputParts.push("OPTIONS:");
+            outputParts.push("────────");
+            outputParts.push("1. APPEND: Add new PRDs to existing structure");
+            outputParts.push("2. MERGE: Combine new PRDs with existing tasks");
+            outputParts.push("3. RESET: Delete existing and regenerate (CAUTION: loses progress)");
+            outputParts.push("4. SELECTIVE: Generate only specific PRDs");
+            outputParts.push("");
+            outputParts.push("AI Agent should decide based on project state and user intent.");
         }
-        // Read PRD content
-        const _prdContent = fs.readFileSync(prdFilePath, "utf-8");
         // Get all available skill files
         const availableSkills = Object.values(SKILL_FILES)
             .map((skillFile) => {
@@ -79,16 +115,7 @@ export class TasksGenerateCommand extends BaseCommand {
                 : null;
         })
             .filter(Boolean);
-        return this.success([
-            `PRD loaded: ${prdFile}`,
-            "✓ CODING-STANDARDS.md found",
-            "✓ ARCHITECTURE-RULES.md found",
-            "",
-            "TASK:",
-            "─".repeat(60),
-            "Generate a complete task breakdown from the PRD.",
-            "Create features, stories, and tasks with proper dependencies.",
-        ].join("\n"), [
+        return this.success(outputParts.join("\n"), [
             "This is an AI-assisted task. The breakdown will be created as:",
             `  ${progressFilePath}`,
             "",
@@ -333,7 +360,7 @@ export class TasksGenerateCommand extends BaseCommand {
                 "",
                 "CRITICAL RULES:",
                 "────────────────",
-                "1. DO read TASK-GENERATOR.md completely",
+                "1. DO read task-generator.md completely",
                 "2. DO analyze the codebase before generating tasks",
                 "3. DO make tasks atomic and independently testable",
                 "4. DO assign realistic skill types",
@@ -354,7 +381,7 @@ export class TasksGenerateCommand extends BaseCommand {
                 "3. Run: taskflow start <task-id> (start working)",
             ].join("\n"),
             contextFiles: [
-                `${prdFilePath} - PRD with requirements`,
+                ...(prdFilePath ? [`${prdFilePath} - PRD with requirements`] : []),
                 `${codingStandardsPath} - Project coding standards`,
                 `${architectureRulesPath} - Project architecture rules`,
                 `${getRefFilePath(paths.refDir, REF_FILES.taskGenerator)} - Task generation guidelines`,
@@ -363,7 +390,7 @@ export class TasksGenerateCommand extends BaseCommand {
             ],
             warnings: [
                 "DO NOT create overly broad tasks - break them down",
-                "DO NOT skip reading TASK-GENERATOR.md",
+                "DO NOT skip reading task-generator.md",
                 "DO NOT invent context files - reference actual codebase files",
                 "DO ensure every task has clear acceptance criteria",
                 "DO make sure task IDs follow the N.M.K format exactly",

package/dist/commands/upgrade.js

@@ -8,13 +8,13 @@ import { colors, icons } from "../lib/output.js";
 import { BaseCommand } from "./base.js";
 const CURRENT_TEMPLATE_VERSION = "0.1.0";
 const UPDATE_STRATEGIES = {
-    NEVER: ["RETROSPECTIVE.md"],
-    PROMPT: ["CODING-STANDARDS.md", "ARCHITECTURE-RULES.md"],
+    NEVER: ["retrospective.md"],
+    PROMPT: ["coding-standards.md", "architecture-rules.md"],
     SUGGEST: [
-        "AI-PROTOCOL.md",
-        "TASK-GENERATOR.md",
-        "TASK-EXECUTOR.md",
-        "PRD-GENERATOR.md",
+        "ai-protocol.md",
+        "task-generator.md",
+        "task-executor.md",
+        "prd-generator.md",
     ],
     AUTO: [".version"],
 };
@@ -57,6 +57,23 @@ export class UpgradeCommand extends BaseCommand {
                 nextSteps: "Run without --diff flag to perform the update, or use --auto to skip prompts.",
             };
         }
+        // Check for customized files that will be overwritten
+        const customizedFiles = updatePlan.files.filter((f) => f.isCustomized && f.strategy !== "NEVER");
+        if (customizedFiles.length > 0 && !options?.force) {
+            output += `${colors.errorBold("⚠️  WARNING: Customized files detected!")}\n\n`;
+            output += `The following files have been modified and will be overwritten:\n`;
+            for (const file of customizedFiles) {
+                output += `  ${colors.error(`- ${file.name}`)}\n`;
+            }
+            output += `\n${colors.warning("Your customizations will be LOST!")}\n\n`;
+            output += `${colors.highlight("To proceed anyway, use:")}\n`;
+            output += `  ${colors.command("taskflow upgrade --force")}\n\n`;
+            return {
+                success: false,
+                output,
+                nextSteps: "Review your customizations, then run with --force if you want to proceed",
+            };
+        }
         // Show files to update
         output += `${colors.highlight("Files to update:")}\n`;
         for (const file of updatePlan.files) {
@@ -64,16 +81,24 @@ export class UpgradeCommand extends BaseCommand {
                 output += `  ${colors.muted(`${icons.success} ${file.name} (never touched)`)}\n`;
             }
             else if (file.strategy === "PROMPT") {
-                output += `  ${colors.warning(`⚠️  ${file.name} (user-generated, will prompt)`)}\n`;
+                output += `  ${colors.warning(`⚠️  ${file.name} (user-generated, will skip)`)}\n`;
             }
             else if (file.strategy === "SUGGEST") {
-                output += `  ${colors.info(`📝 ${file.name} (will update)`)}\n`;
+                if (file.isCustomized) {
+                    output += `  ${colors.warning(`⚠️  ${file.name} (customized, will be overwritten)`)}\n`;
+                }
+                else {
+                    output += `  ${colors.info(`📝 ${file.name} (will update)`)}\n`;
+                }
             }
         }
         // Create backup
         output += `\n${colors.highlight("Creating backup...")}\n`;
         const backupDir = this.createBackup(refDir, currentVersion || "unknown");
         output += `${colors.success(`${icons.success} Backup created:`)} ${backupDir}\n\n`;
+        output += `${colors.warning("⚠️  IMPORTANT: Backup location saved above")}\n`;
+        output += `You can restore your files if needed:\n`;
+        output += `  ${colors.command(`cp ${backupDir}/* ${refDir}/`)}\n\n`;
         // Update files
         let updatedCount = 0;
         let skippedCount = 0;
@@ -97,7 +122,7 @@ export class UpgradeCommand extends BaseCommand {
         output += `\n${colors.successBold(`${icons.success} Upgrade complete!`)}\n`;
         output += `  Updated: ${updatedCount} files\n`;
         output += `  Skipped: ${skippedCount} files\n`;
-        output += `  Preserved: RETROSPECTIVE.md, logs\n`;
+        output += `  Preserved: retrospective.md, logs\n`;
         return {
             success: true,
             output,
@@ -130,13 +155,13 @@ export class UpgradeCommand extends BaseCommand {
         const files = [];
         // Map file names to their template paths using the new structure
         const fileToTemplatePath = {
-            "AI-PROTOCOL.md": TEMPLATE_FILES.protocols.aiProtocol,
-            "TASK-GENERATOR.md": TEMPLATE_FILES.protocols.taskGenerator,
-            "TASK-EXECUTOR.md": TEMPLATE_FILES.protocols.taskExecutor,
-            "PRD-GENERATOR.md": TEMPLATE_FILES.prd.prdGenerator,
-            "CODING-STANDARDS.md": TEMPLATE_FILES.project.codingStandards,
-            "ARCHITECTURE-RULES.md": TEMPLATE_FILES.project.architectureRules,
-            "RETROSPECTIVE.md": TEMPLATE_FILES.retrospective.retrospective,
+            "ai-protocol.md": TEMPLATE_FILES.protocols.aiProtocol,
+            "task-generator.md": TEMPLATE_FILES.protocols.taskGenerator,
+            "task-executor.md": TEMPLATE_FILES.protocols.taskExecutor,
+            "prd-generator.md": TEMPLATE_FILES.prd.prdGenerator,
+            "coding-standards.md": TEMPLATE_FILES.project.codingStandards,
+            "architecture-rules.md": TEMPLATE_FILES.project.architectureRules,
+            "retrospective.md": TEMPLATE_FILES.retrospective.retrospective,
         };
         // Get all template files
         const allFiles = [
@@ -160,12 +185,20 @@ export class UpgradeCommand extends BaseCommand {
             const templatePath = templateRelativePath
                 ? path.join(templateDir, templateRelativePath)
                 : path.join(templateDir, fileName);
+            // Check if file is customized (exists and differs from template)
+            let isCustomized = false;
+            if (fs.existsSync(currentPath) && fs.existsSync(templatePath)) {
+                const currentContent = fs.readFileSync(currentPath, "utf-8");
+                const templateContent = fs.readFileSync(templatePath, "utf-8");
+                isCustomized = currentContent !== templateContent;
+            }
             files.push({
                 name: fileName,
                 strategy,
                 currentPath,
                 templatePath,
                 exists: fs.existsSync(currentPath),
+                isCustomized,
             });
         }
         return {

package/dist/commands/workflow/check.d.ts

@@ -4,8 +4,25 @@
 import { BaseCommand, type CommandResult } from "../base.js";
 export declare class CheckCommand extends BaseCommand {
     execute(): Promise<CommandResult>;
+    private advanceToPlanning;
     private advanceToImplementing;
     private advanceToVerifying;
     private advanceToValidating;
     private advanceToCommitting;
+    /**
+     * Run AI-powered validation on changed files
+     */
+    private runAIValidation;
+    /**
+     * Find modified files for validation
+     */
+    private findModifiedFiles;
+    /**
+     * Create error summary from logs and validation results
+     */
+    private createErrorSummary;
+    /**
+     * Format validation results
+     */
+    private formatValidationResults;
 }