mulby-cli 1.1.5

package/dist/services/plan-command-handler.js

@@ -0,0 +1,172 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanCommandHandler = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const tui_1 = require("./tui");
+/**
+ * Simplified Plan Command Handler
+ *
+ * Usage:
+ * - /plan          Show current plan status
+ * - /plan <需求>    Force plan mode with requirement
+ *
+ * Everything else is automatic - AI manages the todo list
+ */
+class PlanCommandHandler {
+    constructor(planManager, getCurrentPlan, setCurrentPlan, savePlan) {
+        this.planManager = planManager;
+        this.getCurrentPlan = getCurrentPlan;
+        this.setCurrentPlan = setCurrentPlan;
+        this.savePlan = savePlan;
+    }
+    /**
+     * Handle /plan command
+     * Returns: true if handled, false if should pass to AI
+     */
+    async handlePlanCommand(args) {
+        const requirement = args.join(' ').trim();
+        if (requirement) {
+            // /plan <requirement> - Force plan mode, pass to AI
+            tui_1.tui.log(chalk_1.default.cyan('📋 进入计划模式...'));
+            return { handled: false, requirement };
+        }
+        // /plan with no args - show current plan
+        const plan = this.getCurrentPlan();
+        if (!plan) {
+            tui_1.tui.log(chalk_1.default.gray('当前没有活动的计划。'));
+            tui_1.tui.log(chalk_1.default.gray('提示: 输入 /plan <你的需求> 来创建计划'));
+            return { handled: true };
+        }
+        this.displayPlan(plan);
+        return { handled: true };
+    }
+    /**
+     * Display plan with progress bar
+     */
+    displayPlan(plan) {
+        const summary = this.planManager.getProgressSummary(plan);
+        tui_1.tui.log(chalk_1.default.cyan(`\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`));
+        tui_1.tui.log(chalk_1.default.cyan(`📋 ${plan.goal}`));
+        tui_1.tui.log(chalk_1.default.cyan(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━`));
+        // Progress bar
+        const progressBar = this.renderProgressBar(summary.percentage, 30);
+        tui_1.tui.log(`${progressBar} ${summary.completed}/${summary.total} (${Math.round(summary.percentage)}%)`);
+        tui_1.tui.log('');
+        // Task list
+        for (const task of plan.tasks) {
+            const icon = this.getStatusIcon(task.status);
+            const color = task.status === 'in_progress' ? chalk_1.default.yellow :
+                task.status === 'completed' ? chalk_1.default.green :
+                    task.status === 'failed' ? chalk_1.default.red : chalk_1.default.gray;
+            tui_1.tui.log(color(`  ${icon} ${task.title}`));
+        }
+        tui_1.tui.log(chalk_1.default.cyan(`━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n`));
+    }
+    /**
+     * Display compact progress line (for status updates during execution)
+     */
+    displayProgress(plan) {
+        const summary = this.planManager.getProgressSummary(plan);
+        const currentTask = plan.tasks.find(t => t.status === 'in_progress');
+        const progressBar = this.renderProgressBar(summary.percentage, 15);
+        let status = `${progressBar} ${summary.completed}/${summary.total}`;
+        if (currentTask) {
+            status += chalk_1.default.gray(` | ${currentTask.title.slice(0, 30)}`);
+        }
+        tui_1.tui.log(chalk_1.default.cyan(`📋 ${status}`));
+    }
+    // --- Methods for AI to call automatically ---
+    /**
+     * Start a task (mark as in_progress)
+     */
+    async startTask(taskId) {
+        const plan = this.getCurrentPlan();
+        if (!plan)
+            return;
+        const task = plan.tasks.find(t => t.id === taskId);
+        if (task && task.status === 'pending') {
+            task.status = 'in_progress';
+            task.startedAt = new Date();
+            plan.status = 'in_progress';
+            await this.savePlan(plan);
+            this.displayProgress(plan);
+        }
+    }
+    /**
+     * Complete a task
+     */
+    async completeTask(taskId) {
+        const plan = this.getCurrentPlan();
+        if (!plan)
+            return;
+        const task = plan.tasks.find(t => t.id === taskId);
+        if (task) {
+            task.status = 'completed';
+            task.completedAt = new Date();
+            await this.savePlan(plan);
+            // Check if all tasks completed
+            const allDone = plan.tasks.every(t => t.status === 'completed');
+            if (allDone) {
+                plan.status = 'completed';
+                await this.savePlan(plan);
+                tui_1.tui.log(chalk_1.default.green('\n🎉 所有任务已完成！'));
+                this.displayPlan(plan);
+            }
+            else {
+                this.displayProgress(plan);
+            }
+        }
+    }
+    /**
+     * Mark task as failed
+     */
+    async failTask(taskId, error) {
+        const plan = this.getCurrentPlan();
+        if (!plan)
+            return;
+        const task = plan.tasks.find(t => t.id === taskId);
+        if (task) {
+            task.status = 'failed';
+            task.error = error;
+            await this.savePlan(plan);
+            tui_1.tui.log(chalk_1.default.red(`❌ 任务失败: ${task.title}`));
+        }
+    }
+    /**
+     * Get next pending task
+     */
+    getNextTask() {
+        const plan = this.getCurrentPlan();
+        if (!plan)
+            return null;
+        return plan.tasks.find(t => t.status === 'pending') || null;
+    }
+    /**
+     * Get current in-progress task
+     */
+    getCurrentTask() {
+        const plan = this.getCurrentPlan();
+        if (!plan)
+            return null;
+        return plan.tasks.find(t => t.status === 'in_progress') || null;
+    }
+    // --- Helper methods ---
+    getStatusIcon(status) {
+        switch (status) {
+            case 'completed': return '✅';
+            case 'in_progress': return '🔄';
+            case 'failed': return '❌';
+            case 'skipped': return '⏭️';
+            default: return '⏸️';
+        }
+    }
+    renderProgressBar(percentage, width) {
+        const filled = Math.round((percentage / 100) * width);
+        const empty = width - filled;
+        return chalk_1.default.green('█'.repeat(filled)) + chalk_1.default.gray('░'.repeat(empty));
+    }
+}
+exports.PlanCommandHandler = PlanCommandHandler;

package/dist/services/plan-manager.js

@@ -0,0 +1,502 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanManager = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const uuid_1 = require("uuid");
+/**
+ * Plan Manager - handles task plan creation, persistence, and management
+ */
+class PlanManager {
+    constructor(baseDir = '.mulby') {
+        this.plansDir = path_1.default.join(baseDir, 'plans');
+        this.sessionsDir = path_1.default.join(baseDir, 'sessions');
+        this.ensureDirectories();
+    }
+    /**
+     * Ensure required directories exist
+     */
+    ensureDirectories() {
+        fs_extra_1.default.ensureDirSync(this.plansDir);
+        fs_extra_1.default.ensureDirSync(path_1.default.join(this.plansDir, 'templates'));
+        fs_extra_1.default.ensureDirSync(this.sessionsDir);
+    }
+    /**
+     * Create a new task plan
+     */
+    createPlan(goal, tasks) {
+        const plan = {
+            id: `plan-${Date.now()}-${(0, uuid_1.v4)().slice(0, 8)}`,
+            goal,
+            tasks: tasks.map((t, index) => ({
+                ...t,
+                id: `task-${index + 1}`,
+                createdAt: new Date()
+            })),
+            totalEstimatedTokens: tasks.reduce((sum, t) => sum + (t.estimatedTokens || 0), 0),
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            status: 'draft',
+            currentTaskIndex: 0
+        };
+        return plan;
+    }
+    /**
+     * Save plan to file
+     */
+    async savePlan(plan, sessionId) {
+        const serializable = this.toSerializable(plan);
+        // Save to plans directory
+        const planPath = path_1.default.join(this.plansDir, `${plan.id}.json`);
+        await fs_extra_1.default.writeJson(planPath, serializable, { spaces: 2 });
+        // Also save to session directory if sessionId provided
+        if (sessionId) {
+            const sessionDir = path_1.default.join(this.sessionsDir, sessionId);
+            await fs_extra_1.default.ensureDir(sessionDir);
+            const sessionPlanPath = path_1.default.join(sessionDir, 'plan.json');
+            await fs_extra_1.default.writeJson(sessionPlanPath, serializable, { spaces: 2 });
+        }
+    }
+    /**
+     * Load plan from file
+     */
+    async loadPlan(planId) {
+        const planPath = path_1.default.join(this.plansDir, `${planId}.json`);
+        if (!await fs_extra_1.default.pathExists(planPath)) {
+            return null;
+        }
+        const serializable = await fs_extra_1.default.readJson(planPath);
+        return this.fromSerializable(serializable);
+    }
+    /**
+     * Load plan from session
+     */
+    async loadSessionPlan(sessionId) {
+        const sessionPlanPath = path_1.default.join(this.sessionsDir, sessionId, 'plan.json');
+        if (!await fs_extra_1.default.pathExists(sessionPlanPath)) {
+            return null;
+        }
+        const serializable = await fs_extra_1.default.readJson(sessionPlanPath);
+        return this.fromSerializable(serializable);
+    }
+    /**
+     * Update task status
+     */
+    updateTaskStatus(plan, taskId, status, error) {
+        const task = plan.tasks.find(t => t.id === taskId);
+        if (!task) {
+            throw new Error(`Task ${taskId} not found`);
+        }
+        task.status = status;
+        task.error = error;
+        if (status === 'in_progress' && !task.startedAt) {
+            task.startedAt = new Date();
+        }
+        if (status === 'completed' || status === 'failed' || status === 'skipped') {
+            task.completedAt = new Date();
+        }
+        plan.updatedAt = new Date();
+        // Update plan status
+        this.updatePlanStatus(plan);
+        return plan;
+    }
+    /**
+     * Update plan status based on task statuses
+     */
+    updatePlanStatus(plan) {
+        const allCompleted = plan.tasks.every(t => t.status === 'completed' || t.status === 'skipped');
+        const anyFailed = plan.tasks.some(t => t.status === 'failed');
+        const anyInProgress = plan.tasks.some(t => t.status === 'in_progress');
+        if (allCompleted) {
+            plan.status = 'completed';
+        }
+        else if (anyFailed) {
+            plan.status = 'failed';
+        }
+        else if (anyInProgress) {
+            plan.status = 'in_progress';
+        }
+    }
+    /**
+     * Get next pending task
+     */
+    getNextTask(plan) {
+        const completedTaskIds = new Set(plan.tasks
+            .filter(t => t.status === 'completed' || t.status === 'skipped')
+            .map(t => t.id));
+        // Find first pending task whose dependencies are satisfied
+        for (const task of plan.tasks) {
+            if (task.status !== 'pending')
+                continue;
+            const dependenciesSatisfied = task.dependencies.every(depId => completedTaskIds.has(depId));
+            if (dependenciesSatisfied) {
+                return task;
+            }
+        }
+        return null;
+    }
+    /**
+     * Calculate progress percentage
+     */
+    calculateProgress(plan) {
+        const total = plan.tasks.length;
+        if (total === 0)
+            return 0;
+        const completed = plan.tasks.filter(t => t.status === 'completed').length;
+        const inProgress = plan.tasks.filter(t => t.status === 'in_progress').length;
+        // In-progress tasks count as 0.5
+        return ((completed + inProgress * 0.5) / total) * 100;
+    }
+    /**
+     * Get progress summary
+     */
+    getProgressSummary(plan) {
+        const total = plan.tasks.length;
+        const completed = plan.tasks.filter(t => t.status === 'completed').length;
+        const inProgress = plan.tasks.filter(t => t.status === 'in_progress').length;
+        const pending = plan.tasks.filter(t => t.status === 'pending').length;
+        const failed = plan.tasks.filter(t => t.status === 'failed').length;
+        const skipped = plan.tasks.filter(t => t.status === 'skipped').length;
+        return {
+            total,
+            completed,
+            inProgress,
+            pending,
+            failed,
+            skipped,
+            percentage: this.calculateProgress(plan)
+        };
+    }
+    /**
+     * Add task to plan
+     */
+    addTask(plan, task, afterTaskId) {
+        const newTask = {
+            ...task,
+            id: `task-${plan.tasks.length + 1}`,
+            createdAt: new Date()
+        };
+        if (afterTaskId) {
+            const index = plan.tasks.findIndex(t => t.id === afterTaskId);
+            if (index !== -1) {
+                plan.tasks.splice(index + 1, 0, newTask);
+            }
+            else {
+                plan.tasks.push(newTask);
+            }
+        }
+        else {
+            plan.tasks.push(newTask);
+        }
+        plan.updatedAt = new Date();
+        return plan;
+    }
+    /**
+     * Remove task from plan
+     */
+    removeTask(plan, taskId) {
+        const index = plan.tasks.findIndex(t => t.id === taskId);
+        if (index === -1) {
+            throw new Error(`Task ${taskId} not found`);
+        }
+        // Check if other tasks depend on this task
+        const dependentTasks = plan.tasks.filter(t => t.dependencies.includes(taskId));
+        if (dependentTasks.length > 0) {
+            throw new Error(`Cannot remove task ${taskId}: ${dependentTasks.length} tasks depend on it`);
+        }
+        plan.tasks.splice(index, 1);
+        plan.updatedAt = new Date();
+        return plan;
+    }
+    /**
+     * List all plans
+     */
+    async listPlans() {
+        const files = await fs_extra_1.default.readdir(this.plansDir);
+        const planFiles = files.filter(f => f.endsWith('.json') && !f.startsWith('template-'));
+        const plans = [];
+        for (const file of planFiles) {
+            const planPath = path_1.default.join(this.plansDir, file);
+            const serializable = await fs_extra_1.default.readJson(planPath);
+            plans.push(this.fromSerializable(serializable));
+        }
+        return plans.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
+    }
+    /**
+     * Delete plan
+     */
+    async deletePlan(planId) {
+        const planPath = path_1.default.join(this.plansDir, `${planId}.json`);
+        if (await fs_extra_1.default.pathExists(planPath)) {
+            await fs_extra_1.default.remove(planPath);
+        }
+    }
+    // ========== Template System ==========
+    /**
+     * Save plan as a template
+     */
+    async saveTemplate(plan, templateName) {
+        const template = {
+            name: templateName,
+            description: plan.goal,
+            tasks: plan.tasks.map(t => ({
+                title: t.title,
+                description: t.description,
+                priority: t.priority,
+                dependencies: t.dependencies,
+                acceptanceCriteria: t.acceptanceCriteria,
+                files: t.files,
+                estimatedTokens: t.estimatedTokens
+            })),
+            createdAt: new Date().toISOString(),
+            tags: this.inferTags(plan)
+        };
+        const templatePath = path_1.default.join(this.plansDir, 'templates', `${templateName}.json`);
+        await fs_extra_1.default.writeJson(templatePath, template, { spaces: 2 });
+    }
+    /**
+     * Load a template and create a new plan from it
+     */
+    async loadTemplate(templateName, customGoal) {
+        const templatePath = path_1.default.join(this.plansDir, 'templates', `${templateName}.json`);
+        if (!await fs_extra_1.default.pathExists(templatePath)) {
+            return null;
+        }
+        const template = await fs_extra_1.default.readJson(templatePath);
+        const plan = this.createPlan(customGoal || template.description, template.tasks.map(t => ({
+            ...t,
+            status: 'pending'
+        })));
+        return plan;
+    }
+    /**
+     * List all available templates
+     */
+    async listTemplates() {
+        const templatesDir = path_1.default.join(this.plansDir, 'templates');
+        await fs_extra_1.default.ensureDir(templatesDir);
+        const files = await fs_extra_1.default.readdir(templatesDir);
+        const templates = [];
+        for (const file of files) {
+            if (file.endsWith('.json')) {
+                const templatePath = path_1.default.join(templatesDir, file);
+                const template = await fs_extra_1.default.readJson(templatePath);
+                templates.push(template);
+            }
+        }
+        return templates.sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    }
+    /**
+     * Delete a template
+     */
+    async deleteTemplate(templateName) {
+        const templatePath = path_1.default.join(this.plansDir, 'templates', `${templateName}.json`);
+        if (await fs_extra_1.default.pathExists(templatePath)) {
+            await fs_extra_1.default.remove(templatePath);
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Get built-in templates
+     */
+    getBuiltInTemplates() {
+        return [
+            {
+                name: 'feature',
+                description: 'Standard feature implementation workflow',
+                tasks: [
+                    {
+                        title: 'Analyze requirements',
+                        description: 'Understand the feature requirements and identify affected components',
+                        priority: 'high',
+                        dependencies: [],
+                        acceptanceCriteria: ['Requirements are clear', 'Affected files identified'],
+                        files: []
+                    },
+                    {
+                        title: 'Design solution',
+                        description: 'Design the technical approach and data structures',
+                        priority: 'high',
+                        dependencies: ['task-1'],
+                        acceptanceCriteria: ['Technical design documented', 'Edge cases considered'],
+                        files: []
+                    },
+                    {
+                        title: 'Implement core functionality',
+                        description: 'Implement the main feature logic',
+                        priority: 'high',
+                        dependencies: ['task-2'],
+                        acceptanceCriteria: ['Core functionality works', 'Code follows project conventions'],
+                        files: []
+                    },
+                    {
+                        title: 'Add tests',
+                        description: 'Write unit and integration tests',
+                        priority: 'medium',
+                        dependencies: ['task-3'],
+                        acceptanceCriteria: ['Tests cover main scenarios', 'All tests pass'],
+                        files: []
+                    },
+                    {
+                        title: 'Review and refine',
+                        description: 'Code review, documentation, and final polish',
+                        priority: 'low',
+                        dependencies: ['task-4'],
+                        acceptanceCriteria: ['Code is clean', 'Documentation updated'],
+                        files: []
+                    }
+                ],
+                createdAt: '2026-01-01T00:00:00Z',
+                tags: ['feature', 'standard']
+            },
+            {
+                name: 'bugfix',
+                description: 'Bug fix workflow',
+                tasks: [
+                    {
+                        title: 'Reproduce the bug',
+                        description: 'Understand and consistently reproduce the issue',
+                        priority: 'high',
+                        dependencies: [],
+                        acceptanceCriteria: ['Bug can be reproduced', 'Steps documented'],
+                        files: []
+                    },
+                    {
+                        title: 'Identify root cause',
+                        description: 'Debug and find the source of the problem',
+                        priority: 'high',
+                        dependencies: ['task-1'],
+                        acceptanceCriteria: ['Root cause identified', 'Fix approach determined'],
+                        files: []
+                    },
+                    {
+                        title: 'Implement fix',
+                        description: 'Fix the bug with minimal code changes',
+                        priority: 'high',
+                        dependencies: ['task-2'],
+                        acceptanceCriteria: ['Bug is fixed', 'No regressions introduced'],
+                        files: []
+                    },
+                    {
+                        title: 'Add regression test',
+                        description: 'Write a test to prevent the bug from recurring',
+                        priority: 'medium',
+                        dependencies: ['task-3'],
+                        acceptanceCriteria: ['Test covers the bug scenario', 'Test passes'],
+                        files: []
+                    }
+                ],
+                createdAt: '2026-01-01T00:00:00Z',
+                tags: ['bugfix', 'standard']
+            },
+            {
+                name: 'refactor',
+                description: 'Code refactoring workflow',
+                tasks: [
+                    {
+                        title: 'Analyze current code',
+                        description: 'Understand the existing implementation and its issues',
+                        priority: 'high',
+                        dependencies: [],
+                        acceptanceCriteria: ['Current structure understood', 'Pain points identified'],
+                        files: []
+                    },
+                    {
+                        title: 'Design new structure',
+                        description: 'Plan the improved architecture',
+                        priority: 'high',
+                        dependencies: ['task-1'],
+                        acceptanceCriteria: ['New design documented', 'Migration path clear'],
+                        files: []
+                    },
+                    {
+                        title: 'Ensure test coverage',
+                        description: 'Add tests for existing functionality before refactoring',
+                        priority: 'high',
+                        dependencies: ['task-2'],
+                        acceptanceCriteria: ['Critical paths tested', 'Tests pass'],
+                        files: []
+                    },
+                    {
+                        title: 'Refactor incrementally',
+                        description: 'Apply changes in small, verifiable steps',
+                        priority: 'high',
+                        dependencies: ['task-3'],
+                        acceptanceCriteria: ['Code improved', 'Tests still pass'],
+                        files: []
+                    },
+                    {
+                        title: 'Verify and clean up',
+                        description: 'Final verification and removal of old code',
+                        priority: 'medium',
+                        dependencies: ['task-4'],
+                        acceptanceCriteria: ['All tests pass', 'No dead code remains'],
+                        files: []
+                    }
+                ],
+                createdAt: '2026-01-01T00:00:00Z',
+                tags: ['refactor', 'standard']
+            }
+        ];
+    }
+    /**
+     * Infer tags from plan content
+     */
+    inferTags(plan) {
+        const tags = [];
+        const goalLower = plan.goal.toLowerCase();
+        if (goalLower.includes('fix') || goalLower.includes('bug')) {
+            tags.push('bugfix');
+        }
+        if (goalLower.includes('feature') || goalLower.includes('implement') || goalLower.includes('add')) {
+            tags.push('feature');
+        }
+        if (goalLower.includes('refactor') || goalLower.includes('improve') || goalLower.includes('optimize')) {
+            tags.push('refactor');
+        }
+        if (goalLower.includes('test')) {
+            tags.push('testing');
+        }
+        if (goalLower.includes('doc')) {
+            tags.push('documentation');
+        }
+        return tags;
+    }
+    /**
+     * Convert TaskPlan to serializable format
+     */
+    toSerializable(plan) {
+        return {
+            ...plan,
+            tasks: plan.tasks.map(t => ({
+                ...t,
+                createdAt: t.createdAt.toISOString(),
+                startedAt: t.startedAt?.toISOString(),
+                completedAt: t.completedAt?.toISOString()
+            })),
+            createdAt: plan.createdAt.toISOString(),
+            updatedAt: plan.updatedAt.toISOString()
+        };
+    }
+    /**
+     * Convert serializable format to TaskPlan
+     */
+    fromSerializable(serializable) {
+        return {
+            ...serializable,
+            tasks: serializable.tasks.map(t => ({
+                ...t,
+                createdAt: new Date(t.createdAt),
+                startedAt: t.startedAt ? new Date(t.startedAt) : undefined,
+                completedAt: t.completedAt ? new Date(t.completedAt) : undefined
+            })),
+            createdAt: new Date(serializable.createdAt),
+            updatedAt: new Date(serializable.updatedAt)
+        };
+    }
+}
+exports.PlanManager = PlanManager;