task-o-matic 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,552 @@
+# 🚀 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.
+
+## ✨ Features
+
+- 🤖 **AI-Powered**: Parse PRDs and enhance tasks using multiple AI providers
+- 📦 **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
+- 🏠 **Single-Project Focus**: Self-contained within each project directory
+- 💻 **Framework-Agnostic**: Easily integrate into TUI, web apps, or any Node.js project
+
+## 📦 Installation
+
+### As a CLI Tool
+
+```bash
+# Install globally
+npm install -g task-o-matic
+
+# Or use with npx
+npx task-o-matic init
+```
+
+### As a Library (for TUI/Web Apps)
+
+```bash
+# Install in your project
+npm install task-o-matic
+```
+
+### For Development
+
+```bash
+# Clone and install dependencies
+git clone https://github.com/DimitriGilbert/task-o-matic.git
+cd task-o-matic
+npm install
+npm run build
+```
+
+## 🏗️ Architecture & Mindset
+
+### Package Structure
+
+```
+task-o-matic/
+├── dist/              # Compiled output (published)
+│   ├── lib/           # Library entry point + core exports
+│   ├── cli/           # CLI binary
+│   ├── services/      # Business logic layer
+│   ├── commands/      # CLI commands
+│   ├── mcp/           # MCP server
+│   └── types/         # TypeScript definitions
+├── src/
+│   ├── lib/           # Core library (Storage, Config, AI, etc.)
+│   │   └── index.ts   # Main library exports
+│   ├── services/      # TaskService, PRDService (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
+```
+
+### Core Components
+
+- **Service Layer** (`TaskService`, `PRDService`): Framework-agnostic business logic
+- **AI Service**: Uses Vercel AI SDK for multi-provider support
+- **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
+
+### 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
+
+## 🚀 Quick Start
+
+### Library Usage (TUI/Web Apps)
+
+#### Installation
+
+```bash
+npm install task-o-matic
+```
+
+#### Basic Example
+
+```typescript
+import { TaskService, PRDService, type Task, type AIConfig } from 'task-o-matic';
+
+// Initialize the service
+const taskService = new TaskService();
+
+// Create a task with AI enhancement
+const result = await taskService.createTask({
+  title: 'Implement user authentication',
+  content: 'Add login and signup functionality',
+  aiEnhance: true,
+  aiOptions: {
+    provider: 'anthropic',
+    model: 'claude-3-5-sonnet',
+    apiKey: process.env.ANTHROPIC_API_KEY
+  },
+  callbacks: {
+    onProgress: (event) => {
+      console.log(`Progress: ${event.message}`);
+    }
+  }
+});
+
+console.log('Task created:', result.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 Parsing Example
+
+```typescript
+import { PRDService } from 'task-o-matic';
+
+const prdService = new PRDService();
+
+const result = await prdService.parsePRD({
+  file: './requirements.md',
+  workingDirectory: process.cwd(),
+  aiOptions: {
+    provider: 'openrouter',
+    model: 'anthropic/claude-3.5-sonnet',
+    apiKey: process.env.OPENROUTER_API_KEY
+  },
+  callbacks: {
+    onProgress: (event) => {
+      console.log(event.message);
+    }
+  }
+});
+
+console.log(`Created ${result.tasks.length} tasks from PRD`);
+result.tasks.forEach(task => {
+  console.log(`- ${task.title}`);
+});
+```
+
+#### 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
+} from 'task-o-matic';
+```
+
+### CLI Usage
+
+#### 1. Initialize Your Project
+
+```bash
+# Navigate to your project directory
+cd /path/to/your/project
+
+# Initialize task-o-matic (basic setup)
+task-o-matic init init
+
+# Initialize task-o-matic + bootstrap Better-T-Stack project (recommended)
+task-o-matic init init --project-name my-app
+
+# 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
+```
+
+This creates a `.task-o-matic/` directory with:
+
+- `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)
+
+### 3. Configure AI Provider
+
+```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
+
+# Option 2: Configure after init
+task-o-matic config set-ai-provider openrouter anthropic/claude-3.5-sonnet
+
+# 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"
+```
+
+### 4. Bootstrap Your Project (if not done during init)
+
+```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
+```
+
+### 6. Create Your First Tasks
+
+```bash
+# Create a task with AI enhancement
+task-o-matic tasks create --title "Implement user authentication" --ai-enhance
+
+# Create a task with real-time AI streaming
+task-o-matic tasks create --title "Implement user authentication" --ai-enhance --stream
+
+# Parse a PRD into tasks
+task-o-matic prd parse --file my-prd.md
+
+# Parse PRD with real-time AI streaming
+task-o-matic prd parse --file my-prd.md --stream
+
+# List all tasks
+task-o-matic tasks list
+```
+
+## 📚 Documentation
+
+- [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
+- [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
+
+## 🎯 Common Workflows
+
+### Workflow 1: From PRD to Tasks
+
+```bash
+# 1. Initialize project (if not done)
+task-o-matic init init
+
+# 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
+
+# 4. Review and enhance tasks
+task-o-matic tasks list
+task-o-matic tasks split --task-id <complex-task-id>
+```
+
+### Workflow 2: Task Enhancement
+
+```bash
+# 1. Create basic task
+task-o-matic tasks create --title "Add payment system"
+
+# 2. Enhance with AI (with streaming)
+task-o-matic tasks create --title "Add payment system" --ai-enhance --stream
+
+# 3. Break down into subtasks
+task-o-matic tasks split --task-id <task-id>
+```
+
+### Workflow 3: Project Bootstrapping
+
+```bash
+# Option 1: One-step setup (recommended)
+task-o-matic init init --project-name my-app --ai-provider openrouter --ai-key your-key
+
+# Option 2: Two-step setup
+task-o-matic init init --no-bootstrap
+task-o-matic init bootstrap my-app --frontend next --backend hono
+
+# 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
+
+# Start managing tasks
+task-o-matic tasks create --title "Set up development environment" --ai-enhance --stream
+```
+
+## 🔧 Environment Variables
+
+```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
+
+# Default AI Configuration
+AI_PROVIDER=openrouter
+AI_MODEL=anthropic/claude-3.5-sonnet
+AI_MAX_TOKENS=4000
+AI_TEMPERATURE=0.7
+```
+
+## 🤖 AI Providers
+
+### Supported Providers
+
+- **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
+
+### Model Recommendations
+
+- **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
+
+## 📁 Storage Structure
+
+```
+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...
+```
+
+## 🛠️ Development
+
+### Building from Source
+
+```bash
+# Clone and install
+git clone https://github.com/DimitriGilbert/task-o-matic.git
+cd task-o-matic
+npm install
+
+# Build everything (library + CLI + MCP server)
+npm run build
+
+# Build and watch for changes
+npm run build:watch
+
+# Clean build artifacts
+npm run clean
+```
+
+### Development Mode
+
+```bash
+# Run the CLI in development mode
+npm run dev
+
+# Run the MCP server in development
+npm run dev:mcp
+
+# Type checking (without compilation)
+npm run check-types
+
+# Run tests
+npm run test
+```
+
+### Testing Your Changes
+
+```bash
+# Link for local testing
+npm link
+
+# Use the linked package
+task-o-matic --version
+
+# In another project
+cd /path/to/test-project
+npm link task-o-matic
+
+# Test library import
+node -e "const {TaskService} = require('task-o-matic'); console.log('Works!');"
+```
+
+### Package Structure
+
+The package is structured for both CLI and library use:
+
+```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
+  }
+}
+```
+
+## 🤖 MCP Server Integration
+
+`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.
+
+### Running the MCP Server
+
+You can run the server in development mode or as a production build.
+
+**Development:**
+
+```bash
+# This will start the server using tsx for live reloading
+npm run dev:mcp
+```
+
+**Production:**
+First, build the server, then run the executable from your project root.
+
+```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
+```
+
+### Connecting a Client
+
+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.
+
+**Example Client Configuration:**
+
+```json
+{
+  "mcpServers": {
+    "task-o-matic": {
+      "command": "npx",
+      "args": ["projpoc-mcp"]
+    }
+  }
+}
+```
+
+### Exposed Tools
+
+When running, the server provides the following tools:
+
+- **`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.
+
+## 📄 License
+
+MIT License - see LICENSE file for details.
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
+
+---
+
+**Built with ❤️ using Vercel AI SDK and modern TypeScript**

package/dist/cli/bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=bin.d.ts.map

package/dist/cli/bin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../../src/cli/bin.ts"],"names":[],"mappings":""}

package/dist/cli/bin.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../index");
+(0, index_1.runCLI)().catch((error) => {
+    console.error(error);
+    process.exit(1);
+});

package/dist/cli/display/common.d.ts

@@ -0,0 +1,5 @@
+import { DocumentationDetection } from "../../types";
+export declare function displayEnhancementResult(streamEnabled: boolean): void;
+export declare function displayDocumentationAnalysis(analysis: DocumentationDetection): void;
+export declare function displayResearchSummary(documentation: any): void;
+//# sourceMappingURL=common.d.ts.map

package/dist/cli/display/common.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"common.d.ts","sourceRoot":"","sources":["../../../src/cli/display/common.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAC;AAErD,wBAAgB,wBAAwB,CAAC,aAAa,EAAE,OAAO,GAAG,IAAI,CAIrE;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,sBAAsB,GAC/B,IAAI,CAgBN;AAED,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,GAAG,GAAG,IAAI,CAe/D"}

package/dist/cli/display/common.js

@@ -0,0 +1,44 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayEnhancementResult = displayEnhancementResult;
+exports.displayDocumentationAnalysis = displayDocumentationAnalysis;
+exports.displayResearchSummary = displayResearchSummary;
+const chalk_1 = __importDefault(require("chalk"));
+function displayEnhancementResult(streamEnabled) {
+    if (!streamEnabled) {
+        console.log(chalk_1.default.green("✓ Task enhanced with Context7 documentation"));
+    }
+}
+function displayDocumentationAnalysis(analysis) {
+    console.log(chalk_1.default.cyan(`
+Documentation analysis complete:`));
+    if (analysis.libraries.length > 0) {
+        console.log(chalk_1.default.blue(`Libraries identified:`));
+        analysis.libraries.forEach((lib) => {
+            console.log(`  • ${lib.name} (${lib.context7Id})`);
+            console.log(`    Search Query: "${lib.searchQuery}"`);
+            console.log(`    Reason: ${lib.reason}`);
+        });
+        console.log(chalk_1.default.green(`✓ Documentation analysis saved to task`));
+    }
+    else {
+        console.log(chalk_1.default.yellow("No specific documentation needs identified."));
+    }
+}
+function displayResearchSummary(documentation) {
+    if (documentation?.research) {
+        console.log(chalk_1.default.cyan(`
+📚 Research Summary:`));
+        Object.entries(documentation.research).forEach(([lib, entries]) => {
+            console.log(`  • ${lib}: ${entries.length} queries cached`);
+            entries.forEach((entry, index) => {
+                console.log(`    ${index + 1}. Query: "${entry.query}"`);
+                console.log(`       Cache: ${entry.cache}`);
+                console.log(`       Doc: ${entry.doc}`);
+            });
+        });
+    }
+}

package/dist/cli/display/plan.d.ts

@@ -0,0 +1,11 @@
+export declare function displayPlanCreation(taskId: string, taskTitle: string): void;
+export declare function displayPlanView(taskTitle: string, taskId: string, plan: string, createdAt: number, updatedAt: number): void;
+export declare function displayPlanList(plans: Array<{
+    taskId: string;
+    plan: string;
+    createdAt: number;
+    updatedAt: number;
+    taskTitle?: string;
+}>): void;
+export declare function displayPlanDeletion(taskId: string, success: boolean): void;
+//# sourceMappingURL=plan.d.ts.map

package/dist/cli/display/plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan.d.ts","sourceRoot":"","sources":["../../../src/cli/display/plan.ts"],"names":[],"mappings":"AAGA,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,CAM3E;AAED,wBAAgB,eAAe,CAC7B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,MAAM,GAChB,IAAI,CAON;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,KAAK,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC,GACD,IAAI,CAyBN;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,IAAI,CAM1E"}

package/dist/cli/display/plan.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.displayPlanCreation = displayPlanCreation;
+exports.displayPlanView = displayPlanView;
+exports.displayPlanList = displayPlanList;
+exports.displayPlanDeletion = displayPlanDeletion;
+const chalk_1 = __importDefault(require("chalk"));
+function displayPlanCreation(taskId, taskTitle) {
+    console.log(chalk_1.default.green(`\n✓ Implementation plan created and saved for: ${taskTitle} (${taskId})`));
+}
+function displayPlanView(taskTitle, taskId, plan, createdAt, updatedAt) {
+    console.log(chalk_1.default.green(`\n📋 Implementation Plan for ${taskTitle} (${taskId}):`));
+    console.log(chalk_1.default.gray(`Created: ${new Date(createdAt).toLocaleString()}`));
+    console.log(chalk_1.default.gray(`Updated: ${new Date(updatedAt).toLocaleString()}`));
+    console.log(chalk_1.default.cyan(`\n${plan}`));
+}
+function displayPlanList(plans) {
+    if (plans.length === 0) {
+        console.log(chalk_1.default.yellow("No plans found."));
+        return;
+    }
+    console.log(chalk_1.default.blue(`\n📋 Available Plans (${plans.length}):`));
+    for (const plan of plans) {
+        console.log(chalk_1.default.white(`\n• ${plan.taskId}: ${plan.taskTitle || "Unknown Task"}`));
+        console.log(chalk_1.default.gray(`  Created: ${new Date(plan.createdAt).toLocaleDateString()}`));
+        console.log(chalk_1.default.gray(`  Updated: ${new Date(plan.updatedAt).toLocaleDateString()}`));
+        // Show first 100 characters of plan as preview
+        const preview = plan.plan.substring(0, 100).replace(/\n/g, " ");
+        console.log(chalk_1.default.cyan(`  Preview: ${preview}${plan.plan.length > 100 ? "..." : ""}`));
+    }
+}
+function displayPlanDeletion(taskId, success) {
+    if (success) {
+        console.log(chalk_1.default.green(`\n✓ Deleted plan for task: ${taskId}`));
+    }
+    else {
+        console.log(chalk_1.default.yellow(`\n⚠️  No plan found for task: ${taskId}`));
+    }
+}