task-o-matic 0.0.35 → 0.1.0

package/README.md

@@ -1,864 +1,792 @@
-# 🚀 task-o-matic
+# task-o-matic
 
-AI-powered task management for CLI, TUI, and web applications. Parse PRDs, enhance tasks with AI, and integrate task management into your applications using local file storage only. No backend connectivity required.
+AI-powered task management CLI for single projects. Parse PRDs, enhance tasks with AI, and manage your development workflow from the command line.
 
-## ✨ Features
+## Overview
 
-- 🤖 **AI-Powered**: Parse PRDs and enhance tasks using multiple AI providers
-- 🎭 **Interactive Workflow**: Guided setup from project init to task generation with AI assistance
-- ❓ **PRD Question/Refine**: AI generates clarifying questions and can answer them automatically
-- 🧠 **AI Reasoning Support**: Enable advanced reasoning for better PRD refinement
-- 📦 **Multi-Purpose Package**: Use as CLI tool, library, or MCP server
-- 📁 **Project-Local Storage**: All data stored locally in `.task-o-matic/` directory
-- 🎯 **Task Management**: Full CRUD operations with AI enhancement
-- 📋 **PRD Processing**: Convert Product Requirements Documents into actionable tasks
-- 🏗️ **Project Bootstrapping**: Better-T-Stack integration for new projects
-- 🔧 **Multi-Provider AI**: Support for OpenAI, Anthropic, OpenRouter, and custom providers
-- 📊 **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
+`task-o-matic` is the command-line interface for the Task-O-Matic system. It provides a complete set of commands for managing tasks, processing PRDs, and automating project workflows with AI assistance.
 
-## 📦 Installation
+## Installation
 
-### As a CLI Tool
+### Global Installation
 
 ```bash
-# Install globally
 npm install -g task-o-matic
+```
+
+### Using npx
 
-# Or use with npx
+```bash
 npx task-o-matic init
 ```
 
-### As a Library (for TUI/Web Apps)
+## Quick Start
+
+### Initialize Your Project
 
 ```bash
-# Install in your project
-npm install task-o-matic
+# Navigate to your project directory
+cd /path/to/your/project
+
+# Initialize task-o-matic
+task-o-matic init init --project-name my-app
+
+# Configure AI provider
+task-o-matic config set-ai-provider anthropic claude-3-5-sonnet
+
+# Create your first task
+task-o-matic tasks create --title "Implement user authentication" --ai-enhance
 ```
 
-### For Development
+### Interactive Workflow (Recommended)
 
 ```bash
-# Clone and install dependencies
-git clone https://github.com/DimitriGilbert/task-o-matic.git
-cd task-o-matic
-npm install
-npm run build
+# Start the interactive workflow with streaming
+task-o-matic workflow --stream
 ```
 
-## 🏗️ Architecture & Mindset
+The workflow will guide you through:
+1. Project initialization
+2. PRD creation
+3. PRD refinement with AI questions
+4. Task generation
+5. Task splitting
+
+## Commands
+
+### Initialization Commands
+
+#### `task-o-matic init init`
+
+Initialize a new project with task-o-matic.
+
+```bash
+# Basic initialization
+task-o-matic init init
 
-### Package Structure
+# Initialize with project name
+task-o-matic init init --project-name my-app
 
+# Initialize with AI configuration
+task-o-matic init init --project-name my-app --ai-provider openrouter --ai-model anthropic/claude-3.5-sonnet --ai-key your-api-key
+
+# Initialize without bootstrapping
+task-o-matic init init --no-bootstrap
 ```
-task-o-matic/
-├── dist/              # Compiled output (published)
-│   ├── lib/           # Library entry point + core exports
-│   ├── cli/           # CLI binary
-│   ├── services/      # Business logic layer (WorkflowService, PRDService, TaskService)
-│   ├── commands/      # CLI commands
-│   ├── mcp/           # MCP server
-│   └── types/         # TypeScript definitions
-├── src/
-│   ├── lib/           # Core library (Storage, Config, AI, etc.)
-│   │   └── index.ts   # Main library exports
-│   ├── services/      # WorkflowService, PRDService, TaskService (framework-agnostic)
-│   ├── cli/           # CLI-specific logic
-│   │   └── bin.ts     # CLI binary entry point
-│   ├── commands/      # Commander.js command implementations
-│   ├── mcp/           # MCP server implementation
-│   ├── prompts/       # AI prompt templates
-│   ├── types/         # TypeScript type definitions
-│   └── utils/         # Shared utilities
-└── docs/              # Documentation
+
+**Options:**
+- `--project-name <name>`: Name of the project
+- `--ai-provider <provider>`: AI provider (openai, anthropic, openrouter, custom)
+- `--ai-model <model>`: AI model to use
+- `--ai-key <key>`: API key for the AI provider
+- `--no-bootstrap`: Skip project bootstrapping
+
+#### `task-o-matic init bootstrap`
+
+Bootstrap a Better-T-Stack project.
+
+```bash
+# Bootstrap with defaults (Next.js + Hono + SQLite + Auth)
+task-o-matic init bootstrap my-app
+
+# Bootstrap with custom options
+task-o-matic init bootstrap my-app --frontend next --backend hono --database postgres --addons pwa biome
+
+# Bootstrap with authentication
+task-o-matic init bootstrap my-app --auth
 ```
 
-### Core Components
+**Options:**
+- `--frontend <framework>`: Frontend framework (next, react, vue, svelte, none)
+- `--backend <framework>`: Backend framework (hono, express, fastify, none)
+- `--database <db>`: Database (sqlite, postgres, mysql, mongodb, none)
+- `--auth`: Enable authentication
+- `--addons <addons>`: Additional addons (comma-separated: pwa, biome, testing, etc.)
+
+### Configuration Commands
+
+#### `task-o-matic config set-ai-provider`
 
-- **Service Layer** (`WorkflowService`, `PRDService`, `TaskService`): Framework-agnostic business logic
-- **AI Service**: Uses Vercel AI SDK for multi-provider support with reasoning capabilities
-- **Local Storage**: JSON-based file storage in `.task-o-matic/` directory
-- **Configuration**: Project-local config with AI provider settings
-- **Prompt Templates**: Structured AI prompts for consistent results
+Set the AI provider and model.
 
-### Design Philosophy
-
-- **Separation of Concerns**: CLI, Services, and Core are cleanly separated
-- **Framework-Agnostic**: Services can be used in any environment (CLI, TUI, web)
-- **Project-Local**: Each project manages its own tasks and configuration
-- **AI-Enhanced**: Use AI to improve clarity and break down complexity
-- **Developer-Friendly**: Simple, intuitive APIs with helpful output
-- **Self-Contained**: No external dependencies, everything works offline
+```bash
+# Set Anthropic provider
+task-o-matic config set-ai-provider anthropic claude-3-5-sonnet
 
-## 🚀 Quick Start
+# Set OpenAI provider
+task-o-matic config set-ai-provider openai gpt-4
 
-### Library Usage (TUI/Web Apps)
+# Set OpenRouter provider
+task-o-matic config set-ai-provider openrouter anthropic/claude-3.5-sonnet
+
+# Set custom provider
+task-o-matic config set-ai-provider custom custom-model --api-url https://api.custom.com/v1
+```
 
-#### Installation
+#### `task-o-matic config show-ai`
+
+Display current AI configuration.
 
 ```bash
-npm install task-o-matic
+task-o-matic config show-ai
 ```
 
-#### Basic Example
+### Task Commands
+
+#### `task-o-matic tasks create`
 
-```typescript
-import {
-  WorkflowService,
-  TaskService,
-  PRDService,
-  type Task,
-  type AIConfig,
-} from "task-o-matic";
-
-// Use the workflow service for complete project setup
-const workflowService = new WorkflowService();
-
-const result = await workflowService.initializeProject({
-  projectName: "my-app",
-  initMethod: "quick",
-  bootstrap: true,
-  aiOptions: {
-    aiProvider: "anthropic",
-    aiModel: "claude-3-5-sonnet",
-    aiKey: process.env.ANTHROPIC_API_KEY,
-  },
-  callbacks: {
-    onProgress: (event) => {
-      console.log(`Progress: ${event.message}`);
-    },
-  },
-});
-
-console.log("Project initialized:", result.projectName);
-
-// Or use task service directly
-const taskService = new TaskService();
-
-const taskResult = await taskService.createTask({
-  title: "Implement user authentication",
-  content: "Add login and signup functionality",
-  aiEnhance: true,
-  aiOptions: {
-    aiProvider: "anthropic",
-    aiModel: "claude-3-5-sonnet",
-    aiKey: process.env.ANTHROPIC_API_KEY,
-  },
-  callbacks: {
-    onProgress: (event) => {
-      console.log(`Progress: ${event.message}`);
-    },
-  },
-});
-
-console.log("Task created:", taskResult.task);
-```
-
-#### TUI Integration Example
-
-```typescript
-import { TaskService } from "task-o-matic";
-import type { ProgressCallback } from "task-o-matic";
-
-const taskService = new TaskService();
-
-// Progress callback for TUI updates
-const progressCallback: ProgressCallback = {
-  onProgress: (event) => {
-    // Update your TUI with progress
-    tuiStatusBar.update(event.message);
-  },
-};
-
-// Create task with streaming
-const result = await taskService.createTask({
-  title: "Add payment integration",
-  aiEnhance: true,
-  streamingOptions: {
-    enabled: true,
-    onChunk: (chunk) => {
-      // Update TUI in real-time
-      tuiTextArea.append(chunk);
-    },
-    onFinish: ({ text }) => {
-      tuiStatusBar.success("Task enhanced!");
-    },
-  },
-  callbacks: progressCallback,
-});
-```
-
-#### PRD Question/Refine Example
-
-```typescript
-import { PRDService } from "task-o-matic";
-
-const prdService = new PRDService();
-
-// Generate questions and refine PRD with AI answering
-const result = await prdService.refinePRDWithQuestions({
-  file: "./requirements.md",
-  questionMode: "ai", // or "user" for interactive
-  questionAIOptions: {
-    // Optional: use a different AI for answering
-    aiProvider: "openrouter",
-    aiModel: "anthropic/claude-3-opus",
-    aiReasoning: "enabled", // Enable reasoning for better answers
-  },
-  workingDirectory: process.cwd(),
-  aiOptions: {
-    aiProvider: "anthropic",
-    aiModel: "claude-3-5-sonnet",
-    aiKey: process.env.ANTHROPIC_API_KEY,
-  },
-  callbacks: {
-    onProgress: (event) => {
-      console.log(event.message);
-    },
-  },
-});
-
-console.log(`Refined PRD with ${result.questions.length} questions`);
-result.questions.forEach((q, i) => {
-  console.log(`Q${i + 1}: ${q}`);
-  console.log(`A${i + 1}: ${result.answers[q]}`);
-});
-```
-
-#### Using Utility Factories
-
-```typescript
-import { getStorage, getAIOperations, buildAIConfig } from "task-o-matic";
-
-// Get singleton instances
-const storage = getStorage();
-const aiOps = getAIOperations();
-
-// Build AI configuration
-const aiConfig = buildAIConfig({
-  provider: "openai",
-  model: "gpt-4",
-  apiKey: process.env.OPENAI_API_KEY,
-});
-
-// Use storage directly
-const allTasks = await storage.getAllTasks();
-```
-
-#### TypeScript Support
-
-The package includes full TypeScript type definitions:
-
-```typescript
-import type {
-  Task,
-  AIConfig,
-  StreamingOptions,
-  CreateTaskOptions,
-  PRDParseResult,
-  TaskAIMetadata,
-  // Workflow types
-  WorkflowService,
-  InitializeResult,
-  DefinePRDResult,
-  RefinePRDResult,
-  GenerateTasksResult,
-  SplitTasksResult,
-  // Benchmark types
-  WorkflowBenchmarkInput,
-  WorkflowBenchmarkResult,
-  BenchmarkConfig,
-  BenchmarkResult,
-} from "task-o-matic";
-```
-
-### CLI Usage
-
-#### 1. Initialize Your Project
+Create a new task.
 
 ```bash
-# Navigate to your project directory
-cd /path/to/your/project
+# Create a basic task
+task-o-matic tasks create --title "Implement user authentication"
 
-# Initialize task-o-matic (basic setup)
-task-o-matic init init
+# Create task with content
+task-o-matic tasks create --title "Add payment integration" --content "Integrate Stripe for payment processing"
 
-# Initialize task-o-matic + bootstrap Better-T-Stack project (recommended)
-task-o-matic init init --project-name my-app
+# Create task with AI enhancement
+task-o-matic tasks create --title "Implement user authentication" --ai-enhance
 
-# Initialize with custom AI settings + bootstrap
-task-o-matic init init --project-name my-app --ai-provider openrouter --ai-key your-key --frontend next --backend hono
+# Create task with streaming AI output
+task-o-matic tasks create --title "Add payment integration" --ai-enhance --stream
+
+# Create task with priority and tags
+task-o-matic tasks create --title "Fix critical bug" --priority high --tags bug,urgent
 ```
 
-This creates a `.task-o-matic/` directory with:
+**Options:**
+- `--title <title>`: Task title (required)
+- `--content <content>`: Task description
+- `--ai-enhance`: Enhance task with AI
+- `--stream`: Enable streaming output
+- `--priority <priority>`: Task priority (low, medium, high)
+- `--tags <tags>`: Comma-separated tags
 
-- `config.json` - AI configuration
-- `tasks/` - Task JSON files
-- `prd/` - PRD versions and logs
-- `logs/` - Operation logs
-- `bts-config.json` - Better-T-Stack configuration (if bootstrapped)
+#### `task-o-matic tasks list`
 
-### 3. Configure AI Provider
+List all tasks.
 
 ```bash
-# Option 1: Configure during init (recommended)
-task-o-matic init init --project-name my-app --ai-provider openrouter --ai-model anthropic/claude-3.5-sonnet --ai-key your-key
+# List all tasks
+task-o-matic tasks list
 
-# Option 2: Configure after init
-task-o-matic config set-ai-provider openrouter anthropic/claude-3.5-sonnet
+# List tasks by status
+task-o-matic tasks list --status todo
+task-o-matic tasks list --status in-progress
+task-o-matic tasks list --status completed
 
-# Option 3: Use environment variables
-export OPENROUTER_API_KEY="your-key-here"
-export ANTHROPIC_API_KEY="your-key-here"
-export OPENAI_API_KEY="your-key-here"
+# List tasks with raw JSON output
+task-o-matic tasks list --raw
+
+# List tasks with tree view
+task-o-matic tasks list --tree
 ```
 
-### 4. Bootstrap Your Project (if not done during init)
+**Options:**
+- `--status <status>`: Filter by status (todo, in-progress, completed)
+- `--raw`: Output raw JSON
+- `--tree`: Show task tree with subtasks
 
-```bash
-# Bootstrap with defaults (Next.js + Hono + SQLite + Auth)
-task-o-matic init bootstrap my-app
+#### `task-o-matic tasks show`
 
-# Bootstrap with custom options
-task-o-matic init bootstrap my-app --frontend next --backend hono --database postgres --addons pwa biome
+Display details of a specific task.
+
+```bash
+task-o-matic tasks show <task-id>
 ```
 
-### 6. Create Your First Tasks
+#### `task-o-matic tasks update`
+
+Update a task.
 
 ```bash
-# Create a task with AI enhancement
-task-o-matic tasks create --title "Implement user authentication" --ai-enhance
+# Update task status
+task-o-matic tasks update <task-id> --status in-progress
 
-# Create a task with real-time AI streaming
-task-o-matic tasks create --title "Implement user authentication" --ai-enhance --stream
+# Update task title
+task-o-matic tasks update <task-id> --title "New title"
 
-# Parse a PRD into tasks
-task-o-matic prd parse --file my-prd.md
+# Update task content
+task-o-matic tasks update <task-id> --content "New description"
 
-# Parse PRD with real-time AI streaming
-task-o-matic prd parse --file my-prd.md --stream
+# Update task priority
+task-o-matic tasks update <task-id> --priority high
 
-# List all tasks
-task-o-matic tasks list
+# Update task tags
+task-o-matic tasks update <task-id> --tags updated,important
 ```
 
-### 7. Interactive Workflow (Recommended for New Projects)
+**Options:**
+- `--status <status>`: New status (todo, in-progress, completed)
+- `--title <title>`: New title
+- `--content <content>`: New content
+- `--priority <priority>`: New priority (low, medium, high)
+- `--tags <tags>`: Comma-separated tags
+
+#### `task-o-matic tasks delete`
 
-The interactive workflow guides you through the entire setup process:
+Delete a task.
 
 ```bash
-# Start the interactive workflow
-task-o-matic workflow
+task-o-matic tasks delete <task-id>
+```
 
-# With streaming AI output
-task-o-matic workflow --stream
+#### `task-o-matic tasks split`
+
+Split a complex task into subtasks.
+
+```bash
+# Split a specific task
+task-o-matic tasks split <task-id>
+
+# Split with streaming output
+task-o-matic tasks split <task-id> --stream
 
-# Want to test multiple AI models? Try workflow benchmarking:
-task-o-matic benchmark workflow --models "openai:gpt-4o,anthropic:claude-3-5-sonnet"
+# Split with custom instructions
+task-o-matic tasks split <task-id> --instructions "Break into 2-4 hour chunks"
 ```
 
-**The workflow will guide you through:**
+**Options:**
+- `--stream`: Enable streaming output
+- `--instructions <instructions>`: Custom instructions for AI
 
-1. **Project Initialization** - Choose quick start, custom, or AI-assisted configuration
-2. **PRD Definition** - Upload file, write manually, or use AI to generate from description
-3. **PRD Question/Refine** (NEW) - AI generates clarifying questions and refines PRD
-   - User can answer questions interactively
-   - OR AI can answer with PRD + stack context
-   - Optional: Use different AI model for answering (e.g., smarter model)
-   - Optional: Enable reasoning for better answers
-4. **PRD Manual Refinement** - Optional additional AI-assisted improvements
-5. **Task Generation** - Parse PRD into actionable tasks
-6. **Task Splitting** - Break down complex tasks into subtasks
+#### `task-o-matic tasks enhance`
 
-**AI Assistance at Every Step:**
+Enhance a task with AI.
 
-At each step, you can choose "AI-assisted" to describe your needs in natural language:
+```bash
+# Enhance task
+task-o-matic tasks enhance <task-id>
+
+# Enhance with streaming
+task-o-matic tasks enhance <task-id> --stream
+```
+
+**Options:**
+- `--stream`: Enable streaming output
+
+#### `task-o-matic tasks execute`
+
+Execute a task with AI assistance.
 
 ```bash
-# Example AI-assisted workflow
-task-o-matic workflow --stream
+# Execute task
+task-o-matic tasks execute <task-id>
 
-# Step 1: "I want to build a SaaS platform for team collaboration"
-# Step 2: "Real-time chat, file sharing, and task management features"
-# Step 3: "Add more details about authentication and security"
-# Step 4: "Focus on MVP features first"
-# Step 5: "Break tasks into 2-4 hour chunks"
+# Execute with streaming
+task-o-matic tasks execute <task-id> --stream
+
+# Execute in loop mode
+task-o-matic tasks execute <task-id> --loop
 ```
 
-## 📚 Documentation
+**Options:**
+- `--stream`: Enable streaming output
+- `--loop`: Execute in loop mode (continue until completion)
+
+#### `task-o-matic tasks next`
 
-- [Configuration](docs/configuration.md) - AI providers and settings
-- [Task Management](docs/tasks.md) - Full task lifecycle with AI features
-- [PRD Processing](docs/prd.md) - Parse and rework Product Requirements Documents
-- [Interactive Workflow](docs/workflow-command.md) - Guided setup with AI assistance
-- [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
+Get the next task to work on.
 
-## 🎯 Common Workflows
+```bash
+task-o-matic tasks next
+```
+
+#### `task-o-matic tasks status`
 
-### Workflow 0: Interactive Guided Setup (Recommended)
+Show task status summary.
 
 ```bash
-# One command to rule them all
-task-o-matic workflow --stream
+task-o-matic tasks status
+```
 
-# The workflow will guide you through:
-# 1. Project initialization with AI-assisted configuration
-# 2. PRD creation (manual, upload, or AI-generated)
-# 3. PRD refinement with AI feedback
-# 4. Task generation from PRD
-# 5. Complex task splitting
+#### `task-o-matic tasks tree`
 
-# After completion:
-task-o-matic tasks list
+Display task hierarchy as a tree.
+
+```bash
 task-o-matic tasks tree
 ```
 
-### Workflow 1: From PRD to Tasks
+#### `task-o-matic tasks tags`
+
+List all tags used across tasks.
 
 ```bash
-# 1. Initialize project (if not done)
-task-o-matic init init
+task-o-matic tasks tags
+```
 
-# 2. Configure AI provider
-task-o-matic config set-ai-provider anthropic claude-3-5-sonnet
+#### `task-o-matic tasks subtasks`
 
-# 3. Parse PRD with streaming
-task-o-matic prd parse --file requirements.md --stream
+Show subtasks for a task.
 
-# 4. Review and enhance tasks
-task-o-matic tasks list
-task-o-matic tasks split --task-id <complex-task-id>
+```bash
+task-o-matic tasks subtasks <task-id>
 ```
 
-### Workflow 2: Task Enhancement
+### Task Document Commands
+
+#### `task-o-matic tasks document add`
+
+Add documentation to a task.
 
 ```bash
-# 1. Create basic task
-task-o-matic tasks create --title "Add payment system"
+task-o-matic tasks document add <task-id> --file ./docs/implementation.md
+```
 
-# 2. Enhance with AI (with streaming)
-task-o-matic tasks create --title "Add payment system" --ai-enhance --stream
+**Options:**
+- `--file <file>`: Documentation file to add
 
-# 3. Break down into subtasks
-task-o-matic tasks split --task-id <task-id>
+#### `task-o-matic tasks document get`
+
+Get documentation for a task.
+
+```bash
+task-o-matic tasks document get <task-id>
 ```
 
-### Workflow 3: Benchmarking Models
+#### `task-o-matic tasks document analyze`
 
-Compare different AI models for performance, cost, and quality.
+Analyze task documentation with AI.
 
 ```bash
-# 1. Run a benchmark for PRD parsing
-task-o-matic benchmark run prd-parse \
-  --file requirements.md \
-  --models "openai:gpt-4o,openrouter:anthropic/claude-3.5-sonnet" \
-  --concurrency 5
+task-o-matic tasks document analyze <task-id>
 
-# 2. Compare results
-task-o-matic benchmark compare <run-id>
+# Analyze with streaming
+task-o-matic tasks document analyze <task-id> --stream
+```
 
-# 3. View detailed metrics (Tokens, BPS, Size)
-task-o-matic benchmark show <run-id>
+**Options:**
+- `--stream`: Enable streaming output
+
+### Task Plan Commands
+
+#### `task-o-matic tasks plan create`
+
+Create a plan for a task.
+
+```bash
+task-o-matic tasks plan create <task-id> --instructions "Break down into steps"
 ```
 
-### Workflow 3b: Complete Workflow Benchmarking
+**Options:**
+- `--instructions <instructions>`: Planning instructions
 
-Test entire workflows across multiple AI models and automatically set up your project with the best results.
+#### `task-o-matic tasks plan get`
+
+Get the plan for a task.
 
 ```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
+task-o-matic tasks plan get <task-id>
+```
 
-# 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
+#### `task-o-matic tasks plan set`
 
-# 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
+Set a plan for a task.
 
-# 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
+```bash
+task-o-matic tasks plan set <task-id> --plan "Step 1: Setup\nStep 2: Implement\nStep 3: Test"
 ```
 
-**Workflow Benchmark Features:**
+**Options:**
+- `--plan <plan>`: Plan content
 
-- **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
+#### `task-o-matic tasks plan delete`
 
-### Workflow 4: Project Bootstrapping
+Delete the plan for a task.
 
 ```bash
-# Option 1: One-step setup (recommended)
-task-o-matic init init --project-name my-app --ai-provider openrouter --ai-key your-key
+task-o-matic tasks plan delete <task-id>
+```
 
-# Option 2: Two-step setup
-task-o-matic init init --no-bootstrap
-task-o-matic init bootstrap my-app --frontend next --backend hono
+#### `task-o-matic tasks plan list`
 
-# Option 3: Manual setup
-task-o-matic init init
-task-o-matic config set-ai-provider openrouter anthropic/claude-3.5-sonnet
-task-o-matic init bootstrap my-app
+List all tasks with plans.
+
+```bash
+task-o-matic tasks plan list
+```
 
-# Start managing tasks
-task-o-matic tasks create --title "Set up development environment" --ai-enhance --stream
+### PRD Commands
+
+#### `task-o-matic prd parse`
+
+Parse a PRD file into tasks.
+
+```bash
+# Parse PRD file
+task-o-matic prd parse --file requirements.md
+
+# Parse with streaming output
+task-o-matic prd parse --file requirements.md --stream
+
+# Parse with custom instructions
+task-o-matic prd parse --file requirements.md --instructions "Focus on MVP features"
+```
+
+**Options:**
+- `--file <file>`: PRD file to parse (required)
+- `--stream`: Enable streaming output
+- `--instructions <instructions>`: Custom instructions for AI
+
+#### `task-o-matic prd rework`
+
+Rework a PRD with AI feedback.
+
+```bash
+# Rework PRD
+task-o-matic prd rework --file requirements.md --feedback "Add more security details"
+
+# Rework with streaming
+task-o-matic prd rework --file requirements.md --feedback "Focus on scalability" --stream
 ```
 
-## 📊 Benchmarking Commands
+**Options:**
+- `--file <file>`: PRD file to rework (required)
+- `--feedback <feedback>`: Feedback for AI (required)
+- `--stream`: Enable streaming output
+
+### Workflow Commands
+
+#### `task-o-matic workflow`
+
+Interactive workflow for complete project setup.
+
+```bash
+# Start interactive workflow
+task-o-matic workflow
 
-### Basic Model Benchmarking
+# Start with streaming output
+task-o-matic workflow --stream
 
-Compare different AI models on specific operations:
+# Automated workflow with all options
+task-o-matic workflow \
+  --project-name my-saas-app \
+  --project-description "Team collaboration platform" \
+  --init-method ai \
+  --prd-method ai \
+  --prd-description "Real-time chat and file sharing" \
+  --refine-feedback "Add security details" \
+  --generate-instructions "Break into 2-4 hour tasks" \
+  --split-all \
+  --auto-accept \
+  --stream
+```
+
+**Options:**
+- `--project-name <name>`: Project name
+- `--project-description <description>`: Project description
+- `--init-method <method>`: Initialization method (quick, custom, ai)
+- `--frontend <framework>`: Frontend framework
+- `--backend <framework>`: Backend framework
+- `--database <db>`: Database
+- `--auth/--no-auth`: Enable/disable authentication
+- `--prd-method <method>`: PRD creation method (file, manual, ai)
+- `--prd-file <file>`: PRD file path
+- `--prd-content <content>`: PRD content
+- `--prd-description <description>`: PRD description (for AI method)
+- `--refine-feedback <feedback>`: Feedback for PRD refinement
+- `--generate-instructions <instructions>`: Instructions for task generation
+- `--split-tasks/--no-split-tasks`: Enable/disable task splitting
+- `--split-all`: Split all complex tasks
+- `--split-instructions <instructions>`: Instructions for task splitting
+- `--skip-init`: Skip initialization step
+- `--skip-prd`: Skip PRD step
+- `--skip-refine`: Skip PRD refinement step
+- `--skip-generate`: Skip task generation step
+- `--skip-split`: Skip task splitting step
+- `--auto-accept`: Auto-accept all prompts
+- `--stream`: Enable streaming output
+- `--config-file <file>`: Load workflow from config file
+
+### Benchmark Commands
+
+#### `task-o-matic benchmark run`
+
+Run a benchmark on specific operations.
 
 ```bash
-# Benchmark PRD parsing across multiple models
+# Benchmark PRD parsing
 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
+  --models "openai:gpt-4o,anthropic:claude-3-5-sonnet" \
+  --concurrency 3
 
-# Benchmark task splitting
+# Benchmark task breakdown
 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
+**Options:**
+- `--models <models>`: Comma-separated model list (required)
+- `--concurrency <number>`: Max parallel requests (default: 3)
+- `--delay <ms>`: Delay between requests (default: 1000ms)
+
+#### `task-o-matic benchmark workflow`
 
-Test entire project workflows across multiple AI models:
+Benchmark complete workflow across multiple AI models.
 
 ```bash
-# Interactive workflow benchmark (recommended)
+# Interactive workflow benchmark
 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
+# Automated workflow benchmark
 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" \
+  --project-name "my-saas-app" \
+  --project-description "Team collaboration platform" \
   --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
+**Options:**
+All workflow options are supported, plus:
+- `--models <models>`: Comma-separated model list (required)
+- `--concurrency <number>`: Max parallel requests (default: 3)
+- `--delay <ms>`: Delay between requests (default: 1000ms)
 
-🔍 Detailed Comparison
+#### `task-o-matic benchmark list`
 
-[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
+List all benchmark runs.
 
-🎯 Model Selection
-Would you like to select a model and set up your project with its results? (y/N)
+```bash
+task-o-matic benchmark list
 ```
 
-### 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)
+#### `task-o-matic benchmark show`
 
-**Model format:** `provider:model[:reasoning=<tokens>]`
+Show details of a benchmark run.
 
-**Examples:**
-- `openai:gpt-4o`
-- `anthropic:claude-3-5-sonnet`
-- `openrouter:anthropic/claude-3.5-sonnet`
-- `openrouter:openai/o1-preview:reasoning=50000`
+```bash
+task-o-matic benchmark show <run-id>
+```
 
-### Workflow Benchmark Inheritance
+#### `task-o-matic benchmark compare`
 
-The `benchmark workflow` command supports ALL workflow command options:
+Compare benchmark results.
 
 ```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
+task-o-matic benchmark compare <run-id>
 ```
 
-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)
-```
+### Prompt Commands
+
+#### `task-o-matic prompt`
 
-## 🔧 Environment Variables
+Run an AI prompt with context.
 
 ```bash
-# AI Provider API Keys
-OPENAI_API_KEY=your_openai_key
-ANTHROPIC_API_KEY=your_anthropic_key
-OPENROUTER_API_KEY=your_openrouter_key
-CUSTOM_API_KEY=your_custom_key
-CUSTOM_API_URL=https://api.custom.com/v1
+# Run a simple prompt
+task-o-matic prompt "How do I implement authentication?"
 
-# Default AI Configuration
-AI_PROVIDER=openrouter
-AI_MODEL=anthropic/claude-3.5-sonnet
-AI_MAX_TOKENS=4000
-AI_TEMPERATURE=0.7
+# Run prompt with streaming
+task-o-matic prompt "Explain the architecture" --stream
+
+# Run prompt with file context
+task-o-matic prompt "Review this code" --file ./src/auth.ts
 ```
 
-## 🤖 AI Providers
+**Options:**
+- `--stream`: Enable streaming output
+- `--file <file>`: Add file context to prompt
 
-### Supported Providers
+### Install Commands
 
-- **OpenAI**: GPT models with full feature support
-- **Anthropic**: Claude models with enhanced reasoning
-- **OpenRouter**: Access to multiple models through one API
-- **Custom**: Any OpenAI-compatible API endpoint
+#### `task-o-matic install`
 
-### Model Recommendations
+Install shell completions.
 
-- **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
+```bash
+# Install bash completions
+task-o-matic install --shell bash
 
-### Choosing the Right Model
+# Install zsh completions
+task-o-matic install --shell zsh
 
-Not sure which model to use? Try workflow benchmarking:
+# Install fish completions
+task-o-matic install --shell fish
+```
 
-```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"
+**Options:**
+- `--shell <shell>`: Shell type (bash, zsh, fish)
 
-# The benchmark will show you:
-# - Performance (speed, tokens, cost)
-# - Quality (tasks created, PRD completeness)  
-# - Best model for your specific needs
-```
+## Common Workflows
 
-## 📁 Storage Structure
+### Workflow 1: Complete Project Setup
 
-```
-your-project/
-├── .task-o-matic/
-│   ├── config.json          # AI configuration
-│   ├── bts-config.json      # Better-T-Stack configuration (if bootstrapped)
-│   ├── tasks/              # Task JSON files
-│   │   ├── {task-id}.json
-│   │   └── ...
-│   ├── prd/                # PRD versions and logs
-│   │   ├── parsed-prd.json
-│   │   └── ...
-│   └── logs/               # Operation logs
-│       └── ...
-└── your-project-files...
-```
+```bash
+# One command to initialize everything
+task-o-matic workflow --stream
 
-## 🛠️ Development
+# The workflow will guide you through:
+# 1. Project initialization
+# 2. PRD creation
+# 3. PRD refinement
+# 4. Task generation
+# 5. Task breakdown
+```
 
-### Building from Source
+### Workflow 2: From PRD to Tasks
 
 ```bash
-# Clone and install
-git clone https://github.com/DimitriGilbert/task-o-matic.git
-cd task-o-matic
-npm install
+# 1. Initialize project
+task-o-matic init init --project-name my-app
 
-# Build everything (library + CLI + MCP server)
-npm run build
+# 2. Configure AI provider
+task-o-matic config set-ai-provider anthropic claude-3-5-sonnet
+
+# 3. Parse PRD with streaming
+task-o-matic prd parse --file requirements.md --stream
 
-# Build and watch for changes
-npm run build:watch
+# 4. Review and enhance tasks
+task-o-matic tasks list --tree
 
-# Clean build artifacts
-npm run clean
+# 5. Split complex tasks
+task-o-matic tasks split <complex-task-id> --stream
 ```
 
-### Development Mode
+### Workflow 3: Task Enhancement
 
 ```bash
-# Run the CLI in development mode
-npm run dev
+# 1. Create basic task
+task-o-matic tasks create --title "Add payment system"
 
-# Run the MCP server in development
-npm run dev:mcp
+# 2. Enhance with AI and streaming
+task-o-matic tasks create --title "Add payment system" --ai-enhance --stream
 
-# Type checking (without compilation)
-npm run check-types
+# 3. Break down into subtasks
+task-o-matic tasks split <task-id> --stream
+```
+
+### Workflow 4: AI Model Comparison
 
-# Run tests
-npm run test
+```bash
+# Benchmark 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 "E-commerce platform with AI recommendations"
+
+# The benchmark will:
+# 1. Collect workflow questions once
+# 2. Execute identical workflows in parallel
+# 3. Show comprehensive comparison
+# 4. Allow you to select the best model
 ```
 
-### Testing Your Changes
+### Workflow 5: Daily Task Management
 
 ```bash
-# Link for local testing
-npm link
+# Get next task
+task-o-matic tasks next
+
+# Update task status
+task-o-matic tasks update <task-id> --status in-progress
 
-# Use the linked package
-task-o-matic --version
+# Execute task with AI assistance
+task-o-matic tasks execute <task-id> --loop
 
-# In another project
-cd /path/to/test-project
-npm link task-o-matic
+# Mark as completed
+task-o-matic tasks update <task-id> --status completed
 
-# Test library import
-node -e "const {TaskService} = require('task-o-matic'); console.log('Works!');"
+# Check progress
+task-o-matic tasks status
 ```
 
-### Package Structure
+## Environment Variables
 
-The package is structured for both CLI and library use:
+```bash
+# AI Provider API Keys
+export OPENAI_API_KEY="your_openai_key"
+export ANTHROPIC_API_KEY="your_anthropic_key"
+export OPENROUTER_API_KEY="your_openrouter_key"
+export CUSTOM_API_KEY="your_custom_key"
+export CUSTOM_API_URL="https://api.custom.com/v1"
 
-```json
-{
-  "main": "./dist/lib/index.js", // CommonJS library entry
-  "types": "./dist/lib/index.d.ts", // TypeScript definitions
-  "bin": {
-    "task-o-matic": "./dist/cli/bin.js", // CLI binary
-    "task-o-matic-mcp": "./dist/mcp/server.js" // MCP server binary
-  },
-  "exports": {
-    ".": "./dist/lib/index.js", // Main library export
-    "./types": "./dist/types/index.js" // Type-only exports
-  }
-}
+# Default AI Configuration
+export AI_PROVIDER="anthropic"
+export AI_MODEL="claude-3-5-sonnet"
+export AI_MAX_TOKENS="4000"
+export AI_TEMPERATURE="0.7"
 ```
 
-## 🤖 MCP Server Integration
+## AI Providers
 
-`task-o-matic` includes a built-in Model Context Protocol (MCP) server that exposes its project management capabilities directly to compatible AI models and development tools.
+### Supported Providers
 
-### Running the MCP Server
+- **OpenAI**: GPT models with full feature support
+- **Anthropic**: Claude models with enhanced reasoning
+- **OpenRouter**: Access to multiple models through one API
+- **Custom**: Any OpenAI-compatible API endpoint
 
-You can run the server in development mode or as a production build.
+### Model Recommendations
 
-**Development:**
+- **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 Testing**: Use benchmarking to find optimal performance
 
-```bash
-# This will start the server using tsx for live reloading
-npm run dev:mcp
-```
+## Storage Structure
 
-**Production:**
-First, build the server, then run the executable from your project root.
+All data is stored locally in the `.task-o-matic/` directory:
 
-```bash
-# 1. Build the server
-npm run build:mcp
-
-# 2. Run the server
-# The 'projpoc-mcp' command is now available via npx
-npx projpoc-mcp
+```
+your-project/
+├── .task-o-matic/
+│   ├── config.json          # AI configuration
+│   ├── bts-config.json      # Better-T-Stack configuration (if bootstrapped)
+│   ├── tasks/              # Task JSON files
+│   │   ├── {task-id}.json
+│   │   └── ...
+│   ├── prd/                # PRD versions and logs
+│   │   ├── parsed-prd.json
+│   │   └── ...
+│   └── logs/               # Operation logs
+│       └── ...
+└── your-project-files...
 ```
 
-### Connecting a Client
+## Shell Completions
 
-You can connect any MCP-compatible client. For example, to connect an AI model, you would configure its tool server settings to use the `projpoc-mcp` command.
+Install shell completions for better command-line experience:
+
+```bash
+# Bash
+task-o-matic install --shell bash
+source ~/.bashrc
 
-**Example Client Configuration:**
+# Zsh
+task-o-matic install --shell zsh
+source ~/.zshrc
 
-```json
-{
-  "mcpServers": {
-    "task-o-matic": {
-      "command": "npx",
-      "args": ["projpoc-mcp"]
-    }
-  }
-}
+# Fish
+task-o-matic install --shell fish
 ```
 
-### Exposed Tools
+## Documentation
 
-When running, the server provides the following tools:
+For more detailed documentation, see:
 
-- **`get_project_info`**: Retrieves information about the current project, including its path and AI configuration.
-- **`list_tasks`**: Lists all tasks for the project.
-  - `filterByStatus` (optional): Filter by `todo`, `in-progress`, or `completed`.
-- **`create_task`**: Creates a new task.
-  - `taskTitle` (required): The title of the task.
-  - `taskContent` (optional): The description of the task.
+- [Configuration](../../docs/configuration.md) - AI providers and settings
+- [Task Management](../../docs/tasks.md) - Full task lifecycle with AI features
+- [PRD Processing](../../docs/prd.md) - Parse and rework Product Requirements Documents
+- [Interactive Workflow](../../docs/workflow-command.md) - Guided setup with AI assistance
+- [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
 
-## 📄 License
+## License
 
 MIT License - see LICENSE file for details.
 
-## 🤝 Contributing
+## Contributing
 
 1. Fork the repository
 2. Create a feature branch