task-o-matic 0.0.8 → 0.0.9

package/README.md

@@ -17,6 +17,7 @@ AI-powered task management for CLI, TUI, and web applications. Parse PRDs, enhan
 - 📊 **Smart Breakdown**: AI-powered task decomposition into subtasks
 - 🌊 **Real-time Streaming**: Watch AI responses generate live with streaming output
 - 📊 **Model Benchmarking**: Compare performance and quality across different AI models
+- 🏁 **Workflow Benchmarking**: Test complete workflows across multiple models and compare results
 - 🏠 **Single-Project Focus**: Self-contained within each project directory
 - 💻 **Framework-Agnostic**: Easily integrate into TUI, web apps, or any Node.js project
 
@@ -267,6 +268,11 @@ import type {
   RefinePRDResult,
   GenerateTasksResult,
   SplitTasksResult,
+  // Benchmark types
+  WorkflowBenchmarkInput,
+  WorkflowBenchmarkResult,
+  BenchmarkConfig,
+  BenchmarkResult,
 } from "task-o-matic";
 ```
 
@@ -350,6 +356,9 @@ task-o-matic workflow
 
 # With streaming AI output
 task-o-matic workflow --stream
+
+# Want to test multiple AI models? Try workflow benchmarking:
+task-o-matic benchmark workflow --models "openai:gpt-4o,anthropic:claude-3-5-sonnet"
 ```
 
 **The workflow will guide you through:**
@@ -389,6 +398,7 @@ task-o-matic workflow --stream
 - [AI Integration](docs/ai-integration.md) - AI providers and prompt engineering
 - [Project Initialization](docs/projects.md) - Project setup and bootstrapping
 - [Streaming Output](docs/streaming.md) - Real-time AI streaming capabilities
+- [Model Benchmarking](docs/benchmarking.md) - Compare AI models and workflow performance
 
 ## 🎯 Common Workflows
 
@@ -458,6 +468,55 @@ task-o-matic benchmark compare <run-id>
 task-o-matic benchmark show <run-id>
 ```
 
+### Workflow 3b: Complete Workflow Benchmarking
+
+Test entire workflows across multiple AI models and automatically set up your project with the best results.
+
+```bash
+# 1. Basic workflow benchmark with interactive setup
+task-o-matic benchmark workflow \
+  --models "openai:gpt-4o,anthropic:claude-3-5-sonnet,openrouter:qwen/qwen-2.5-72b-instruct" \
+  --concurrency 2 \
+  --delay 1000
+
+# 2. Automated workflow benchmark
+task-o-matic benchmark workflow \
+  --models "openai:gpt-4o,anthropic:claude-3-5-sonnet" \
+  --project-name "my-saas-app" \
+  --project-description "Team collaboration platform with real-time chat" \
+  --init-method ai \
+  --prd-method ai \
+  --auto-accept \
+  --skip-all
+
+# 3. Benchmark with specific workflow options
+task-o-matic benchmark workflow \
+  --models "openai:gpt-4o,anthropic:claude-3-5-sonnet" \
+  --project-name "e-commerce-app" \
+  --init-method custom \
+  --frontend next \
+  --backend hono \
+  --database postgres \
+  --prd-method ai \
+  --prd-description "Modern e-commerce platform with AI recommendations" \
+  --refine-feedback "Focus on scalability and security" \
+  --split-all
+
+# Results include:
+# - Comprehensive comparison table (duration, tasks, PRD size, costs)
+# - Detailed per-model breakdowns with timing and token metrics
+# - Interactive selection to choose the best model
+# - Automatic project setup with selected model's results
+```
+
+**Workflow Benchmark Features:**
+
+- **Two-Phase Execution**: Interactive question collection, then parallel execution
+- **Complete Workflow**: Project init → PRD creation → task generation → task splitting
+- **Comprehensive Metrics**: Performance, cost, quality, and output comparison
+- **Model Selection**: Choose the best performer and auto-setup your project
+- **Identical Conditions**: All models receive the same inputs for fair comparison
+
 ### Workflow 4: Project Bootstrapping
 
 ```bash
@@ -477,6 +536,130 @@ task-o-matic init bootstrap my-app
 task-o-matic tasks create --title "Set up development environment" --ai-enhance --stream
 ```
 
+## 📊 Benchmarking Commands
+
+### Basic Model Benchmarking
+
+Compare different AI models on specific operations:
+
+```bash
+# Benchmark PRD parsing across multiple models
+task-o-matic benchmark run prd-parse \
+  --file requirements.md \
+  --models "openai:gpt-4o,anthropic:claude-3-5-sonnet,openrouter:qwen/qwen-2.5-72b-instruct" \
+  --concurrency 3 \
+  --delay 1000
+
+# Benchmark task splitting
+task-o-matic benchmark run task-breakdown \
+  --task-id <task-id> \
+  --models "openai:gpt-4o,anthropic:claude-3-5-sonnet" \
+  --concurrency 2
+
+# View benchmark results
+task-o-matic benchmark list
+task-o-matic benchmark show <run-id>
+task-o-matic benchmark compare <run-id>
+```
+
+### Complete Workflow Benchmarking
+
+Test entire project workflows across multiple AI models:
+
+```bash
+# Interactive workflow benchmark (recommended)
+task-o-matic benchmark workflow \
+  --models "openai:gpt-4o,anthropic:claude-3-5-sonnet,openrouter:qwen/qwen-2.5-72b-instruct"
+```
+
+**What happens:**
+1. **Phase 1**: You answer workflow questions once (project setup, PRD creation, etc.)
+2. **Phase 2**: All models execute the identical workflow in parallel
+3. **Results**: Comprehensive comparison table with metrics and model selection
+
+**Full automation example:**
+
+```bash
+task-o-matic benchmark workflow \
+  --models "openai:gpt-4o,anthropic:claude-3-5-sonnet" \
+  --project-name "my-saas-platform" \
+  --project-description "Team collaboration platform with real-time messaging" \
+  --init-method ai \
+  --prd-method ai \
+  --auto-accept \
+  --refine-feedback "Add more technical details and security considerations" \
+  --generate-instructions "Focus on MVP features and break into small tasks" \
+  --split-all \
+  --concurrency 2 \
+  --delay 2000
+```
+
+**Output includes:**
+
+```
+📊 Workflow Benchmark Results
+
+Model                                    | Duration   | Tasks | PRD Size   | Steps | Cost      
+---------------------------------------- | ---------- | ----- | ---------- | ----- | ----------
+openai:gpt-4o                           | 45234ms    | 12    | 2843 chars | 5/5   | $0.023400
+anthropic:claude-3-5-sonnet             | 42156ms    | 15    | 3021 chars | 5/5   | $0.019800
+
+🔍 Detailed Comparison
+
+[1] openai:gpt-4o
+Duration: 45234ms
+Steps Completed: 5/5
+  Init: 2341ms
+  PRD Generation: 12456ms
+  Task Generation: 8234ms
+  Task Splitting: 3421ms
+Tasks Created: 12
+PRD Size: 2843 characters
+Tokens: 4521 (Prompt: 2341, Completion: 2180)
+Cost: $0.023400
+
+🎯 Model Selection
+Would you like to select a model and set up your project with its results? (y/N)
+```
+
+### Benchmark Options
+
+All benchmark commands support:
+
+- `--models <list>`: Comma-separated model list (required)
+- `--concurrency <number>`: Max parallel requests (default: 3)
+- `--delay <ms>`: Delay between requests (default: 1000ms)
+
+**Model format:** `provider:model[:reasoning=<tokens>]`
+
+**Examples:**
+- `openai:gpt-4o`
+- `anthropic:claude-3-5-sonnet`
+- `openrouter:anthropic/claude-3.5-sonnet`
+- `openrouter:openai/o1-preview:reasoning=50000`
+
+### Workflow Benchmark Inheritance
+
+The `benchmark workflow` command supports ALL workflow command options:
+
+```bash
+# All these workflow options work in benchmarks:
+--project-name, --init-method, --project-description
+--frontend, --backend, --database, --auth/--no-auth
+--prd-method, --prd-file, --prd-description, --prd-content
+--refine-feedback, --generate-instructions
+--split-tasks, --split-all, --split-instructions
+--skip-init, --skip-prd, --skip-refine, --skip-generate, --skip-split
+--stream, --auto-accept, --config-file
+```
+
+This allows you to:
+- **Pre-configure workflow steps** via command-line options
+- **Skip interactive questions** for automated benchmarking
+- **Compare identical workflows** across different models
+- **Test specific scenarios** (e.g., only AI vs only custom stack)
+```
+
 ## 🔧 Environment Variables
 
 ```bash
@@ -508,6 +691,23 @@ AI_TEMPERATURE=0.7
 - **PRD Parsing**: `claude-3.5-sonnet` or `gpt-4`
 - **Task Enhancement**: `claude-3-haiku` or `gpt-3.5-turbo`
 - **Task Breakdown**: `claude-3.5-sonnet` for complex tasks
+- **Workflow Benchmarking**: Test 2-3 models to find optimal performance for your use case
+
+### Choosing the Right Model
+
+Not sure which model to use? Try workflow benchmarking:
+
+```bash
+# Test your specific workflow across multiple models
+task-o-matic benchmark workflow \
+  --models "openai:gpt-4o,anthropic:claude-3-5-sonnet,openrouter:qwen/qwen-2.5-72b-instruct" \
+  --project-description "Your project description here"
+
+# The benchmark will show you:
+# - Performance (speed, tokens, cost)
+# - Quality (tasks created, PRD completeness)  
+# - Best model for your specific needs
+```
 
 ## 📁 Storage Structure
 

package/dist/commands/benchmark.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"benchmark.d.ts","sourceRoot":"","sources":["../../src/commands/benchmark.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,eAAO,MAAM,gBAAgB,SAE5B,CAAC"}
+{"version":3,"file":"benchmark.d.ts","sourceRoot":"","sources":["../../src/commands/benchmark.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,eAAO,MAAM,gBAAgB,SAE5B,CAAC"}

package/dist/commands/benchmark.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -7,6 +40,7 @@ exports.benchmarkCommand = void 0;
 const commander_1 = require("commander");
 const chalk_1 = __importDefault(require("chalk"));
 const benchmark_1 = require("../services/benchmark");
+const workflow_prompts_1 = require("../utils/workflow-prompts");
 exports.benchmarkCommand = new commander_1.Command("benchmark").description("Run and manage AI benchmarks");
 // Helper to parse model string
 // Format: provider:model[:reasoning=<tokens>]
@@ -225,3 +259,311 @@ exports.benchmarkCommand
     }));
     console.table(table);
 });
+exports.benchmarkCommand
+    .command("workflow")
+    .description("Benchmark complete workflow execution across multiple models")
+    .requiredOption("--models <list>", "Comma-separated list of models (provider:model[:reasoning=<tokens>])")
+    .option("--concurrency <number>", "Max concurrent requests", "3")
+    .option("--delay <number>", "Delay between requests in ms", "1000")
+    // Inherit all workflow command options
+    .option("--stream", "Show streaming AI output")
+    .option("--skip-all", "Skip all optional steps (use defaults)")
+    .option("--auto-accept", "Auto-accept all AI suggestions")
+    .option("--config-file <path>", "Load workflow options from JSON file")
+    // Step 1: Initialize
+    .option("--skip-init", "Skip initialization step")
+    .option("--project-name <name>", "Project name")
+    .option("--init-method <method>", "Initialization method: quick, custom, ai")
+    .option("--project-description <desc>", "Project description for AI-assisted init")
+    .option("--frontend <framework>", "Frontend framework")
+    .option("--backend <framework>", "Backend framework")
+    .option("--database <db>", "Database choice")
+    .option("--auth", "Include authentication")
+    .option("--no-auth", "Exclude authentication")
+    .option("--bootstrap", "Bootstrap with Better-T-Stack")
+    .option("--no-bootstrap", "Skip bootstrapping")
+    // Step 2: Define PRD
+    .option("--skip-prd", "Skip PRD definition")
+    .option("--prd-method <method>", "PRD method: upload, manual, ai, skip")
+    .option("--prd-file <path>", "Path to existing PRD file")
+    .option("--prd-description <desc>", "Product description for AI-assisted PRD")
+    .option("--prd-content <content>", "Direct PRD content")
+    // Step 3: Refine PRD
+    .option("--skip-refine", "Skip PRD refinement")
+    .option("--refine-method <method>", "Refinement method: manual, ai, skip")
+    .option("--refine-feedback <feedback>", "Feedback for AI refinement")
+    // Step 4: Generate Tasks
+    .option("--skip-generate", "Skip task generation")
+    .option("--generate-method <method>", "Generation method: standard, ai")
+    .option("--generate-instructions <instructions>", "Custom task generation instructions")
+    // Step 5: Split Tasks
+    .option("--skip-split", "Skip task splitting")
+    .option("--split-tasks <ids>", "Comma-separated task IDs to split")
+    .option("--split-all", "Split all tasks")
+    .option("--split-method <method>", "Split method: interactive, standard, custom")
+    .option("--split-instructions <instructions>", "Custom split instructions")
+    .action(async (options) => {
+    try {
+        await runWorkflowBenchmark(options);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red("Workflow benchmark failed:"), error.message);
+        process.exit(1);
+    }
+});
+/**
+ * Execute workflow benchmark across multiple models
+ */
+async function runWorkflowBenchmark(options) {
+    console.log(chalk_1.default.blue.bold("\n🚀 Task-O-Matic Workflow Benchmark\n"));
+    // Parse models
+    const modelStrings = options.models.split(",");
+    const models = modelStrings.map((s) => parseModelString(s.trim()));
+    const config = {
+        models,
+        concurrency: parseInt(options.concurrency, 10),
+        delay: parseInt(options.delay, 10),
+    };
+    console.log(chalk_1.default.dim(`Models: ${models.length}, Concurrency: ${config.concurrency}, Delay: ${config.delay}ms`));
+    // Phase 1: Collect user responses interactively
+    console.log(chalk_1.default.blue.bold("\n📋 Phase 1: Collecting Workflow Responses\n"));
+    console.log(chalk_1.default.gray("Please answer the following questions. Your responses will be used for all models."));
+    const collectedResponses = await collectWorkflowResponses(options);
+    // Phase 2: Execute workflow on all models
+    console.log(chalk_1.default.blue.bold("\n⚡ Phase 2: Executing Workflows\n"));
+    console.log(chalk_1.default.gray(`Running workflow on ${models.length} models...\n`));
+    // Prepare workflow input
+    const workflowInput = {
+        collectedResponses,
+        workflowOptions: options,
+        tempDirBase: "/tmp",
+    };
+    // Prepare dashboard
+    console.log(chalk_1.default.bold("Benchmark Progress:"));
+    const modelMap = new Map();
+    const modelStatus = new Map();
+    // Print initial lines and map indices
+    models.forEach((m, i) => {
+        const id = `${m.provider}:${m.model}${m.reasoningTokens ? `:reasoning=${m.reasoningTokens}` : ""}`;
+        modelMap.set(id, i);
+        modelStatus.set(id, "Waiting...");
+        console.log(chalk_1.default.dim(`- ${id}: Waiting...`));
+    });
+    const totalModels = models.length;
+    const run = await benchmark_1.benchmarkService.runBenchmark("workflow-full", workflowInput, config, (event) => {
+        const index = modelMap.get(event.modelId);
+        if (index === undefined)
+            return;
+        // Update status in memory
+        let statusStr = "";
+        if (event.type === "start") {
+            statusStr = chalk_1.default.yellow("Starting...");
+        }
+        else if (event.type === "progress") {
+            statusStr = chalk_1.default.blue("Running workflow...");
+        }
+        else if (event.type === "complete") {
+            statusStr = chalk_1.default.green(`Completed (${event.duration}ms)`);
+        }
+        else if (event.type === "error") {
+            statusStr = chalk_1.default.red(`Failed: ${event.error}`);
+        }
+        modelStatus.set(event.modelId, statusStr);
+        // Update display
+        const up = totalModels - index;
+        process.stdout.write(`\x1B[${up}A`); // Move up
+        process.stdout.write(`\x1B[2K`); // Clear line
+        process.stdout.write(`- ${chalk_1.default.bold(event.modelId)}: ${statusStr}\r`);
+        process.stdout.write(`\x1B[${up}B`); // Move down
+    });
+    console.log(chalk_1.default.green(`\n✅ Workflow benchmark completed! Run ID: ${run.id}`));
+    // Display results
+    await displayWorkflowBenchmarkResults(run);
+    // Optional: Let user select a model for project setup
+    await promptForModelSelection(run, collectedResponses);
+}
+/**
+ * Collect workflow responses from user interactively
+ */
+async function collectWorkflowResponses(options) {
+    // Use provided options or prompt user
+    const getOrPrompt = async (preAnswered, promptFn, skipCondition = false) => {
+        if (skipCondition) {
+            throw new Error("Step skipped");
+        }
+        if (preAnswered !== undefined) {
+            return preAnswered;
+        }
+        return promptFn();
+    };
+    // Project setup questions
+    const projectName = await getOrPrompt(options.projectName, () => (0, workflow_prompts_1.textInputPrompt)("What is the name of your project?", "my-benchmark-project"));
+    const initMethod = await getOrPrompt(options.initMethod, () => (0, workflow_prompts_1.selectPrompt)("How would you like to configure your project stack?", [
+        { name: "Quick start (recommended defaults)", value: "quick" },
+        { name: "Custom configuration", value: "custom" },
+        { name: "AI-assisted (describe your project)", value: "ai" },
+    ]));
+    let projectDescription;
+    if (initMethod === "ai") {
+        projectDescription = await getOrPrompt(options.projectDescription, () => (0, workflow_prompts_1.textInputPrompt)("Describe your project (e.g., 'A SaaS app for team collaboration'):"));
+    }
+    // Stack configuration (for custom method)
+    let stackConfig = {};
+    if (initMethod === "custom") {
+        stackConfig.frontend = await getOrPrompt(options.frontend, () => (0, workflow_prompts_1.selectPrompt)("Frontend framework:", ["next", "react", "vue", "svelte"]));
+        stackConfig.backend = await getOrPrompt(options.backend, () => (0, workflow_prompts_1.selectPrompt)("Backend framework:", ["hono", "express", "fastify", "nestjs"]));
+        stackConfig.database = await getOrPrompt(options.database, () => (0, workflow_prompts_1.selectPrompt)("Database:", ["sqlite", "postgres", "mysql", "mongodb"]));
+        stackConfig.auth = await getOrPrompt(options.auth, () => (0, workflow_prompts_1.confirmPrompt)("Include authentication?", true));
+    }
+    // PRD questions
+    const prdMethod = await getOrPrompt(options.prdMethod, () => (0, workflow_prompts_1.selectPrompt)("How would you like to define your PRD?", [
+        { name: "AI-assisted creation", value: "ai" },
+        { name: "Upload existing file", value: "upload" },
+        { name: "Write manually", value: "manual" },
+        { name: "Skip PRD", value: "skip" },
+    ]));
+    let prdDescription;
+    let prdFile;
+    let prdContent;
+    if (prdMethod === "ai") {
+        prdDescription = await getOrPrompt(options.prdDescription, () => (0, workflow_prompts_1.textInputPrompt)("Describe your product in detail:"));
+    }
+    else if (prdMethod === "upload") {
+        prdFile = await getOrPrompt(options.prdFile, () => (0, workflow_prompts_1.textInputPrompt)("Path to PRD file:"));
+    }
+    else if (prdMethod === "manual") {
+        prdContent = await getOrPrompt(options.prdContent, () => (0, workflow_prompts_1.editorPrompt)("Write your PRD:", "# Product Requirements Document\n\n## Overview\n\n## Features\n\n"));
+    }
+    // Additional workflow questions
+    const refinePrd = !options.skipRefine && prdMethod !== "skip" ?
+        await (0, workflow_prompts_1.confirmPrompt)("Refine PRD with AI feedback?", false) : false;
+    let refineFeedback;
+    if (refinePrd) {
+        refineFeedback = await getOrPrompt(options.refineFeedback, () => (0, workflow_prompts_1.textInputPrompt)("What feedback should be used for PRD refinement?", "Add more technical details and clarify requirements"));
+    }
+    const generateTasks = !options.skipGenerate && prdMethod !== "skip";
+    const customInstructions = options.generateInstructions ||
+        (generateTasks ? await (0, workflow_prompts_1.textInputPrompt)("Custom task generation instructions (optional):", "") : undefined);
+    const splitTasks = !options.skipSplit && generateTasks ?
+        await (0, workflow_prompts_1.confirmPrompt)("Split complex tasks into subtasks?", true) : false;
+    const splitInstructions = splitTasks && options.splitInstructions ?
+        options.splitInstructions :
+        (splitTasks ? await (0, workflow_prompts_1.textInputPrompt)("Custom splitting instructions (optional):", "Break into 2-4 hour chunks") : undefined);
+    return {
+        projectName,
+        initMethod: initMethod,
+        projectDescription,
+        stackConfig,
+        prdMethod: prdMethod,
+        prdContent,
+        prdDescription,
+        prdFile,
+        refinePrd,
+        refineFeedback,
+        generateTasks,
+        customInstructions,
+        splitTasks,
+        splitInstructions,
+    };
+}
+/**
+ * Display workflow benchmark results in a comprehensive format
+ */
+async function displayWorkflowBenchmarkResults(run) {
+    console.log(chalk_1.default.bold("\n📊 Workflow Benchmark Results\n"));
+    // Summary table
+    console.log(chalk_1.default.bold(`${"Model".padEnd(40)} | ${"Duration".padEnd(10)} | ${"Tasks".padEnd(8)} | ${"PRD Size".padEnd(10)} | ${"Steps".padEnd(8)} | ${"Cost".padEnd(10)}`));
+    console.log("-".repeat(130));
+    run.results.forEach((r) => {
+        const duration = `${r.duration}ms`.padEnd(10);
+        const taskCount = r.output?.stats?.totalTasks || 0;
+        const tasks = `${taskCount}`.padEnd(8);
+        const prdSize = r.output?.stats?.prdSize ? `${r.output.stats.prdSize} chars`.padEnd(10) : "-".padEnd(10);
+        const steps = r.output?.stats ? `${r.output.stats.successfulSteps}/${r.output.stats.totalSteps}`.padEnd(8) : "-".padEnd(8);
+        const cost = r.cost ? `$${r.cost.toFixed(6)}`.padEnd(10) : "-".padEnd(10);
+        console.log(`${r.modelId.padEnd(40)} | ${duration} | ${tasks} | ${prdSize} | ${steps} | ${cost}`);
+        if (r.error) {
+            console.log(chalk_1.default.red(`  Error: ${r.error}`));
+        }
+    });
+    // Detailed comparison
+    console.log(chalk_1.default.bold("\n🔍 Detailed Comparison\n"));
+    run.results.forEach((r, index) => {
+        if (r.error)
+            return;
+        console.log(chalk_1.default.cyan(`\n[${index + 1}] ${r.modelId}`));
+        console.log(`Duration: ${r.duration}ms`);
+        if (r.output?.stats) {
+            const stats = r.output.stats;
+            console.log(`Steps Completed: ${stats.successfulSteps}/${stats.totalSteps}`);
+            if (stats.initDuration)
+                console.log(`  Init: ${stats.initDuration}ms`);
+            if (stats.prdGenerationDuration)
+                console.log(`  PRD Generation: ${stats.prdGenerationDuration}ms`);
+            if (stats.taskGenerationDuration)
+                console.log(`  Task Generation: ${stats.taskGenerationDuration}ms`);
+            if (stats.taskSplittingDuration)
+                console.log(`  Task Splitting: ${stats.taskSplittingDuration}ms`);
+            console.log(`Tasks Created: ${stats.totalTasks}`);
+            if (stats.tasksWithSubtasks)
+                console.log(`Tasks with Subtasks: ${stats.tasksWithSubtasks}`);
+            if (stats.prdSize)
+                console.log(`PRD Size: ${stats.prdSize} characters`);
+        }
+        if (r.tokenUsage) {
+            console.log(`Tokens: ${r.tokenUsage.total} (Prompt: ${r.tokenUsage.prompt}, Completion: ${r.tokenUsage.completion})`);
+        }
+        if (r.cost) {
+            console.log(`Cost: $${r.cost.toFixed(6)}`);
+        }
+    });
+}
+/**
+ * Allow user to select a model and set up project with its results
+ */
+async function promptForModelSelection(run, responses) {
+    const successfulResults = run.results.filter((r) => !r.error);
+    if (successfulResults.length === 0) {
+        console.log(chalk_1.default.yellow("\n⚠️  No successful results to select from."));
+        return;
+    }
+    if (successfulResults.length === 1) {
+        console.log(chalk_1.default.green(`\n✅ Only one successful result from ${successfulResults[0].modelId}`));
+        return;
+    }
+    console.log(chalk_1.default.blue.bold("\n🎯 Model Selection\n"));
+    const shouldSelect = await (0, workflow_prompts_1.confirmPrompt)("Would you like to select a model and set up your project with its results?", false);
+    if (!shouldSelect) {
+        console.log(chalk_1.default.gray("Benchmark complete. Results have been saved."));
+        return;
+    }
+    const choices = successfulResults.map((r, index) => ({
+        name: `${r.modelId} (${r.duration}ms, ${r.output?.stats?.totalTasks || 0} tasks, $${r.cost?.toFixed(6) || 'unknown'})`,
+        value: index,
+    }));
+    const selectedIndex = await (0, workflow_prompts_1.selectPrompt)("Select the model whose results you want to use for your project:", choices);
+    const selectedResult = successfulResults[selectedIndex];
+    console.log(chalk_1.default.green(`\n✅ Selected: ${selectedResult.modelId}`));
+    console.log(chalk_1.default.gray("Setting up your project with the selected results..."));
+    // Get target directory
+    const targetDir = await (0, workflow_prompts_1.textInputPrompt)("Enter target directory for your project:", `./${responses.projectName}`);
+    try {
+        console.log(chalk_1.default.cyan("\n🔧 Applying benchmark results..."));
+        const { workflowBenchmarkService } = await Promise.resolve().then(() => __importStar(require("../services/workflow-benchmark")));
+        const result = await workflowBenchmarkService.applyBenchmarkResult(selectedResult, targetDir, responses);
+        if (result.success) {
+            console.log(chalk_1.default.green(`\n✅ ${result.message}`));
+            console.log(chalk_1.default.cyan("\nNext steps:"));
+            console.log(chalk_1.default.gray(`  • Navigate to: cd ${targetDir}`));
+            console.log(chalk_1.default.gray("  • Review your tasks: task-o-matic tasks list"));
+            console.log(chalk_1.default.gray("  • View task tree: task-o-matic tasks tree"));
+            console.log(chalk_1.default.gray("  • Start working: task-o-matic tasks next"));
+        }
+        else {
+            console.log(chalk_1.default.red(`\n❌ ${result.message}`));
+        }
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`\n❌ Failed to apply results: ${error instanceof Error ? error.message : String(error)}`));
+    }
+}

package/dist/commands/tasks/execute-loop.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const executeLoopCommand: Command;
+//# sourceMappingURL=execute-loop.d.ts.map

package/dist/commands/tasks/execute-loop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"execute-loop.d.ts","sourceRoot":"","sources":["../../../src/commands/tasks/execute-loop.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiDpC,eAAO,MAAM,kBAAkB,SAoI3B,CAAC"}