mulby-cli 1.1.5

package/dist/services/config-manager.js

@@ -0,0 +1,117 @@
+"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 });
+exports.ConfigManager = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const CONFIG_DIR = path.join(os.homedir(), '.mulby');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+class ConfigManager {
+    constructor() {
+        this.config = {};
+        this.load();
+    }
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    load() {
+        try {
+            if (fs.existsSync(CONFIG_FILE)) {
+                this.config = fs.readJsonSync(CONFIG_FILE);
+            }
+        }
+        catch (error) {
+            console.error('加载配置文件失败:', error);
+            this.config = {};
+        }
+    }
+    save() {
+        try {
+            fs.ensureDirSync(CONFIG_DIR);
+            fs.writeJsonSync(CONFIG_FILE, this.config, { spaces: 2 });
+        }
+        catch (error) {
+            console.error('保存配置文件失败:', error);
+        }
+    }
+    get(key) {
+        const keys = key.split('.');
+        let current = this.config;
+        for (const k of keys) {
+            if (current === undefined || current === null)
+                return undefined;
+            current = current[k];
+        }
+        // Automatically convert numeric strings to numbers for specific keys
+        if (typeof current === 'string' && (key === 'ai.maxTokens' || key === 'ai.timeout' || key === 'ai.maxRetries')) {
+            const num = Number(current);
+            return (isNaN(num) ? current : num);
+        }
+        return current;
+    }
+    set(key, value) {
+        const keys = key.split('.');
+        let current = this.config;
+        for (let i = 0; i < keys.length - 1; i++) {
+            const k = keys[i];
+            if (current[k] === undefined) {
+                current[k] = {};
+            }
+            current = current[k];
+        }
+        current[keys[keys.length - 1]] = value;
+        this.save();
+    }
+    delete(key) {
+        const keys = key.split('.');
+        let current = this.config;
+        for (let i = 0; i < keys.length - 1; i++) {
+            const k = keys[i];
+            if (current[k] === undefined)
+                return; // Path doesn't exist
+            current = current[k];
+        }
+        delete current[keys[keys.length - 1]];
+        this.save();
+    }
+    getAll() {
+        return { ...this.config };
+    }
+}
+exports.ConfigManager = ConfigManager;

package/dist/services/dependency-manager.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DependencyManager = void 0;
+/**
+ * Dependency Manager - handles task dependency analysis and management
+ */
+class DependencyManager {
+    /**
+     * Check if a task can be executed (all dependencies are satisfied)
+     */
+    canExecute(task, completedTasks) {
+        return task.dependencies.every(depId => completedTasks.has(depId));
+    }
+    /**
+     * Get all tasks that can be executed in parallel
+     */
+    getParallelTasks(tasks, completedTasks) {
+        return tasks.filter(t => t.status === 'pending' &&
+            this.canExecute(t, completedTasks));
+    }
+    /**
+     * Detect cyclic dependencies using DFS
+     * Returns the cycle path if found, null otherwise
+     */
+    detectCyclicDependency(tasks) {
+        const taskMap = new Map();
+        tasks.forEach(t => taskMap.set(t.id, t));
+        const visited = new Set();
+        const recursionStack = new Set();
+        const path = [];
+        const dfs = (taskId) => {
+            visited.add(taskId);
+            recursionStack.add(taskId);
+            path.push(taskId);
+            const task = taskMap.get(taskId);
+            if (task) {
+                for (const depId of task.dependencies) {
+                    if (!visited.has(depId)) {
+                        const cycle = dfs(depId);
+                        if (cycle)
+                            return cycle;
+                    }
+                    else if (recursionStack.has(depId)) {
+                        // Found a cycle
+                        const cycleStart = path.indexOf(depId);
+                        return path.slice(cycleStart).concat(depId);
+                    }
+                }
+            }
+            path.pop();
+            recursionStack.delete(taskId);
+            return null;
+        };
+        for (const task of tasks) {
+            if (!visited.has(task.id)) {
+                const cycle = dfs(task.id);
+                if (cycle)
+                    return cycle;
+            }
+        }
+        return null;
+    }
+    /**
+     * Topological sort of tasks based on dependencies
+     * Returns sorted task IDs or null if cycle detected
+     */
+    topologicalSort(tasks) {
+        const cycle = this.detectCyclicDependency(tasks);
+        if (cycle)
+            return null;
+        const taskMap = new Map();
+        tasks.forEach(t => taskMap.set(t.id, t));
+        const visited = new Set();
+        const result = [];
+        const visit = (taskId) => {
+            if (visited.has(taskId))
+                return;
+            visited.add(taskId);
+            const task = taskMap.get(taskId);
+            if (task) {
+                for (const depId of task.dependencies) {
+                    visit(depId);
+                }
+            }
+            result.push(taskId);
+        };
+        for (const task of tasks) {
+            visit(task.id);
+        }
+        return result;
+    }
+    /**
+     * Get all tasks that depend on a given task (direct and indirect)
+     */
+    getDependentTasks(tasks, taskId) {
+        const dependents = [];
+        const visited = new Set();
+        const findDependents = (id) => {
+            for (const task of tasks) {
+                if (task.dependencies.includes(id) && !visited.has(task.id)) {
+                    visited.add(task.id);
+                    dependents.push(task);
+                    findDependents(task.id);
+                }
+            }
+        };
+        findDependents(taskId);
+        return dependents;
+    }
+    /**
+     * Get all tasks that a given task depends on (direct and indirect)
+     */
+    getPrerequisiteTasks(tasks, taskId) {
+        const taskMap = new Map();
+        tasks.forEach(t => taskMap.set(t.id, t));
+        const prerequisites = [];
+        const visited = new Set();
+        const findPrerequisites = (id) => {
+            const task = taskMap.get(id);
+            if (!task)
+                return;
+            for (const depId of task.dependencies) {
+                if (!visited.has(depId)) {
+                    visited.add(depId);
+                    const depTask = taskMap.get(depId);
+                    if (depTask) {
+                        prerequisites.push(depTask);
+                        findPrerequisites(depId);
+                    }
+                }
+            }
+        };
+        findPrerequisites(taskId);
+        return prerequisites;
+    }
+    /**
+     * Calculate the critical path (longest dependency chain)
+     */
+    getCriticalPath(tasks) {
+        const taskMap = new Map();
+        tasks.forEach(t => taskMap.set(t.id, t));
+        const memo = new Map();
+        const getLongestPath = (taskId) => {
+            if (memo.has(taskId))
+                return memo.get(taskId);
+            const task = taskMap.get(taskId);
+            if (!task)
+                return [];
+            if (task.dependencies.length === 0) {
+                const path = [task];
+                memo.set(taskId, path);
+                return path;
+            }
+            let longestDepPath = [];
+            for (const depId of task.dependencies) {
+                const depPath = getLongestPath(depId);
+                if (depPath.length > longestDepPath.length) {
+                    longestDepPath = depPath;
+                }
+            }
+            const path = [...longestDepPath, task];
+            memo.set(taskId, path);
+            return path;
+        };
+        let criticalPath = [];
+        for (const task of tasks) {
+            const path = getLongestPath(task.id);
+            if (path.length > criticalPath.length) {
+                criticalPath = path;
+            }
+        }
+        return criticalPath;
+    }
+    /**
+     * Generate dependency visualization (ASCII tree)
+     */
+    visualizeDependencies(tasks) {
+        const lines = [];
+        const taskMap = new Map();
+        tasks.forEach(t => taskMap.set(t.id, t));
+        // Find root tasks (no dependencies)
+        const rootTasks = tasks.filter(t => t.dependencies.length === 0);
+        const renderTask = (task, prefix, isLast) => {
+            const connector = isLast ? '└── ' : '├── ';
+            const statusIcon = this.getStatusIcon(task.status);
+            lines.push(`${prefix}${connector}${statusIcon} ${task.title}`);
+            // Find tasks that depend on this one
+            const children = tasks.filter(t => t.dependencies.includes(task.id));
+            const childPrefix = prefix + (isLast ? '    ' : '│   ');
+            children.forEach((child, idx) => {
+                renderTask(child, childPrefix, idx === children.length - 1);
+            });
+        };
+        lines.push('Dependency Tree:');
+        rootTasks.forEach((task, idx) => {
+            renderTask(task, '', idx === rootTasks.length - 1);
+        });
+        return lines.join('\n');
+    }
+    /**
+     * Validate dependencies (check for invalid references)
+     */
+    validateDependencies(tasks) {
+        const taskIds = new Set(tasks.map(t => t.id));
+        const errors = [];
+        for (const task of tasks) {
+            for (const depId of task.dependencies) {
+                if (!taskIds.has(depId)) {
+                    errors.push(`Task "${task.title}" references non-existent dependency: ${depId}`);
+                }
+                if (depId === task.id) {
+                    errors.push(`Task "${task.title}" has self-dependency`);
+                }
+            }
+        }
+        const cycle = this.detectCyclicDependency(tasks);
+        if (cycle) {
+            errors.push(`Cyclic dependency detected: ${cycle.join(' -> ')}`);
+        }
+        return {
+            valid: errors.length === 0,
+            errors
+        };
+    }
+    getStatusIcon(status) {
+        switch (status) {
+            case 'completed': return '✅';
+            case 'in_progress': return '🔄';
+            case 'pending': return '⏸️';
+            case 'failed': return '❌';
+            case 'skipped': return '⏭️';
+            default: return '  ';
+        }
+    }
+}
+exports.DependencyManager = DependencyManager;

package/dist/services/file-writer.js

@@ -0,0 +1,66 @@
+"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 });
+exports.FileWriter = void 0;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+class FileWriter {
+    constructor(basePath) {
+        this.basePath = basePath;
+    }
+    async writeFile(relativePath, content) {
+        this.validatePath(relativePath);
+        const fullPath = path.join(this.basePath, relativePath);
+        await fs.ensureDir(path.dirname(fullPath));
+        // 简单的原子写入模拟：写 .tmp -> rename
+        const tmpPath = `${fullPath}.tmp`;
+        await fs.writeFile(tmpPath, content, 'utf-8');
+        await fs.move(tmpPath, fullPath, { overwrite: true });
+    }
+    validatePath(relativePath) {
+        const fullPath = path.resolve(this.basePath, relativePath);
+        if (!fullPath.startsWith(path.resolve(this.basePath))) {
+            throw new Error(`非法路径尝试: ${relativePath}`);
+        }
+    }
+    async exists(relativePath) {
+        const fullPath = path.join(this.basePath, relativePath);
+        return fs.pathExists(fullPath);
+    }
+    getBasePath() {
+        return this.basePath;
+    }
+}
+exports.FileWriter = FileWriter;

package/dist/services/plan-adapter.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PlanAdapter = void 0;
+const dependency_manager_1 = require("./dependency-manager");
+/**
+ * Plan Adapter - handles dynamic plan adjustments
+ */
+class PlanAdapter {
+    constructor() {
+        this.dependencyManager = new dependency_manager_1.DependencyManager();
+    }
+    /**
+     * Handle task failure and generate recovery tasks
+     */
+    onTaskFailed(plan, task, error) {
+        const newTasks = [];
+        // 1. Create a fix task
+        const fixTask = {
+            id: `fix-${task.id}-${Date.now()}`,
+            title: `Fix: ${task.title}`,
+            description: `Resolve the error encountered in task "${task.title}": ${error}`,
+            status: 'pending',
+            priority: 'high',
+            dependencies: [],
+            acceptanceCriteria: [
+                'Error is identified and understood',
+                'Fix is implemented',
+                'Original task can be retried'
+            ],
+            files: task.files,
+            createdAt: new Date()
+        };
+        newTasks.push(fixTask);
+        // 2. Create a retry task that depends on the fix
+        const retryTask = {
+            id: `retry-${task.id}-${Date.now()}`,
+            title: `Retry: ${task.title}`,
+            description: task.description,
+            status: 'pending',
+            priority: task.priority,
+            dependencies: [fixTask.id],
+            acceptanceCriteria: task.acceptanceCriteria,
+            files: task.files,
+            createdAt: new Date()
+        };
+        newTasks.push(retryTask);
+        // 3. Update dependent tasks to point to the retry task
+        const dependentTasks = this.dependencyManager.getDependentTasks(plan.tasks, task.id);
+        for (const depTask of dependentTasks) {
+            const idx = depTask.dependencies.indexOf(task.id);
+            if (idx !== -1) {
+                depTask.dependencies[idx] = retryTask.id;
+            }
+        }
+        return newTasks;
+    }
+    /**
+     * Analyze failure and suggest recovery strategy
+     */
+    analyzeFailure(task, error) {
+        const errorLower = error.toLowerCase();
+        // Categorize error types
+        let category = 'unknown';
+        let suggestions = [];
+        let autoRecoverable = false;
+        if (errorLower.includes('not found') || errorLower.includes('no such file')) {
+            category = 'missing_resource';
+            suggestions = [
+                'Check if the file/resource was created in a previous task',
+                'Verify file paths are correct',
+                'Create missing resources first'
+            ];
+            autoRecoverable = true;
+        }
+        else if (errorLower.includes('permission') || errorLower.includes('access denied')) {
+            category = 'permission';
+            suggestions = [
+                'Check file/directory permissions',
+                'Run with elevated privileges if needed',
+                'Verify user has write access'
+            ];
+        }
+        else if (errorLower.includes('timeout') || errorLower.includes('timed out')) {
+            category = 'timeout';
+            suggestions = [
+                'Increase timeout duration',
+                'Check network connectivity',
+                'Retry the operation'
+            ];
+            autoRecoverable = true;
+        }
+        else if (errorLower.includes('syntax') || errorLower.includes('parse')) {
+            category = 'syntax_error';
+            suggestions = [
+                'Check code syntax',
+                'Validate configuration files',
+                'Review recent changes'
+            ];
+        }
+        else if (errorLower.includes('dependency') || errorLower.includes('module not found')) {
+            category = 'dependency';
+            suggestions = [
+                'Install missing dependencies',
+                'Check package.json',
+                'Run npm/yarn install'
+            ];
+            autoRecoverable = true;
+        }
+        else if (errorLower.includes('type') || errorLower.includes('typescript')) {
+            category = 'type_error';
+            suggestions = [
+                'Fix TypeScript type errors',
+                'Check interface definitions',
+                'Verify function signatures'
+            ];
+        }
+        return {
+            category,
+            originalError: error,
+            suggestions,
+            autoRecoverable,
+            affectedTasks: this.dependencyManager.getDependentTasks([], task.id).map(t => t.id)
+        };
+    }
+    /**
+     * Reorder tasks based on priority and dependencies
+     */
+    optimizeTaskOrder(tasks) {
+        // First, ensure topological order
+        const sorted = this.dependencyManager.topologicalSort(tasks);
+        if (!sorted) {
+            // Cycle detected, return original order
+            return tasks;
+        }
+        const taskMap = new Map();
+        tasks.forEach(t => taskMap.set(t.id, t));
+        // Group by dependency level
+        const levels = [];
+        const assigned = new Set();
+        while (assigned.size < tasks.length) {
+            const currentLevel = [];
+            for (const taskId of sorted) {
+                if (assigned.has(taskId))
+                    continue;
+                const task = taskMap.get(taskId);
+                const depsCompleted = task.dependencies.every(d => assigned.has(d));
+                if (depsCompleted) {
+                    currentLevel.push(task);
+                }
+            }
+            // Sort current level by priority
+            currentLevel.sort((a, b) => {
+                const priorityOrder = { high: 0, medium: 1, low: 2 };
+                return priorityOrder[a.priority] - priorityOrder[b.priority];
+            });
+            currentLevel.forEach(t => assigned.add(t.id));
+            levels.push(currentLevel);
+        }
+        return levels.flat();
+    }
+    /**
+     * Suggest task breakdown for complex tasks
+     */
+    suggestBreakdown(task) {
+        const subtasks = [];
+        // Based on task description length and complexity indicators
+        const complexityIndicators = ['implement', 'create', 'design', 'refactor', 'migrate'];
+        const hasComplexity = complexityIndicators.some(i => task.title.toLowerCase().includes(i) ||
+            task.description.toLowerCase().includes(i));
+        if (!hasComplexity) {
+            return subtasks;
+        }
+        // Generate suggested subtasks
+        if (task.files.length > 2) {
+            // Multiple files - suggest per-file tasks
+            task.files.forEach((file, idx) => {
+                subtasks.push({
+                    id: `${task.id}-sub-${idx + 1}`,
+                    title: `Update ${file.split('/').pop()}`,
+                    description: `Implement changes in ${file}`,
+                    status: 'pending',
+                    priority: task.priority,
+                    dependencies: idx === 0 ? task.dependencies : [`${task.id}-sub-${idx}`],
+                    acceptanceCriteria: [`Changes in ${file} are complete and working`],
+                    files: [file],
+                    createdAt: new Date()
+                });
+            });
+        }
+        return subtasks;
+    }
+    /**
+     * Estimate remaining work
+     */
+    estimateRemainingWork(plan) {
+        const pendingTasks = plan.tasks.filter(t => t.status === 'pending' || t.status === 'in_progress');
+        const completedTasks = plan.tasks.filter(t => t.status === 'completed');
+        // Calculate average completion time from completed tasks
+        let avgCompletionTime = 0;
+        if (completedTasks.length > 0) {
+            const completionTimes = completedTasks
+                .filter(t => t.startedAt && t.completedAt)
+                .map(t => t.completedAt.getTime() - t.startedAt.getTime());
+            if (completionTimes.length > 0) {
+                avgCompletionTime = completionTimes.reduce((a, b) => a + b, 0) / completionTimes.length;
+            }
+        }
+        // Estimate remaining time
+        const estimatedRemainingTime = avgCompletionTime * pendingTasks.length;
+        // Calculate by priority
+        const byPriority = {
+            high: pendingTasks.filter(t => t.priority === 'high').length,
+            medium: pendingTasks.filter(t => t.priority === 'medium').length,
+            low: pendingTasks.filter(t => t.priority === 'low').length
+        };
+        // Get critical path
+        const criticalPath = this.dependencyManager.getCriticalPath(pendingTasks);
+        return {
+            pendingTaskCount: pendingTasks.length,
+            estimatedTimeMs: estimatedRemainingTime,
+            estimatedTimeFormatted: this.formatDuration(estimatedRemainingTime),
+            byPriority,
+            criticalPathLength: criticalPath.length,
+            blockedTasks: pendingTasks.filter(t => !this.dependencyManager.canExecute(t, new Set(completedTasks.map(c => c.id)))).length
+        };
+    }
+    formatDuration(ms) {
+        if (ms === 0)
+            return 'Unknown';
+        const seconds = Math.floor(ms / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        if (hours > 0) {
+            return `~${hours}h ${minutes % 60}m`;
+        }
+        else if (minutes > 0) {
+            return `~${minutes}m`;
+        }
+        else {
+            return `~${seconds}s`;
+        }
+    }
+}
+exports.PlanAdapter = PlanAdapter;