task-o-matic 0.0.1

package/dist/commands/tasks.js

@@ -0,0 +1,599 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tasksCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const tasks_1 = require("../services/tasks");
+const task_execution_1 = require("../lib/task-execution");
+const streaming_options_1 = require("../utils/streaming-options");
+const progress_1 = require("../cli/display/progress");
+const task_1 = require("../cli/display/task");
+const plan_1 = require("../cli/display/plan");
+const common_1 = require("../cli/display/common");
+exports.tasksCommand = new commander_1.Command("tasks");
+// List tasks
+exports.tasksCommand
+    .command("list")
+    .description("List all tasks")
+    .option("--status <status>", "Filter by status (todo/in-progress/completed)")
+    .option("--tag <tag>", "Filter by tag")
+    .action(async (options) => {
+    try {
+        const tasks = await tasks_1.taskService.listTasks({
+            status: options.status,
+            tag: options.tag,
+        });
+        (0, task_1.displayTaskList)(tasks);
+        for (const task of tasks) {
+            await (0, task_1.displayTask)(task, { showSubtasks: true });
+        }
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Create task
+exports.tasksCommand
+    .command("create")
+    .description("Create a new task with AI enhancement using Context7")
+    .requiredOption("--title <title>", "Task title")
+    .option("--content <content>", "Task content (supports markdown)")
+    .option("--effort <effort>", "Estimated effort (small/medium/large)")
+    .option("--parent-id <id>", "Parent task ID (creates subtask)")
+    .option("--ai-enhance", "Enhance task with AI using Context7 documentation")
+    .option("--stream", "Show streaming AI output during enhancement")
+    .option("--ai-provider <provider>", "AI provider override")
+    .option("--ai-model <model>", "AI model override")
+    .option("--ai-key <key>", "AI API key override")
+    .option("--ai-provider-url <url>", "AI provider URL override")
+    .option("--reasoning <tokens>", "Enable reasoning for OpenRouter models (max reasoning tokens)")
+    .action(async (options) => {
+    try {
+        const streamingOptions = (0, streaming_options_1.createStreamingOptions)(options.aiEnhance && options.stream, "Enhancement");
+        const result = await tasks_1.taskService.createTask({
+            title: options.title,
+            content: options.content,
+            parentId: options.parentId,
+            effort: options.effort,
+            aiEnhance: options.aiEnhance,
+            aiOptions: {
+                aiProvider: options.aiProvider,
+                aiModel: options.aiModel,
+                aiKey: options.aiKey,
+                aiProviderUrl: options.aiProviderUrl,
+                aiReasoning: options.reasoning,
+            },
+            streamingOptions,
+            callbacks: {
+                onProgress: progress_1.displayProgress,
+                onError: progress_1.displayError,
+            },
+        });
+        (0, common_1.displayEnhancementResult)(options.aiEnhance && options.stream);
+        (0, task_1.displayCreatedTask)(result.task, result.aiMetadata);
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Show task details
+exports.tasksCommand
+    .command("show")
+    .description("Show detailed information about a task")
+    .requiredOption("--id <id>", "Task ID")
+    .action(async (options) => {
+    try {
+        const task = await tasks_1.taskService.getTask(options.id);
+        if (!task) {
+            throw new Error(`Task with ID ${options.id} not found`);
+        }
+        await (0, task_1.displayTaskDetails)(task);
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Document task
+exports.tasksCommand
+    .command("document")
+    .description("Analyze and fetch documentation for a task using AI with Context7")
+    .requiredOption("--task-id <id>", "Task ID")
+    .option("--force", "Force refresh documentation even if recent")
+    .option("--stream", "Show streaming AI output during analysis")
+    .option("--ai-provider <provider>", "AI provider override")
+    .option("--ai-model <model>", "AI model override")
+    .option("--ai-key <key>", "AI API key override")
+    .option("--ai-provider-url <url>", "AI provider URL override")
+    .option("--reasoning <tokens>", "Enable reasoning for OpenRouter models (max reasoning tokens)")
+    .action(async (options) => {
+    try {
+        const streamingOptions = (0, streaming_options_1.createStreamingOptions)(options.stream, "Analysis");
+        const result = await tasks_1.taskService.documentTask(options.taskId, options.force, {
+            aiProvider: options.aiProvider,
+            aiModel: options.aiModel,
+            aiKey: options.aiKey,
+            aiProviderUrl: options.aiProviderUrl,
+            aiReasoning: options.reasoning,
+        }, streamingOptions, {
+            onProgress: progress_1.displayProgress,
+            onError: progress_1.displayError,
+        });
+        if (result.documentation && !options.force) {
+            const daysSinceFetch = (Date.now() - result.documentation.lastFetched) / (24 * 60 * 60 * 1000);
+            console.log(chalk_1.default.green(`✓ Documentation is fresh (${Math.round(daysSinceFetch)} days old)`));
+            console.log(chalk_1.default.cyan(`Recap: ${result.documentation.recap}`));
+            console.log(chalk_1.default.blue(`Libraries: ${result.documentation.libraries.join(", ")}`));
+            return;
+        }
+        if (result.analysis) {
+            (0, common_1.displayDocumentationAnalysis)(result.analysis);
+        }
+        if (result.documentation?.research) {
+            (0, common_1.displayResearchSummary)(result.documentation);
+        }
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Enhance existing task
+exports.tasksCommand
+    .command("enhance")
+    .description("Enhance an existing task with AI using Context7 documentation")
+    .option("--task-id <id>", "Task ID to enhance")
+    .option("--all", "Enhance all existing tasks")
+    .option("--stream", "Show streaming AI output during enhancement")
+    .option("--ai-provider <provider>", "AI provider override")
+    .option("--ai-model <model>", "AI model override")
+    .option("--ai-key <key>", "AI API key override")
+    .option("--ai-provider-url <url>", "AI provider URL override")
+    .option("--reasoning <tokens>", "Enable reasoning for OpenRouter models (max reasoning tokens)")
+    .action(async (options) => {
+    try {
+        if (!options.taskId && !options.all) {
+            throw new Error("Either --task-id or --all must be specified");
+        }
+        if (options.taskId && options.all) {
+            throw new Error("Cannot specify both --task-id and --all");
+        }
+        const enhanceSingleTask = async (taskId) => {
+            const streamingOptions = (0, streaming_options_1.createStreamingOptions)(options.stream, "Enhancement");
+            const result = await tasks_1.taskService.enhanceTask(taskId, {
+                aiProvider: options.aiProvider,
+                aiModel: options.aiModel,
+                aiKey: options.aiKey,
+                aiProviderUrl: options.aiProviderUrl,
+                aiReasoning: options.reasoning,
+            }, streamingOptions, {
+                onProgress: progress_1.displayProgress,
+                onError: progress_1.displayError,
+            });
+            if (result.enhancedContent.length > 200) {
+                console.log(chalk_1.default.cyan(`  Enhanced content saved to file.`));
+            }
+            else {
+                console.log(chalk_1.default.cyan(`  Enhanced content updated in task description.`));
+            }
+            console.log(chalk_1.default.green("✓ Task enhanced with Context7 documentation"));
+            console.log(chalk_1.default.magenta(`  🤖 Enhanced using Context7 MCP tools`));
+        };
+        if (options.taskId) {
+            await enhanceSingleTask(options.taskId);
+        }
+        else if (options.all) {
+            const allTasks = await tasks_1.taskService.listTasks({});
+            if (allTasks.length === 0) {
+                console.log(chalk_1.default.yellow("No tasks found to enhance."));
+                return;
+            }
+            console.log(chalk_1.default.blue(`🤖 Enhancing ${allTasks.length} tasks in order...`));
+            for (let i = 0; i < allTasks.length; i++) {
+                const task = allTasks[i];
+                console.log(chalk_1.default.cyan(`\n[${i + 1}/${allTasks.length}] Enhancing: ${task.title} (${task.id})`));
+                try {
+                    await enhanceSingleTask(task.id);
+                    console.log(chalk_1.default.green(`✓ Enhanced task ${task.id}`));
+                }
+                catch (error) {
+                    console.log(chalk_1.default.red(`❌ Failed to enhance task ${task.id}: ${error instanceof Error ? error.message : "Unknown error"}`));
+                }
+            }
+            console.log(chalk_1.default.green(`\n✓ Bulk enhancement complete! Processed ${allTasks.length} tasks.`));
+        }
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Split task into subtasks
+exports.tasksCommand
+    .command("split")
+    .description("Split a task into smaller subtasks using AI")
+    .option("--task-id <id>", "Task ID to split")
+    .option("--all", "Split all existing tasks that don't have subtasks")
+    .option("--stream", "Show streaming AI output during breakdown")
+    .option("--ai-provider <provider>", "AI provider override")
+    .option("--ai-model <model>", "AI model override")
+    .option("--ai-key <key>", "AI API key override")
+    .option("--ai-provider-url <url>", "AI provider URL override")
+    .option("--reasoning <tokens>", "Enable reasoning for OpenRouter models (max reasoning tokens)")
+    .action(async (options) => {
+    try {
+        if (!options.taskId && !options.all) {
+            throw new Error("Either --task-id or --all must be specified");
+        }
+        if (options.taskId && options.all) {
+            throw new Error("Cannot specify both --task-id and --all");
+        }
+        const splitSingleTask = async (taskId) => {
+            const streamingOptions = (0, streaming_options_1.createStreamingOptions)(options.stream, "Task breakdown");
+            try {
+                const result = await tasks_1.taskService.splitTask(taskId, {
+                    aiProvider: options.aiProvider,
+                    aiModel: options.aiModel,
+                    aiKey: options.aiKey,
+                    aiProviderUrl: options.aiProviderUrl,
+                    aiReasoning: options.reasoning,
+                }, undefined, undefined, streamingOptions, {
+                    onProgress: progress_1.displayProgress,
+                    onError: progress_1.displayError,
+                });
+                (0, task_1.displaySubtaskCreation)(result.subtasks);
+                // Display AI metadata
+                console.log(chalk_1.default.gray(`\n📊 AI Splitting Details:`));
+                console.log(chalk_1.default.gray(`   Provider: ${result.metadata.aiProvider}`));
+                console.log(chalk_1.default.gray(`   Model: ${result.metadata.aiModel}`));
+                console.log(chalk_1.default.gray(`   Subtasks created: ${result.subtasks.length}`));
+                console.log(chalk_1.default.gray(`   Confidence: ${result.metadata.confidence ? (result.metadata.confidence * 100).toFixed(1) : "N/A"}%`));
+            }
+            catch (error) {
+                if (error instanceof Error && error.message.includes("already has")) {
+                    console.log(chalk_1.default.yellow(`⚠️ ${error.message}`));
+                    return;
+                }
+                throw error;
+            }
+        };
+        if (options.taskId) {
+            await splitSingleTask(options.taskId);
+        }
+        else if (options.all) {
+            const allTasks = await tasks_1.taskService.listTasks({});
+            if (allTasks.length === 0) {
+                console.log(chalk_1.default.yellow("No tasks found to split."));
+                return;
+            }
+            console.log(chalk_1.default.blue(`🔧 Splitting ${allTasks.length} tasks...`));
+            for (let i = 0; i < allTasks.length; i++) {
+                const task = allTasks[i];
+                console.log(chalk_1.default.cyan(`\n[${i + 1}/${allTasks.length}] Splitting: ${task.title}`));
+                try {
+                    await splitSingleTask(task.id);
+                }
+                catch (error) {
+                    console.log(chalk_1.default.red(`❌ Failed to split task ${task.id}: ${error instanceof Error ? error.message : "Unknown error"}`));
+                }
+            }
+            console.log(chalk_1.default.green(`\n✓ Bulk splitting complete! Processed ${allTasks.length} tasks.`));
+        }
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Plan task implementation
+exports.tasksCommand
+    .command("plan")
+    .description("Create detailed implementation plan for a task or subtask")
+    .requiredOption("--id <id>", "Task or subtask ID to plan")
+    .option("--stream", "Show streaming AI output during planning")
+    .option("--ai-provider <provider>", "AI provider override")
+    .option("--ai-model <model>", "AI model override")
+    .option("--ai-key <key>", "AI API key override")
+    .option("--ai-provider-url <url>", "AI provider URL override")
+    .option("--reasoning <tokens>", "Enable reasoning for OpenRouter models (max reasoning tokens)")
+    .action(async (options) => {
+    try {
+        const streamingOptions = (0, streaming_options_1.createStreamingOptions)(options.stream, "Planning");
+        const result = await tasks_1.taskService.planTask(options.id, {
+            aiProvider: options.aiProvider,
+            aiModel: options.aiModel,
+            aiKey: options.aiKey,
+            aiProviderUrl: options.aiProviderUrl,
+            aiReasoning: options.reasoning,
+        }, streamingOptions, {
+            onProgress: progress_1.displayProgress,
+            onError: progress_1.displayError,
+        });
+        // Display the plan
+        (0, plan_1.displayPlanCreation)(options.id, result.task.title);
+        console.log(chalk_1.default.cyan(result.plan));
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Get plan command
+exports.tasksCommand
+    .command("get-plan")
+    .description("View existing implementation plan for a task or subtask")
+    .requiredOption("--id <id>", "Task or subtask ID")
+    .action(async (options) => {
+    try {
+        const plan = await tasks_1.taskService.getTaskPlan(options.id);
+        if (!plan) {
+            console.log(chalk_1.default.yellow(`⚠️  No plan found for task/subtask ${options.id}`));
+            return;
+        }
+        const task = await tasks_1.taskService.getTask(options.id);
+        const taskTitle = task ? task.title : options.id;
+        (0, plan_1.displayPlanView)(taskTitle, options.id, plan.plan, plan.createdAt, plan.updatedAt);
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// List plans command
+exports.tasksCommand
+    .command("list-plan")
+    .description("List all available implementation plans")
+    .action(async () => {
+    try {
+        const plans = await tasks_1.taskService.listTaskPlans();
+        // Get task titles for each plan
+        const plansWithTitles = await Promise.all(plans.map(async (plan) => {
+            const task = await tasks_1.taskService.getTask(plan.taskId);
+            return {
+                ...plan,
+                taskTitle: task ? task.title : plan.taskId,
+            };
+        }));
+        (0, plan_1.displayPlanList)(plansWithTitles);
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Update task command
+exports.tasksCommand
+    .command("update")
+    .description("Update an existing task")
+    .requiredOption("--id <id>", "Task ID to update")
+    .option("--title <title>", "New task title")
+    .option("--description <description>", "New task description")
+    .option("--status <status>", "New status (todo/in-progress/completed)")
+    .option("--effort <effort>", "New estimated effort (small/medium/large)")
+    .option("--tags <tags>", "New tags (comma-separated)")
+    .action(async (options) => {
+    try {
+        const { id, ...updates } = options;
+        if (Object.keys(updates).length === 0) {
+            throw new Error("At least one field must be specified for update");
+        }
+        const updatedTask = await tasks_1.taskService.updateTask(id, {
+            title: updates.title,
+            description: updates.description,
+            status: updates.status,
+            effort: updates.effort,
+            tags: updates.tags,
+        });
+        (0, task_1.displayTaskUpdate)(updatedTask, updates);
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Delete task command
+exports.tasksCommand
+    .command("delete")
+    .description("Delete a task")
+    .requiredOption("--id <id>", "Task ID to delete")
+    .option("--force", "Skip confirmation and delete anyway")
+    .option("--cascade", "Delete all subtasks as well")
+    .action(async (options) => {
+    try {
+        if (!options.force) {
+            const task = await tasks_1.taskService.getTask(options.id);
+            if (!task) {
+                throw new Error(`Task with ID ${options.id} not found`);
+            }
+            console.log(chalk_1.default.red(`\n⚠️  Are you sure you want to delete task: ${task.title} (${task.id})?`));
+            console.log(chalk_1.default.red("This action cannot be undone."));
+            // Simple confirmation - in a real CLI you might want a proper prompt
+            console.log(chalk_1.default.yellow("Use --force to confirm deletion."));
+            return;
+        }
+        const result = await tasks_1.taskService.deleteTask(options.id, {
+            cascade: options.cascade,
+            force: options.force,
+        });
+        (0, task_1.displayTaskDelete)(result.deleted, result.orphanedSubtasks);
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Set status command
+exports.tasksCommand
+    .command("status")
+    .description("Set task status")
+    .requiredOption("--id <id>", "Task ID")
+    .requiredOption("--status <status>", "New status (todo/in-progress/completed)")
+    .action(async (options) => {
+    try {
+        const task = await tasks_1.taskService.getTask(options.id);
+        if (!task) {
+            throw new Error(`Task with ID ${options.id} not found`);
+        }
+        const oldStatus = task.status;
+        const updatedTask = await tasks_1.taskService.setTaskStatus(options.id, options.status);
+        (0, task_1.displayTaskStatusChange)(updatedTask, oldStatus, options.status);
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Add tags command
+exports.tasksCommand
+    .command("add-tags")
+    .description("Add tags to a task")
+    .requiredOption("--id <id>", "Task ID")
+    .requiredOption("--tags <tags>", "Tags to add (comma-separated)")
+    .action(async (options) => {
+    try {
+        const tags = options.tags.split(',').map((tag) => tag.trim());
+        const updatedTask = await tasks_1.taskService.addTags(options.id, tags);
+        (0, task_1.displayTagsUpdate)(updatedTask, tags, []);
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Remove tags command
+exports.tasksCommand
+    .command("remove-tags")
+    .description("Remove tags from a task")
+    .requiredOption("--id <id>", "Task ID")
+    .requiredOption("--tags <tags>", "Tags to remove (comma-separated)")
+    .action(async (options) => {
+    try {
+        const tags = options.tags.split(',').map((tag) => tag.trim());
+        const updatedTask = await tasks_1.taskService.removeTags(options.id, tags);
+        (0, task_1.displayTagsUpdate)(updatedTask, [], tags);
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Delete plan command
+exports.tasksCommand
+    .command("delete-plan")
+    .description("Delete implementation plan for a task")
+    .requiredOption("--id <id>", "Task ID")
+    .action(async (options) => {
+    try {
+        const success = await tasks_1.taskService.deleteTaskPlan(options.id);
+        (0, plan_1.displayPlanDeletion)(options.id, success);
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// List subtasks command
+exports.tasksCommand
+    .command("subtasks")
+    .description("List subtasks for a task")
+    .requiredOption("--id <id>", "Parent task ID")
+    .action(async (options) => {
+    try {
+        const subtasks = await tasks_1.taskService.getSubtasks(options.id);
+        if (subtasks.length === 0) {
+            console.log(chalk_1.default.yellow(`No subtasks found for task ${options.id}`));
+            return;
+        }
+        const parentTask = await tasks_1.taskService.getTask(options.id);
+        const parentTitle = parentTask ? parentTask.title : options.id;
+        console.log(chalk_1.default.blue(`\n📋 Subtasks for ${parentTitle} (${options.id}):`));
+        console.log("");
+        for (let i = 0; i < subtasks.length; i++) {
+            const subtask = subtasks[i];
+            await (0, task_1.displayTask)(subtask, { indent: '  ', showSubtasks: false });
+        }
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Task tree command
+exports.tasksCommand
+    .command("tree")
+    .description("Display hierarchical task tree")
+    .option("--id <id>", "Root task ID (optional - shows full tree if not specified)")
+    .action(async (options) => {
+    try {
+        const tasks = await tasks_1.taskService.getTaskTree(options.id);
+        await (0, task_1.displayTaskTree)(tasks, options.id);
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Get next task command
+exports.tasksCommand
+    .command("get-next")
+    .description("Get the next task to work on (defaults to hierarchical order)")
+    .option("--status <status>", "Filter by status (todo/in-progress)")
+    .option("--tag <tag>", "Filter by tag")
+    .option("--effort <effort>", "Filter by effort (small/medium/large)")
+    .option("--priority <priority>", "Sort priority (newest/oldest/effort)", "hierarchical")
+    .action(async (options) => {
+    try {
+        // Default to todo status if not specified
+        const searchOptions = {
+            ...options,
+            status: options.status || "todo"
+        };
+        const nextTask = await tasks_1.taskService.getNextTask(searchOptions);
+        if (!nextTask) {
+            console.log(chalk_1.default.yellow("No tasks found matching the criteria."));
+            return;
+        }
+        const criteria = [
+            searchOptions.status && `status: ${searchOptions.status}`,
+            options.tag && `tag: ${options.tag}`,
+            options.effort && `effort: ${options.effort}`,
+            options.priority && `priority: ${options.priority}`
+        ].filter(Boolean).join(", ");
+        (0, task_1.displayNextTask)(nextTask, criteria || "next todo task");
+    }
+    catch (error) {
+        (0, progress_1.displayError)(error);
+        process.exit(1);
+    }
+});
+// Execute task command
+exports.tasksCommand
+    .command("execute")
+    .description("Execute a task using an external coding assistant")
+    .requiredOption("--id <id>", "Task ID to execute")
+    .option("--tool <tool>", "External tool to use (opencode/claude/gemini/codex)", "opencode")
+    .option("--message <message>", "Custom message to send to the tool (uses task plan if not provided)")
+    .option("--dry", "Show what would be executed without running it")
+    .option("--validate <command>", "Validation command to run after execution (can be used multiple times)", (value, previous = []) => {
+    return [...previous, value];
+})
+    .action(async (options) => {
+    try {
+        await (0, task_execution_1.executeTask)({
+            taskId: options.id,
+            tool: options.tool,
+            message: options.message,
+            dry: options.dry,
+            validate: options.validate || [],
+        });
+    }
+    catch (error) {
+        console.error(chalk_1.default.red("Execution failed:"), error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+    }
+});

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * task-o-matic CLI Logic
+ *
+ * This module contains the CLI setup and command definitions.
+ * It can be imported and used by the binary or for testing.
+ */
+import { Command } from "commander";
+declare const program: Command;
+/**
+ * Run the CLI
+ * This is the main entry point for the CLI, called by the bin script
+ */
+export declare const runCLI: () => Promise<void>;
+/**
+ * Export the program for testing purposes
+ */
+export { program };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,QAAA,MAAM,OAAO,SAAgB,CAAC;AA6C9B;;;GAGG;AACH,eAAO,MAAM,MAAM,qBAUlB,CAAC;AAEF;;GAEG;AACH,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/dist/index.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * task-o-matic CLI Logic
+ *
+ * This module contains the CLI setup and command definitions.
+ * It can be imported and used by the binary or for testing.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.program = exports.runCLI = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const config_1 = require("./commands/config");
+const tasks_1 = require("./commands/tasks");
+const prd_1 = require("./commands/prd");
+const init_1 = require("./commands/init");
+const prompt_1 = require("./commands/prompt");
+const config_2 = require("./lib/config");
+const program = new commander_1.Command();
+exports.program = program;
+program
+    .name("task-o-matic")
+    .description("AI-powered Task Management CLI for Single Projects")
+    .version("0.1.0")
+    .option("-v, --verbose", "Enable verbose logging");
+// Add subcommands
+program.addCommand(config_1.configCommand);
+program.addCommand(tasks_1.tasksCommand);
+program.addCommand(prd_1.prdCommand);
+program.addCommand(prompt_1.promptCommand);
+program.addCommand(init_1.initCommand);
+// Default action - show help
+program.action(() => {
+    console.log(chalk_1.default.blue("🚀 AI-Powered Task Management CLI"));
+    console.log(chalk_1.default.cyan(`Project Directory: ${config_2.configManager.getTaskOMaticDir()}`));
+    console.log("");
+    console.log(chalk_1.default.yellow("Quick Start:"));
+    console.log("  1. Initialize project: task-o-matic init");
+    console.log("  2. Configure AI provider: task-o-matic config set-ai-provider openrouter anthropic/claude-3.5-sonnet");
+    console.log('  3. Create a task: task-o-matic tasks create --title "Your first task"');
+    console.log("  4. List tasks: task-o-matic tasks list");
+    console.log("");
+    program.outputHelp();
+});
+// Error handling
+program.on("command:*", (operands) => {
+    console.error(chalk_1.default.red(`Unknown command: ${operands[0]}`));
+    console.log(chalk_1.default.blue("Available commands: config, tasks, prd, prompt, init"));
+    console.log(chalk_1.default.blue("Use --help for available commands"));
+    process.exit(1);
+});
+/**
+ * Run the CLI
+ * This is the main entry point for the CLI, called by the bin script
+ */
+const runCLI = async () => {
+    try {
+        await program.parseAsync(process.argv);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red("Error:"), error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+    }
+};
+exports.runCLI = runCLI;