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

package/dist/commands/tasks/generate.js

@@ -11,66 +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");
-        void _prdContent; // Intentionally unused - PRD content is loaded for reference
         // Get all available skill files
         const availableSkills = Object.values(SKILL_FILES)
             .map((skillFile) => {
@@ -80,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}`,
             "",
@@ -355,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`,

package/dist/commands/upgrade.js

@@ -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;
@@ -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

@@ -9,4 +9,20 @@ export declare class CheckCommand extends BaseCommand {
     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;
 }