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

package/README.md

@@ -172,7 +172,7 @@ Most users should use this package via:
 - **[@krr2020/taskflow-mcp-server](https://www.npmjs.com/package/@krr2020/taskflow-mcp-server)** - MCP Server for Claude Desktop
 - **CLI** - Direct command-line usage via `npx @krr2020/taskflow-core`
 
-See the main [Taskflow documentation](../../README.md) for complete usage examples.
+See the main [Taskflow documentation](../README.md) for complete usage examples.
 
 ## 📄 License
 

package/dist/cli/index.js

@@ -4,6 +4,7 @@
 import process from "node:process";
 import { Command } from "commander";
 // Import commands
+import { ConfigureAICommand } from "../commands/configure.js";
 import { InitCommand } from "../commands/init.js";
 import { PrdCreateCommand } from "../commands/prd/create.js";
 import { PrdGenerateArchCommand } from "../commands/prd/generate-arch.js";
@@ -51,6 +52,42 @@ export async function runCLI() {
         }
     });
     // ========================================
+    // CONFIGURE COMMAND
+    // ========================================
+    const configureCommand = program
+        .command("configure")
+        .description("Configure taskflow settings");
+    configureCommand
+        .command("ai")
+        .description("Configure AI/LLM provider for manual command execution")
+        .option("--provider <provider>", "Provider type (openai-compatible, anthropic, ollama)")
+        .option("--apiKey <key>", "API key for the provider (can use $${ENV_VAR} format)")
+        .option("--model <model>", "Default model to use")
+        .option("--planning <model>", "Model for planning phase (e.g., claude-opus-4)")
+        .option("--execution <model>", "Model for execution phase (e.g., gemini-pro-2.0)")
+        .option("--analysis <model>", "Model for analysis phase (e.g., claude-sonnet-4)")
+        .option("--planningProvider <provider>", "Different provider for planning")
+        .option("--planningApiKey <key>", "API key for planning provider")
+        .option("--executionProvider <provider>", "Different provider for execution")
+        .option("--executionApiKey <key>", "API key for execution provider")
+        .option("--analysisProvider <provider>", "Different provider for analysis")
+        .option("--analysisApiKey <key>", "API key for analysis provider")
+        .option("--ollamaBaseUrl <url>", "Ollama base URL (default: http://localhost:11434)")
+        .option("--openaiBaseUrl <url>", "OpenAI-compatible base URL (default: https://api.openai.com/v1)")
+        .option("--enable", "Enable AI features")
+        .option("--disable", "Disable AI features")
+        .action(async (options) => {
+        try {
+            const cmd = new ConfigureAICommand(context);
+            const result = await cmd.execute(options);
+            console.log(formatSuccess(result));
+            process.exit(0);
+        }
+        catch (error) {
+            handleError(error);
+        }
+    });
+    // ========================================
     // UPGRADE COMMAND
     // ========================================
     program
@@ -232,10 +269,11 @@ export async function runCLI() {
         .command("create")
         .description("Create a new PRD")
         .argument("<feature-name>", "Name of the feature")
-        .action(async (featureName) => {
+        .option("--description <desc>", "Feature description/requirements (optional)")
+        .action(async (featureName, options) => {
         try {
             const cmd = new PrdCreateCommand(context);
-            const result = await cmd.execute(featureName);
+            const result = await cmd.execute(featureName, options.description);
             console.log(formatSuccess(result));
             process.exit(0);
         }
@@ -245,7 +283,7 @@ export async function runCLI() {
     });
     prdCommand
         .command("generate-arch")
-        .description("Generate CODING-STANDARDS.md and ARCHITECTURE-RULES.md from PRD")
+        .description("Generate coding-standards.md and architecture-rules.md from PRD")
         .argument("<prd-file>", "PRD filename")
         .action(async (prdFile) => {
         try {
@@ -267,7 +305,7 @@ export async function runCLI() {
     tasksCommand
         .command("generate")
         .description("Generate task breakdown from PRD")
-        .argument("<prd-file>", "PRD filename")
+        .argument("[prd-file]", "PRD filename (optional - shows selection if not provided)")
         .action(async (prdFile) => {
         try {
             const cmd = new TasksGenerateCommand(context);

package/dist/commands/base.d.ts

@@ -2,6 +2,8 @@
  * Base command infrastructure for AI-first command design
  * Every command returns structured guidance for AI agents
  */
+import { ConfigLoader } from "../lib/config-loader.js";
+import type { LLMProvider } from "../llm/base.js";
 export interface CommandContext {
     projectRoot: string;
 }
@@ -16,7 +18,46 @@ export interface CommandResult {
 }
 export declare abstract class BaseCommand {
     protected context: CommandContext;
+    protected llmProvider: LLMProvider | undefined;
+    protected configLoader: ConfigLoader;
     constructor(context: CommandContext);
+    /**
+     * Initialize LLM provider if configured
+     */
+    private initializeLLMProvider;
+    /**
+     * Check if LLM is available
+     */
+    protected isLLMAvailable(): boolean;
+    /**
+     * Get LLM guidance for a given context
+     * Keeps guidance concise (200 words max)
+     */
+    protected getLLMGuidance(context: {
+        task?: string;
+        status?: string;
+        files?: string[];
+        errors?: string[];
+        instructions?: string;
+    }): Promise<string>;
+    /**
+     * Get error analysis with LLM
+     * Groups errors by file and provides targeted fixes
+     */
+    protected getErrorAnalysis(errors: Array<{
+        file: string;
+        message: string;
+        line?: number;
+        code?: string;
+    }>): Promise<string>;
+    /**
+     * Group errors by file
+     */
+    private groupErrorsByFile;
+    /**
+     * Truncate text to maximum word count
+     */
+    private truncateToWords;
     abstract execute(...args: unknown[]): Promise<CommandResult>;
     /**
      * Format command result for terminal output

package/dist/commands/base.js

@@ -2,10 +2,151 @@
  * Base command infrastructure for AI-first command design
  * Every command returns structured guidance for AI agents
  */
+import { ConfigLoader } from "../lib/config-loader.js";
+import { Phase } from "../llm/base.js";
+import { ProviderFactory } from "../llm/factory.js";
 export class BaseCommand {
     context;
+    llmProvider;
+    configLoader;
     constructor(context) {
         this.context = context;
+        this.configLoader = new ConfigLoader(context.projectRoot);
+        this.initializeLLMProvider();
+    }
+    /**
+     * Initialize LLM provider if configured
+     */
+    initializeLLMProvider() {
+        try {
+            const config = this.configLoader.load();
+            // Check if AI is configured and enabled
+            if (config.ai && "enabled" in config.ai && config.ai.enabled) {
+                const aiConfig = config.ai;
+                const selector = ProviderFactory.createSelector(aiConfig);
+                if (selector.isConfigured()) {
+                    this.llmProvider = selector.getProvider(Phase.Planning);
+                }
+            }
+        }
+        catch {
+            // LLM provider initialization failed gracefully
+            this.llmProvider = void 0;
+        }
+    }
+    /**
+     * Check if LLM is available
+     */
+    isLLMAvailable() {
+        return this.llmProvider?.isConfigured() === true;
+    }
+    /**
+     * Get LLM guidance for a given context
+     * Keeps guidance concise (200 words max)
+     */
+    async getLLMGuidance(context) {
+        if (!this.isLLMAvailable() || !this.llmProvider) {
+            return "";
+        }
+        try {
+            const { task, status, files, errors, instructions } = context;
+            const prompt = `Generate concise guidance (max 200 words) for:
+${task ? `Task: ${task}` : ""}
+${status ? `Status: ${status}` : ""}
+${files && files.length > 0 ? `Files: ${files.slice(0, 5).join(", ")}` : ""}
+${errors && errors.length > 0 ? `Errors: ${errors.slice(0, 3).join("; ")}` : ""}
+${instructions ? `Instructions: ${instructions}` : ""}
+
+Provide:
+1. Key context to understand
+2. Critical files to check
+3. Common pitfalls to avoid
+4. Recommended approach
+
+Be concise and actionable.`;
+            const response = await this.llmProvider.generate([
+                {
+                    role: "system",
+                    content: "You are a helpful coding assistant providing concise guidance.",
+                },
+                { role: "user", content: prompt },
+            ], { maxTokens: 300, temperature: 0.5 });
+            return this.truncateToWords(response.content, 200);
+        }
+        catch {
+            // LLM call failed, return empty string
+            return "";
+        }
+    }
+    /**
+     * Get error analysis with LLM
+     * Groups errors by file and provides targeted fixes
+     */
+    async getErrorAnalysis(errors) {
+        if (!this.isLLMAvailable() || !this.llmProvider || errors.length === 0) {
+            return "";
+        }
+        try {
+            const groupedErrors = this.groupErrorsByFile(errors);
+            const prompt = `Analyze these errors and provide targeted fixes:
+
+${Object.entries(groupedErrors)
+                .map(([file, fileErrors]) => `\n${file}:\n${fileErrors.map((e) => `  ${e.message}`).join("\n")}`)
+                .join("\n")}
+
+Provide:
+1. Root cause analysis per file
+2. Specific fix suggestions
+3. File-by-file approach to resolve
+
+Be concise and actionable.`;
+            const response = await this.llmProvider.generate([
+                {
+                    role: "system",
+                    content: "You are a debugging assistant providing error analysis.",
+                },
+                { role: "user", content: prompt },
+            ], { maxTokens: 500, temperature: 0.3 });
+            return response.content;
+        }
+        catch {
+            return "";
+        }
+    }
+    /**
+     * Group errors by file
+     */
+    groupErrorsByFile(errors) {
+        const grouped = {};
+        for (const error of errors) {
+            if (!grouped[error.file]) {
+                grouped[error.file] = [];
+            }
+            const entry = {
+                message: error.message,
+            };
+            if (error.line !== undefined) {
+                entry.line = error.line;
+            }
+            if (error.code !== undefined) {
+                entry.code = error.code;
+            }
+            const array = grouped[error.file];
+            if (array) {
+                array.push(entry);
+            }
+        }
+        return grouped;
+    }
+    /**
+     * Truncate text to maximum word count
+     */
+    truncateToWords(text, maxWords) {
+        const words = text.split(/\s+/);
+        if (words.length <= maxWords) {
+            return text;
+        }
+        return words.slice(0, maxWords).join(" ");
     }
     /**
      * Format command result for terminal output

package/dist/commands/configure.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Configure AI command
+ * Configure LLM provider and per-phase model selection
+ */
+import { BaseCommand, type CommandResult } from "./base.js";
+export declare class ConfigureAICommand extends BaseCommand {
+    execute(options: {
+        provider?: string;
+        apiKey?: string;
+        model?: string;
+        planning?: string;
+        execution?: string;
+        analysis?: string;
+        planningProvider?: string;
+        planningApiKey?: string;
+        executionProvider?: string;
+        executionApiKey?: string;
+        analysisProvider?: string;
+        analysisApiKey?: string;
+        ollamaBaseUrl?: string;
+        openaiBaseUrl?: string;
+        enable?: boolean;
+        disable?: boolean;
+    }): Promise<CommandResult>;
+    private saveConfig;
+    private formatConfigOutput;
+    private generateNextSteps;
+    private getWarnings;
+}

package/dist/commands/configure.js

@@ -0,0 +1,187 @@
+/**
+ * Configure AI command
+ * Configure LLM provider and per-phase model selection
+ */
+import fs from "node:fs";
+import path from "node:path";
+import { ProviderFactory } from "../llm/factory.js";
+import { BaseCommand } from "./base.js";
+export class ConfigureAICommand extends BaseCommand {
+    async execute(options) {
+        const configPath = path.join(this.context.projectRoot, "taskflow.config.json");
+        if (!fs.existsSync(configPath)) {
+            return this.failure("Configuration file not found", [
+                `taskflow.config.json not found in ${this.context.projectRoot}`,
+                "Run 'taskflow init' to initialize the project first",
+            ], "Initialize taskflow with 'taskflow init'");
+        }
+        // Load existing config
+        const raw = fs.readFileSync(configPath, "utf-8");
+        const config = JSON.parse(raw);
+        // Check for enable/disable flags
+        if (options.disable) {
+            config.ai = config.ai || {};
+            config.ai.enabled = false;
+            this.saveConfig(config, configPath);
+            return this.success("AI configuration disabled", "AI features will not be used. Commands will show guidance only.", {
+                aiGuidance: "To re-enable, run: taskflow configure ai --enable\n" +
+                    "Or configure a provider: taskflow configure ai --provider anthropic --apiKey $${ANTHROPIC_API_KEY}",
+            });
+        }
+        if (options.enable) {
+            config.ai = config.ai || { enabled: true };
+            config.ai.enabled = true;
+            this.saveConfig(config, configPath);
+            return this.success("AI configuration enabled", "AI features will be used when properly configured with a provider.", {
+                aiGuidance: "Configure a provider: taskflow configure ai --provider anthropic --apiKey $${ANTHROPIC_API_KEY}",
+            });
+        }
+        // Ensure ai config exists
+        if (!config.ai) {
+            config.ai = {
+                enabled: true,
+            };
+        }
+        // Update basic configuration
+        if (options.provider) {
+            config.ai.provider = options.provider;
+            config.ai.enabled = true;
+        }
+        if (options.apiKey) {
+            config.ai.apiKey = options.apiKey;
+        }
+        if (options.model) {
+            config.ai.models = config.ai.models || { default: "gpt-4o-mini" };
+            config.ai.models.default = options.model;
+        }
+        // Update per-phase models
+        if (options.planning || options.execution || options.analysis) {
+            config.ai.models = config.ai.models || { default: "gpt-4o-mini" };
+            const models = config.ai.models;
+            if (options.planning) {
+                models.planning = options.planning;
+            }
+            if (options.execution) {
+                models.execution = options.execution;
+            }
+            if (options.analysis) {
+                models.analysis = options.analysis;
+            }
+        }
+        // Update per-phase providers
+        if (options.planningProvider ||
+            options.executionProvider ||
+            options.analysisProvider) {
+            if (options.planningProvider) {
+                config.ai.planningProvider = options.planningProvider;
+            }
+            if (options.executionProvider) {
+                config.ai.executionProvider = options.executionProvider;
+            }
+            if (options.analysisProvider) {
+                config.ai.analysisProvider = options.analysisProvider;
+            }
+        }
+        // Update per-phase API keys
+        if (options.planningApiKey ||
+            options.executionApiKey ||
+            options.analysisApiKey) {
+            if (options.planningApiKey) {
+                config.ai.planningApiKey = options.planningApiKey;
+            }
+            if (options.executionApiKey) {
+                config.ai.executionApiKey = options.executionApiKey;
+            }
+            if (options.analysisApiKey) {
+                config.ai.analysisApiKey = options.analysisApiKey;
+            }
+        }
+        // Update base URLs
+        if (options.ollamaBaseUrl) {
+            config.ai.ollamaBaseUrl = options.ollamaBaseUrl;
+        }
+        if (options.openaiBaseUrl) {
+            config.ai.openaiBaseUrl = options.openaiBaseUrl;
+        }
+        // Save config
+        this.saveConfig(config, configPath);
+        // Generate output
+        const output = this.formatConfigOutput(config.ai);
+        const nextSteps = this.generateNextSteps(config.ai);
+        return this.success("AI configuration updated successfully", nextSteps, {
+            aiGuidance: output,
+            warnings: this.getWarnings(config.ai),
+        });
+    }
+    saveConfig(config, configPath) {
+        fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+    }
+    formatConfigOutput(aiConfig) {
+        const lines = [];
+        lines.push("AI Configuration:");
+        lines.push("─".repeat(60));
+        lines.push(`Enabled: ${aiConfig.enabled ? "✓" : "✗"}`);
+        lines.push(`Provider: ${aiConfig.provider || "Not configured"}`);
+        lines.push(`API Key: ${aiConfig.apiKey ? "***configured***" : "Not configured"}`);
+        lines.push("");
+        lines.push("Models:");
+        const models = aiConfig.models;
+        lines.push(`  Default: ${models?.default || "Not configured"}`);
+        lines.push(`  Planning: ${models?.planning || "Uses default"}`);
+        lines.push(`  Execution: ${models?.execution || "Uses default"}`);
+        lines.push(`  Analysis: ${models?.analysis || "Uses default"}`);
+        lines.push("");
+        lines.push("Per-Phase Providers:");
+        lines.push(`  Planning: ${aiConfig.planningProvider || "Uses default provider"}`);
+        lines.push(`  Execution: ${aiConfig.executionProvider || "Uses default provider"}`);
+        lines.push(`  Analysis: ${aiConfig.analysisProvider || "Uses default provider"}`);
+        lines.push("");
+        lines.push("Base URLs:");
+        lines.push(`  Ollama: ${aiConfig.ollamaBaseUrl || "http://localhost:11434"}`);
+        lines.push(`  OpenAI: ${aiConfig.openaiBaseUrl || "https://api.openai.com/v1"}`);
+        return lines.join("\n");
+    }
+    generateNextSteps(aiConfig) {
+        if (!aiConfig.enabled) {
+            return "Enable AI features: taskflow configure ai --enable";
+        }
+        if (!aiConfig.provider || !aiConfig.apiKey) {
+            const availableProviders = ProviderFactory.getAvailableProviders();
+            const examples = [];
+            if (availableProviders.includes("anthropic")) {
+                examples.push("  taskflow configure ai --provider anthropic --apiKey $${ANTHROPIC_API_KEY}");
+            }
+            if (availableProviders.includes("openai-compatible")) {
+                examples.push("  taskflow configure ai --provider openai-compatible --apiKey $${OPENAI_API_KEY}");
+            }
+            if (availableProviders.includes("ollama")) {
+                examples.push("  taskflow configure ai --provider ollama");
+            }
+            return `Configure a provider:\n${examples.join("\n")}`;
+        }
+        const models = aiConfig.models;
+        if (!models?.planning && !models?.execution && !models?.analysis) {
+            return ("Configure per-phase models (optional):\n" +
+                "  taskflow configure ai --planning claude-opus-4 --execution gemini-pro-2.0 --analysis claude-sonnet-4-20250514");
+        }
+        return "AI is fully configured. Try running: taskflow tasks generate";
+    }
+    getWarnings(aiConfig) {
+        const warnings = [];
+        if (!aiConfig.enabled) {
+            warnings.push("AI is disabled. Commands will show guidance only.");
+        }
+        if (!aiConfig.provider) {
+            warnings.push("No provider configured. Set one with --provider option.");
+        }
+        if (aiConfig.provider &&
+            !aiConfig.apiKey &&
+            aiConfig.provider !== "ollama") {
+            warnings.push("API key not configured for this provider.");
+        }
+        if (aiConfig.provider === "ollama" && !aiConfig.ollamaBaseUrl) {
+            warnings.push("Ollama base URL not configured. Using default: http://localhost:11434");
+        }
+        return warnings;
+    }
+}

package/dist/commands/init.js

@@ -16,7 +16,21 @@ export class InitCommand extends BaseCommand {
                     configLoader.getConfigPath(),
             ], "Run 'taskflow status' to view your project state.");
         }
-        const finalProjectName = projectName || path.basename(this.context.projectRoot);
+        // Try to get project name from package.json, then use provided name, then fallback to directory name
+        let detectedProjectName;
+        const packageJsonPath = path.join(this.context.projectRoot, "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+            try {
+                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+                detectedProjectName = packageJson.name;
+            }
+            catch (_error) {
+                // If package.json is invalid, continue to fallback
+            }
+        }
+        const finalProjectName = projectName ||
+            detectedProjectName ||
+            path.basename(this.context.projectRoot);
         // Create default configuration
         const config = ConfigLoader.createDefaultConfig(finalProjectName);
         configLoader.save(config);
@@ -120,7 +134,7 @@ export class InitCommand extends BaseCommand {
                 "────────────────────",
                 "A PRD (Product Requirements Document) defines what you're building.",
                 "The AI will help you create it by:",
-                "1. Reading .taskflow/ref/PRD-GENERATOR.md for guidelines",
+                "1. Reading .taskflow/ref/prd-generator.md for guidelines",
                 "2. Gathering requirements through conversation",
                 "3. Creating a structured PRD document",
                 "",
@@ -128,15 +142,15 @@ export class InitCommand extends BaseCommand {
                 "that you can execute step-by-step.",
             ].join("\n"),
             contextFiles: [
-                ".taskflow/ref/AI-PROTOCOL.md - Core AI operating discipline",
-                ".taskflow/ref/PRD-GENERATOR.md - PRD creation guidelines",
-                ".taskflow/ref/TASK-GENERATOR.md - Task breakdown guidelines",
-                ".taskflow/ref/RETROSPECTIVE.md - Known error patterns",
+                ".taskflow/ref/ai-protocol.md - Core AI operating discipline",
+                ".taskflow/ref/prd-generator.md - PRD creation guidelines",
+                ".taskflow/ref/task-generator.md - Task breakdown guidelines",
+                ".taskflow/ref/retrospective.md - Known error patterns",
             ],
             warnings: [
                 "NEVER edit files in .taskflow/ or tasks/ directories directly",
                 "ALWAYS use taskflow commands for task management",
-                "Read AI-PROTOCOL.md before starting any task",
+                "Read ai-protocol.md before starting any task",
             ],
         });
     }

package/dist/commands/prd/create.d.ts

@@ -3,6 +3,6 @@
  */
 import { BaseCommand, type CommandResult } from "../base.js";
 export declare class PrdCreateCommand extends BaseCommand {
-    execute(featureName: string): Promise<CommandResult>;
+    execute(featureName: string, description?: string): Promise<CommandResult>;
     private generatePrdTemplate;
 }

package/dist/commands/prd/create.js

@@ -7,7 +7,7 @@ import { ConfigLoader } from "../../lib/config-loader.js";
 import { getRefFilePath, REF_FILES } from "../../lib/config-paths.js";
 import { BaseCommand } from "../base.js";
 export class PrdCreateCommand extends BaseCommand {
-    async execute(featureName) {
+    async execute(featureName, description) {
         const configLoader = new ConfigLoader(this.context.projectRoot);
         const paths = configLoader.getPaths();
         // Validate feature name
@@ -44,24 +44,39 @@ export class PrdCreateCommand extends BaseCommand {
             ].join("\n"));
         }
         // Create PRD template
-        const prdTemplate = this.generatePrdTemplate(featureName);
+        const prdTemplate = this.generatePrdTemplate(featureName, description);
         // Write PRD file
         fs.writeFileSync(prdFilePath, prdTemplate, "utf-8");
-        return this.success([
+        const initialRequirements = description
+            ? [
+                "",
+                "INITIAL REQUIREMENTS PROVIDED:",
+                "───────────────────────────────",
+                description,
+                "",
+                "Use this as a starting point for the PRD.",
+            ]
+            : [];
+        const nextStepsBase = [
             `✓ PRD created: ${prdFilename}`,
             `✓ Location: ${prdFilePath}`,
             "",
             "NEXT:",
             "─".repeat(60),
             "1. Fill out the PRD document with feature requirements",
-            "2. Generate coding standards and architecture rules",
-            "3. Generate task breakdown from PRD",
-        ].join("\n"), [
+        ];
+        if (description) {
+            nextStepsBase.push("   (Initial requirements already provided)");
+        }
+        nextStepsBase.push("2. Generate coding standards and architecture rules");
+        nextStepsBase.push("3. Generate task breakdown from PRD");
+        return this.success(nextStepsBase.join("\n"), [
             "1. Edit the PRD file to add feature details:",
             `   Open: ${prdFilePath}`,
+            ...initialRequirements,
             "",
             "2. Use AI to help fill out the PRD:",
-            "   - Read .taskflow/ref/PRD-GENERATOR.md for guidance",
+            "   - Read .taskflow/ref/prd-generator.md for guidance",
             "   - Gather requirements through conversation",
             "   - Document goals, user stories, and acceptance criteria",
             "",
@@ -109,7 +124,7 @@ export class PrdCreateCommand extends BaseCommand {
                 "",
                 "IMPORTANT:",
                 "───────────",
-                "Do NOT create CODING-STANDARDS.md or ARCHITECTURE-RULES.md yet.",
+                "Do NOT create coding-standards.md or architecture-rules.md yet.",
                 "Those will be generated in the next step using:",
                 `  taskflow prd generate-arch ${prdFilename}`,
                 "",
@@ -127,14 +142,17 @@ export class PrdCreateCommand extends BaseCommand {
                 `${getRefFilePath(paths.refDir, REF_FILES.aiProtocol)} - Core AI operating discipline`,
             ],
             warnings: [
-                "DO NOT skip the PRD-GENERATOR.md - it contains critical guidance",
+                "DO NOT skip the prd-generator.md - it contains critical guidance",
                 "DO NOT guess at requirements - ask the user for clarification",
                 "DO NOT create coding standards yet - wait for generate-arch command",
                 "DO ensure PRD is complete before generating tasks",
             ],
         });
     }
-    generatePrdTemplate(featureName) {
+    generatePrdTemplate(featureName, description) {
+        const problemStatement = description
+            ? description.trim()
+            : "<!-- What problem does this feature solve? -->";
         return `# PRD: ${featureName}
 
 **Created:** ${new Date().toISOString().split("T")[0]}
@@ -146,7 +164,7 @@ export class PrdCreateCommand extends BaseCommand {
 ## 1. Overview
 
 ### Problem Statement
-<!-- What problem does this feature solve? -->
+${problemStatement}
 
 ### Goals
 <!-- What are we trying to achieve? -->