task-o-matic 0.0.1

package/dist/services/tasks.js

@@ -0,0 +1,596 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.taskService = exports.TaskService = void 0;
+const ai_service_factory_1 = require("../utils/ai-service-factory");
+const stack_formatter_1 = require("../utils/stack-formatter");
+const ai_config_builder_1 = require("../utils/ai-config-builder");
+/**
+ * TaskService - Centralized business logic for all task operations
+ * This service is framework-agnostic and can be used by CLI, TUI, or Web
+ */
+class TaskService {
+    // ============================================================================
+    // CORE CRUD OPERATIONS
+    // ============================================================================
+    async createTask(input) {
+        const startTime = Date.now();
+        let content = input.content;
+        let aiMetadata;
+        if (input.aiEnhance) {
+            input.callbacks?.onProgress?.({
+                type: 'progress',
+                message: 'Building context for task...',
+            });
+            const context = await (0, ai_service_factory_1.getContextBuilder)().buildContextForNewTask(input.title, input.content);
+            const stackInfo = (0, stack_formatter_1.formatStackInfo)(context.stack);
+            const enhancementAIConfig = (0, ai_config_builder_1.buildAIConfig)(input.aiOptions);
+            input.callbacks?.onProgress?.({
+                type: 'progress',
+                message: 'Enhancing task with AI documentation...',
+            });
+            const taskDescription = input.content ?? "";
+            content = await (0, ai_service_factory_1.getAIOperations)().enhanceTaskWithDocumentation(`task-${Date.now()}`, input.title, taskDescription, stackInfo, input.streamingOptions, undefined, enhancementAIConfig, context.existingResearch);
+            const aiConfig = (0, ai_service_factory_1.getModelProvider)().getAIConfig();
+            aiMetadata = {
+                taskId: "",
+                aiGenerated: true,
+                aiPrompt: "Enhance task with relevant documentation using Context7 tools",
+                confidence: 0.9,
+                aiProvider: aiConfig.provider,
+                aiModel: aiConfig.model,
+                generatedAt: Date.now(),
+            };
+        }
+        input.callbacks?.onProgress?.({
+            type: 'progress',
+            message: 'Saving task...',
+        });
+        const task = await (0, ai_service_factory_1.getStorage)().createTask({
+            title: input.title,
+            description: input.content ?? "",
+            content,
+            parentId: input.parentId,
+            estimatedEffort: input.effort,
+        }, aiMetadata);
+        input.callbacks?.onProgress?.({
+            type: 'completed',
+            message: 'Task created successfully',
+        });
+        return { success: true, task, aiMetadata };
+    }
+    async listTasks(filters) {
+        const storage = (0, ai_service_factory_1.getStorage)();
+        const topLevelTasks = await storage.getTopLevelTasks();
+        let filteredTasks = topLevelTasks;
+        if (filters.status) {
+            filteredTasks = filteredTasks.filter((task) => task.status === filters.status);
+        }
+        if (filters.tag) {
+            const tagToFilter = filters.tag; // Type narrowing
+            filteredTasks = filteredTasks.filter((task) => task.tags && task.tags.includes(tagToFilter));
+        }
+        return filteredTasks;
+    }
+    async getTask(id) {
+        return await (0, ai_service_factory_1.getStorage)().getTask(id);
+    }
+    async getTaskContent(id) {
+        return await (0, ai_service_factory_1.getStorage)().getTaskContent(id);
+    }
+    async getTaskAIMetadata(id) {
+        return await (0, ai_service_factory_1.getStorage)().getTaskAIMetadata(id);
+    }
+    async getSubtasks(id) {
+        return await (0, ai_service_factory_1.getStorage)().getSubtasks(id);
+    }
+    async updateTask(id, updates) {
+        const storage = (0, ai_service_factory_1.getStorage)();
+        const existingTask = await storage.getTask(id);
+        if (!existingTask) {
+            throw new Error(`Task with ID ${id} not found`);
+        }
+        // Validate status transitions
+        if (updates.status) {
+            const validTransitions = {
+                todo: ["in-progress", "completed"],
+                "in-progress": ["completed", "todo"],
+                completed: ["todo", "in-progress"],
+            };
+            if (!validTransitions[existingTask.status].includes(updates.status)) {
+                throw new Error(`Invalid status transition from ${existingTask.status} to ${updates.status}`);
+            }
+        }
+        const finalUpdates = { ...updates };
+        // Handle tags: convert comma-separated string to array and merge
+        if (typeof updates.tags === "string") {
+            const newTags = updates.tags.split(",").map((tag) => tag.trim());
+            const existingTags = existingTask.tags || [];
+            finalUpdates.tags = [...new Set([...existingTags, ...newTags])];
+        }
+        const updatedTask = await storage.updateTask(id, finalUpdates);
+        if (!updatedTask) {
+            throw new Error(`Failed to update task ${id}`);
+        }
+        return updatedTask;
+    }
+    async setTaskStatus(id, status) {
+        return await this.updateTask(id, { status });
+    }
+    async deleteTask(id, options = {}) {
+        const { cascade, force } = options;
+        const storage = (0, ai_service_factory_1.getStorage)();
+        const taskToDelete = await storage.getTask(id);
+        if (!taskToDelete) {
+            throw new Error(`Task with ID ${id} not found`);
+        }
+        const deleted = [];
+        const orphanedSubtasks = [];
+        // Get subtasks before deletion
+        const subtasks = await storage.getSubtasks(id);
+        if (subtasks.length > 0 && !cascade) {
+            if (!force) {
+                throw new Error(`Task has ${subtasks.length} subtasks. Use cascade to delete them or force to orphan them`);
+            }
+            // Orphan subtasks by removing parent reference
+            for (const subtask of subtasks) {
+                await storage.updateTask(subtask.id, { parentId: undefined });
+                orphanedSubtasks.push(subtask);
+            }
+        }
+        else if (cascade) {
+            // Recursively delete subtasks
+            for (const subtask of subtasks) {
+                const result = await this.deleteTask(subtask.id, { cascade: true, force: true });
+                deleted.push(...result.deleted);
+                orphanedSubtasks.push(...result.orphanedSubtasks);
+            }
+        }
+        // Delete the main task
+        const success = await storage.deleteTask(id);
+        if (success) {
+            deleted.push(taskToDelete);
+        }
+        return { success: true, deleted, orphanedSubtasks };
+    }
+    // ============================================================================
+    // TAG OPERATIONS
+    // ============================================================================
+    async addTags(id, tags) {
+        const storage = (0, ai_service_factory_1.getStorage)();
+        const task = await storage.getTask(id);
+        if (!task) {
+            throw new Error(`Task with ID ${id} not found`);
+        }
+        const existingTags = task.tags || [];
+        const newTags = tags.filter((tag) => !existingTags.includes(tag));
+        if (newTags.length === 0) {
+            return task; // No new tags to add
+        }
+        const updatedTags = [...existingTags, ...newTags];
+        const updatedTask = await storage.updateTask(id, { tags: updatedTags });
+        if (!updatedTask) {
+            throw new Error(`Failed to add tags to task ${id}`);
+        }
+        return updatedTask;
+    }
+    async removeTags(id, tags) {
+        const storage = (0, ai_service_factory_1.getStorage)();
+        const task = await storage.getTask(id);
+        if (!task) {
+            throw new Error(`Task with ID ${id} not found`);
+        }
+        const existingTags = task.tags || [];
+        const updatedTags = existingTags.filter((tag) => !tags.includes(tag));
+        if (updatedTags.length === existingTags.length) {
+            return task; // No tags removed
+        }
+        const updatedTask = await storage.updateTask(id, { tags: updatedTags });
+        if (!updatedTask) {
+            throw new Error(`Failed to remove tags from task ${id}`);
+        }
+        return updatedTask;
+    }
+    // ============================================================================
+    // TASK NAVIGATION
+    // ============================================================================
+    async getNextTask(filters) {
+        const storage = (0, ai_service_factory_1.getStorage)();
+        const allTasks = await storage.getTasks();
+        // Filter by status and other criteria
+        let filteredTasks = allTasks.filter((task) => {
+            if (filters.status && task.status !== filters.status)
+                return false;
+            if (filters.tag && (!task.tags || !task.tags.includes(filters.tag)))
+                return false;
+            if (filters.effort && task.estimatedEffort !== filters.effort)
+                return false;
+            return true;
+        });
+        if (filteredTasks.length === 0)
+            return null;
+        // Sort based on priority
+        switch (filters.priority) {
+            case "newest":
+                return filteredTasks.sort((a, b) => b.createdAt - a.createdAt)[0];
+            case "oldest":
+                return filteredTasks.sort((a, b) => a.createdAt - b.createdAt)[0];
+            case "effort":
+                const effortOrder = { small: 1, medium: 2, large: 3 };
+                return filteredTasks.sort((a, b) => (effortOrder[a.estimatedEffort || "medium"] || 2) -
+                    (effortOrder[b.estimatedEffort || "medium"] || 2))[0];
+            default:
+                // Default: task ID order (1, 1.1, 1.2, 2, 2.1, etc.)
+                return filteredTasks.sort((a, b) => a.id.localeCompare(b.id))[0];
+        }
+    }
+    async getTaskTree(rootId) {
+        const storage = (0, ai_service_factory_1.getStorage)();
+        if (rootId) {
+            // Return tree starting from specific task
+            const rootTask = await storage.getTask(rootId);
+            if (!rootTask) {
+                throw new Error(`Task with ID ${rootId} not found`);
+            }
+            // Get all subtasks recursively
+            const getAllSubtasks = async (task) => {
+                const subtasks = await storage.getSubtasks(task.id);
+                const allSubtasks = [];
+                for (const subtask of subtasks) {
+                    allSubtasks.push(subtask);
+                    const deeperSubtasks = await getAllSubtasks(subtask);
+                    allSubtasks.push(...deeperSubtasks);
+                }
+                return allSubtasks;
+            };
+            const subtasks = await getAllSubtasks(rootTask);
+            return [rootTask, ...subtasks];
+        }
+        else {
+            // Return all top-level tasks and their subtasks
+            return await storage.getTasks();
+        }
+    }
+    // ============================================================================
+    // AI OPERATIONS
+    // ============================================================================
+    async enhanceTask(taskId, aiOptions, streamingOptions, callbacks) {
+        const startTime = Date.now();
+        callbacks?.onProgress?.({
+            type: 'started',
+            message: 'Starting task enhancement...',
+        });
+        const task = await (0, ai_service_factory_1.getStorage)().getTask(taskId);
+        if (!task) {
+            throw new Error(`Task with ID ${taskId} not found`);
+        }
+        callbacks?.onProgress?.({
+            type: 'progress',
+            message: 'Building context...',
+        });
+        const context = await (0, ai_service_factory_1.getContextBuilder)().buildContext(taskId);
+        const stackInfo = (0, stack_formatter_1.formatStackInfo)(context.stack);
+        const enhancementAIConfig = (0, ai_config_builder_1.buildAIConfig)(aiOptions);
+        callbacks?.onProgress?.({
+            type: 'progress',
+            message: 'Calling AI for enhancement...',
+        });
+        const enhancedContent = await (0, ai_service_factory_1.getAIOperations)().enhanceTaskWithDocumentation(task.id, task.title, task.description ?? "", stackInfo, streamingOptions, undefined, enhancementAIConfig, context.existingResearch);
+        callbacks?.onProgress?.({
+            type: 'progress',
+            message: 'Saving enhanced content...',
+        });
+        const originalLength = task.description?.length || 0;
+        if (enhancedContent.length > 200) {
+            const contentFile = await (0, ai_service_factory_1.getStorage)().saveEnhancedTaskContent(task.id, enhancedContent);
+            await (0, ai_service_factory_1.getStorage)().updateTask(task.id, {
+                contentFile,
+                description: task.description +
+                    "\n\n🤖 AI-enhanced with Context7 documentation available.",
+            });
+        }
+        else {
+            await (0, ai_service_factory_1.getStorage)().updateTask(task.id, { description: enhancedContent });
+        }
+        const aiConfig = (0, ai_service_factory_1.getModelProvider)().getAIConfig();
+        const aiMetadata = {
+            taskId: task.id,
+            aiGenerated: true,
+            aiPrompt: "Enhance task with Context7 documentation using MCP tools",
+            confidence: 0.9,
+            aiProvider: aiConfig.provider,
+            aiModel: aiConfig.model,
+            enhancedAt: Date.now(),
+        };
+        await (0, ai_service_factory_1.getStorage)().saveTaskAIMetadata(aiMetadata);
+        const duration = Date.now() - startTime;
+        callbacks?.onProgress?.({
+            type: 'completed',
+            message: 'Task enhancement completed',
+        });
+        return {
+            success: true,
+            task,
+            enhancedContent,
+            stats: {
+                originalLength,
+                enhancedLength: enhancedContent.length,
+                duration,
+            },
+            metadata: {
+                aiProvider: aiConfig.provider,
+                aiModel: aiConfig.model,
+                confidence: 0.9,
+            },
+        };
+    }
+    async splitTask(taskId, aiOptions, promptOverride, messageOverride, streamingOptions, callbacks) {
+        const startTime = Date.now();
+        callbacks?.onProgress?.({
+            type: 'started',
+            message: 'Starting task breakdown...',
+        });
+        const task = await (0, ai_service_factory_1.getStorage)().getTask(taskId);
+        if (!task) {
+            throw new Error(`Task with ID ${taskId} not found`);
+        }
+        // Check if task already has subtasks
+        const existingSubtasks = await (0, ai_service_factory_1.getStorage)().getSubtasks(taskId);
+        if (existingSubtasks.length > 0) {
+            throw new Error(`Task ${task.title} already has ${existingSubtasks.length} subtasks. Use existing subtasks or delete them first.`);
+        }
+        callbacks?.onProgress?.({
+            type: 'progress',
+            message: 'Building context...',
+        });
+        // Build comprehensive context
+        const context = await (0, ai_service_factory_1.getContextBuilder)().buildContext(taskId);
+        const stackInfo = (0, stack_formatter_1.formatStackInfo)(context.stack);
+        // Get full task content
+        const fullContent = context.task.fullContent || task.description || "";
+        const breakdownAIConfig = (0, ai_config_builder_1.buildAIConfig)(aiOptions);
+        callbacks?.onProgress?.({
+            type: 'progress',
+            message: 'Calling AI to break down task...',
+        });
+        // Use AI service to break down the task with enhanced context
+        const subtaskData = await (0, ai_service_factory_1.getAIOperations)().breakdownTask(task, breakdownAIConfig, promptOverride, messageOverride, streamingOptions, undefined, fullContent, stackInfo, existingSubtasks);
+        callbacks?.onProgress?.({
+            type: 'progress',
+            message: `Creating ${subtaskData.length} subtasks...`,
+        });
+        // Create subtasks
+        const createdSubtasks = [];
+        for (let i = 0; i < subtaskData.length; i++) {
+            const subtask = subtaskData[i];
+            callbacks?.onProgress?.({
+                type: 'progress',
+                message: `Creating subtask ${i + 1}/${subtaskData.length}: ${subtask.title}`,
+                current: i + 1,
+                total: subtaskData.length,
+            });
+            const result = await this.createTask({
+                title: subtask.title,
+                content: subtask.content,
+                effort: subtask.estimatedEffort,
+                parentId: taskId,
+            });
+            createdSubtasks.push(result.task);
+        }
+        // Create AI metadata for tracking using actual AI config
+        const aiConfig = (0, ai_service_factory_1.getModelProvider)().getAIConfig();
+        const aiMetadata = {
+            taskId: task.id,
+            aiGenerated: true,
+            aiPrompt: promptOverride ||
+                "Split task into meaningful subtasks with full context and existing subtask awareness",
+            confidence: 0.9,
+            aiProvider: aiConfig.provider,
+            aiModel: aiConfig.model,
+            splitAt: Date.now(),
+        };
+        await (0, ai_service_factory_1.getStorage)().saveTaskAIMetadata(aiMetadata);
+        const duration = Date.now() - startTime;
+        callbacks?.onProgress?.({
+            type: 'completed',
+            message: `Task split into ${createdSubtasks.length} subtasks`,
+        });
+        return {
+            success: true,
+            task,
+            subtasks: createdSubtasks,
+            stats: {
+                subtasksCreated: createdSubtasks.length,
+                duration,
+            },
+            metadata: {
+                aiProvider: aiConfig.provider,
+                aiModel: aiConfig.model,
+                confidence: 0.9,
+            },
+        };
+    }
+    async documentTask(taskId, force = false, aiOptions, streamingOptions, callbacks) {
+        const startTime = Date.now();
+        callbacks?.onProgress?.({
+            type: 'started',
+            message: 'Analyzing documentation needs...',
+        });
+        const task = await (0, ai_service_factory_1.getStorage)().getTask(taskId);
+        if (!task) {
+            throw new Error(`Task with ID ${taskId} not found`);
+        }
+        if (task.documentation && !force) {
+            if ((0, ai_service_factory_1.getContextBuilder)().isDocumentationFresh(task.documentation)) {
+                callbacks?.onProgress?.({
+                    type: 'info',
+                    message: 'Documentation is fresh, skipping analysis',
+                });
+                return {
+                    success: true,
+                    task,
+                    documentation: task.documentation,
+                    stats: {
+                        duration: Date.now() - startTime,
+                    },
+                };
+            }
+        }
+        callbacks?.onProgress?.({
+            type: 'progress',
+            message: 'Building context...',
+        });
+        const context = await (0, ai_service_factory_1.getContextBuilder)().buildContext(taskId);
+        const stackInfo = (0, stack_formatter_1.formatStackInfo)(context.stack);
+        const analysisAIConfig = (0, ai_config_builder_1.buildAIConfig)(aiOptions);
+        // Get full task content
+        const fullContent = context.task.fullContent || task.description;
+        if (!fullContent) {
+            throw new Error("Task content is empty");
+        }
+        // Get existing documentations from all tasks
+        const tasks = await (0, ai_service_factory_1.getStorage)().getTasks();
+        const documentations = tasks.map((task) => task.documentation);
+        callbacks?.onProgress?.({
+            type: 'progress',
+            message: 'Calling AI to analyze documentation needs...',
+        });
+        // First analyze what documentation is needed
+        const analysis = await (0, ai_service_factory_1.getAIOperations)().analyzeDocumentationNeeds(task.id, task.title, fullContent, stackInfo, streamingOptions, undefined, analysisAIConfig, documentations);
+        let documentation;
+        if (analysis.libraries.length > 0) {
+            callbacks?.onProgress?.({
+                type: 'progress',
+                message: `Fetching documentation for ${analysis.libraries.length} libraries...`,
+            });
+            // Build research object from actual libraries
+            const research = {};
+            for (const lib of analysis.libraries) {
+                const sanitizedLibrary = (0, ai_service_factory_1.getStorage)().sanitizeForFilename(lib.name);
+                const sanitizedQuery = (0, ai_service_factory_1.getStorage)().sanitizeForFilename(lib.searchQuery);
+                const docFile = `docs/${sanitizedLibrary}/${sanitizedQuery}.md`;
+                if (!research[lib.name]) {
+                    research[lib.name] = [];
+                }
+                research[lib.name].push({
+                    query: lib.searchQuery,
+                    doc: docFile,
+                });
+            }
+            callbacks?.onProgress?.({
+                type: 'progress',
+                message: 'Generating documentation recap...',
+            });
+            const recap = await (0, ai_service_factory_1.getAIOperations)().generateDocumentationRecap(analysis.libraries, analysis.toolResults?.map((tr) => ({
+                library: tr.toolName,
+                content: JSON.stringify(tr.output),
+            })) || [], streamingOptions);
+            documentation = {
+                lastFetched: Date.now(),
+                libraries: analysis.libraries.map((lib) => lib.context7Id),
+                recap,
+                files: analysis.files || [],
+                research,
+            };
+            callbacks?.onProgress?.({
+                type: 'progress',
+                message: 'Saving documentation...',
+            });
+            await (0, ai_service_factory_1.getStorage)().updateTask(taskId, { documentation });
+        }
+        const duration = Date.now() - startTime;
+        callbacks?.onProgress?.({
+            type: 'completed',
+            message: 'Documentation analysis completed',
+        });
+        return {
+            success: true,
+            task,
+            analysis,
+            documentation,
+            stats: {
+                duration,
+            },
+        };
+    }
+    async planTask(taskId, aiOptions, streamingOptions, callbacks) {
+        const startTime = Date.now();
+        callbacks?.onProgress?.({
+            type: 'started',
+            message: 'Creating implementation plan...',
+        });
+        const task = await (0, ai_service_factory_1.getStorage)().getTask(taskId);
+        if (!task) {
+            throw new Error(`Task with ID ${taskId} not found`);
+        }
+        const aiService = (0, ai_service_factory_1.getAIOperations)();
+        const planAIConfig = (0, ai_config_builder_1.buildAIConfig)(aiOptions);
+        callbacks?.onProgress?.({
+            type: 'progress',
+            message: 'Building task context...',
+        });
+        // Build task context and details
+        let taskContext = `Task ID: ${task.id}\nTitle: ${task.title}\n`;
+        let taskDetails = `Description: ${task.description || "No description"}\n`;
+        // If this is a subtask, include parent task context
+        if (task.parentId) {
+            const parentTask = await (0, ai_service_factory_1.getStorage)().getTask(task.parentId);
+            if (parentTask) {
+                taskContext += `Parent Task ID: ${parentTask.id}\nParent Task Title: ${parentTask.title}\n`;
+                taskDetails += `Parent Task Description: ${parentTask.description || "No description"}\n`;
+            }
+        }
+        // If this is a task with subtasks, get subtask details
+        const subtasks = await (0, ai_service_factory_1.getStorage)().getSubtasks(taskId);
+        if (subtasks.length > 0) {
+            taskDetails += `\nSubtasks:\n`;
+            subtasks.forEach((subtask, index) => {
+                taskDetails += `${index + 1}. ${subtask.title} (${subtask.id})\n`;
+                taskDetails += `   ${subtask.description || "No description"}\n\n`;
+            });
+        }
+        callbacks?.onProgress?.({
+            type: 'progress',
+            message: 'Calling AI to create plan...',
+        });
+        const plan = await aiService.planTask(taskContext, taskDetails, planAIConfig, undefined, undefined, streamingOptions);
+        callbacks?.onProgress?.({
+            type: 'progress',
+            message: 'Saving plan...',
+        });
+        // Save the plan to storage
+        await (0, ai_service_factory_1.getStorage)().savePlan(taskId, plan);
+        const duration = Date.now() - startTime;
+        callbacks?.onProgress?.({
+            type: 'completed',
+            message: 'Implementation plan created',
+        });
+        const aiConfig = (0, ai_service_factory_1.getModelProvider)().getAIConfig();
+        return {
+            success: true,
+            task,
+            plan,
+            stats: {
+                duration,
+            },
+            metadata: {
+                aiProvider: aiConfig.provider,
+                aiModel: aiConfig.model,
+            },
+        };
+    }
+    // ============================================================================
+    // PLAN OPERATIONS
+    // ============================================================================
+    async getTaskPlan(taskId) {
+        return (0, ai_service_factory_1.getStorage)().getPlan(taskId);
+    }
+    async listTaskPlans() {
+        return (0, ai_service_factory_1.getStorage)().listPlans();
+    }
+    async deleteTaskPlan(taskId) {
+        return (0, ai_service_factory_1.getStorage)().deletePlan(taskId);
+    }
+}
+exports.TaskService = TaskService;
+// Export singleton instance
+exports.taskService = new TaskService();

package/dist/test/commands.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=commands.test.d.ts.map

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

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

package/dist/test/commands.test.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const assert = __importStar(require("assert"));
+describe("CLI Commands", () => {
+    it("should show help for the main command", (done) => {
+        (0, child_process_1.exec)("npx tsx src/cli/bin.ts --help", (error, stdout, stderr) => {
+            assert.strictEqual(error, null);
+            assert.ok(stdout.includes("Usage: task-o-matic [options] [command]"));
+            done();
+        });
+    });
+    it("should show help for the config command", (done) => {
+        (0, child_process_1.exec)("npx tsx src/cli/bin.ts config --help", (error, stdout, stderr) => {
+            assert.strictEqual(error, null);
+            assert.ok(stdout.includes("Usage: task-o-matic config [options] [command]"));
+            done();
+        });
+    });
+    it("should show help for the tasks command", (done) => {
+        (0, child_process_1.exec)("npx tsx src/cli/bin.ts tasks --help", (error, stdout, stderr) => {
+            assert.strictEqual(error, null);
+            assert.ok(stdout.includes("Usage: task-o-matic tasks [options] [command]"));
+            done();
+        });
+    });
+    it("should show help for the prd command", (done) => {
+        (0, child_process_1.exec)("npx tsx src/cli/bin.ts prd --help", (error, stdout, stderr) => {
+            assert.strictEqual(error, null);
+            assert.ok(stdout.includes("Usage: task-o-matic prd [options] [command]"));
+            done();
+        });
+    });
+    it("should show help for the init command", (done) => {
+        (0, child_process_1.exec)("npx tsx src/cli/bin.ts init --help", (error, stdout, stderr) => {
+            assert.strictEqual(error, null);
+            assert.ok(stdout.includes("Usage: task-o-matic init [options] [command]"));
+            done();
+        });
+    });
+});

package/dist/test/storage.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=storage.test.d.ts.map

package/dist/test/storage.test.d.ts.map

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