orquesta-cli 0.1.26 → 0.2.0

package/dist/orchestration/worktree-manager.js

@@ -0,0 +1,124 @@
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { logger } from '../utils/logger.js';
+const execAsync = promisify(exec);
+async function isGitRepo(cwd) {
+    try {
+        await execAsync('git rev-parse --is-inside-work-tree', { cwd });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function gitRepoRoot(cwd) {
+    const { stdout } = await execAsync('git rev-parse --show-toplevel', { cwd });
+    return stdout.trim();
+}
+export class WorktreeManager {
+    allocations = new Map();
+    tmpRoot;
+    constructor(tmpRoot) {
+        this.tmpRoot = tmpRoot ?? path.join(os.tmpdir(), 'orquesta-cli-worktrees');
+    }
+    async allocate(id, hostCwd = process.cwd()) {
+        if (this.allocations.has(id)) {
+            throw new Error(`Worktree already allocated for id=${id}`);
+        }
+        const gitMode = await isGitRepo(hostCwd);
+        let allocation;
+        if (gitMode) {
+            const repoRoot = await gitRepoRoot(hostCwd);
+            const branch = `orquesta/worker-${id}-${Date.now()}`;
+            const worktreeDir = path.join(this.tmpRoot, 'git', id);
+            await fs.mkdir(path.dirname(worktreeDir), { recursive: true });
+            await execAsync(`git worktree add -b ${branch} "${worktreeDir}" HEAD`, { cwd: repoRoot });
+            allocation = { id, path: worktreeDir, backend: 'git', branch };
+            logger.flow('Allocated git worktree', { id, branch, path: worktreeDir });
+        }
+        else {
+            const copyDir = path.join(this.tmpRoot, 'copy', id);
+            await fs.mkdir(copyDir, { recursive: true });
+            try {
+                await execAsync(`rsync -a --exclude='.git' "${hostCwd}/" "${copyDir}/"`);
+            }
+            catch {
+                await execAsync(`cp -a "${hostCwd}/." "${copyDir}/"`);
+            }
+            allocation = { id, path: copyDir, backend: 'copy' };
+            logger.flow('Allocated copy worktree', { id, path: copyDir });
+        }
+        this.allocations.set(id, allocation);
+        return allocation;
+    }
+    async mergeBack(id, hostCwd = process.cwd()) {
+        const alloc = this.allocations.get(id);
+        if (!alloc) {
+            return { success: false, filesChanged: [], conflicts: [], error: `No allocation for id=${id}` };
+        }
+        try {
+            if (alloc.backend === 'git' && alloc.branch) {
+                const repoRoot = await gitRepoRoot(hostCwd);
+                const { stdout: diffStat } = await execAsync(`git diff --name-only HEAD ${alloc.branch}`, { cwd: repoRoot });
+                const filesChanged = diffStat.split('\n').map(s => s.trim()).filter(Boolean);
+                try {
+                    await execAsync(`git merge --no-ff ${alloc.branch}`, { cwd: repoRoot });
+                    return { success: true, filesChanged, conflicts: [] };
+                }
+                catch (mergeError) {
+                    const { stdout: conflicts } = await execAsync('git diff --name-only --diff-filter=U', { cwd: repoRoot }).catch(() => ({ stdout: '' }));
+                    await execAsync('git merge --abort', { cwd: repoRoot }).catch(() => { });
+                    return {
+                        success: false,
+                        filesChanged,
+                        conflicts: conflicts.split('\n').map(s => s.trim()).filter(Boolean),
+                        error: mergeError.message,
+                    };
+                }
+            }
+            const { stdout: rawDiff } = await execAsync(`rsync -avc --dry-run --exclude='.git' "${alloc.path}/" "${hostCwd}/"`).catch(() => ({ stdout: '' }));
+            const filesChanged = rawDiff
+                .split('\n')
+                .filter(line => line && !line.startsWith('sending') && !line.startsWith('total') && !line.startsWith('sent ') && !line.includes('xfer#'))
+                .map(s => s.trim())
+                .filter(Boolean);
+            await execAsync(`rsync -a --exclude='.git' "${alloc.path}/" "${hostCwd}/"`);
+            return { success: true, filesChanged, conflicts: [] };
+        }
+        catch (error) {
+            return { success: false, filesChanged: [], conflicts: [], error: error.message };
+        }
+    }
+    async release(id, hostCwd = process.cwd()) {
+        const alloc = this.allocations.get(id);
+        if (!alloc)
+            return;
+        try {
+            if (alloc.backend === 'git') {
+                const repoRoot = await gitRepoRoot(hostCwd);
+                await execAsync(`git worktree remove --force "${alloc.path}"`, { cwd: repoRoot }).catch(() => { });
+                if (alloc.branch) {
+                    await execAsync(`git branch -D ${alloc.branch}`, { cwd: repoRoot }).catch(() => { });
+                }
+            }
+            else {
+                await fs.rm(alloc.path, { recursive: true, force: true }).catch(() => { });
+            }
+        }
+        finally {
+            this.allocations.delete(id);
+        }
+    }
+    async releaseAll(hostCwd = process.cwd()) {
+        const ids = Array.from(this.allocations.keys());
+        await Promise.all(ids.map(id => this.release(id, hostCwd)));
+    }
+    listActive() {
+        return Array.from(this.allocations.values());
+    }
+}
+export const worktreeManager = new WorktreeManager();
+//# sourceMappingURL=worktree-manager.js.map

package/dist/tools/llm/simple/planning-tools.js

@@ -19,7 +19,8 @@ DO NOT use for:
 Guidelines:
 - 1-5 TODOs (even 1 is fine for simple actions!)
 - Actionable titles that clearly describe what to do
-- Sequential order (execution order)
+- Use 'dependsOn' to mark dependencies — TODOs without dependsOn that share no prerequisites run in PARALLEL
+- Mark 'requiresFilesystem: true' for TODOs that write to disk (so the orchestrator isolates them)
 - Include details in title
 
 IMPORTANT: Write TODO titles in the user's language.`,
@@ -28,7 +29,7 @@ IMPORTANT: Write TODO titles in the user's language.`,
                 properties: {
                     todos: {
                         type: 'array',
-                        description: 'List of TODO items',
+                        description: 'List of TODO items. Independent items (no dependsOn) are dispatched concurrently when parallel execution is enabled.',
                         items: {
                             type: 'object',
                             properties: {
@@ -40,6 +41,19 @@ IMPORTANT: Write TODO titles in the user's language.`,
                                     type: 'string',
                                     description: 'Clear, actionable task title (in user language)',
                                 },
+                                dependsOn: {
+                                    type: 'array',
+                                    items: { type: 'string' },
+                                    description: 'Optional. IDs of other TODOs that must complete before this one starts. Omit for tasks that can run independently.',
+                                },
+                                requiresFilesystem: {
+                                    type: 'boolean',
+                                    description: 'Optional. True when this TODO writes to the filesystem (file edits, shell commands that modify state). Used to allocate per-worker worktree.',
+                                },
+                                parallelGroup: {
+                                    type: 'string',
+                                    description: 'Optional grouping label so the UI can visually group sibling parallel branches.',
+                                },
                             },
                             required: ['id', 'title'],
                         },

package/dist/types/index.d.ts

@@ -103,6 +103,18 @@ export interface OrquestaConfig {
     lastSyncAt?: string;
     connectedAt?: string;
 }
+export type OrchestrationRole = 'planner' | 'executor' | 'refiner';
+export interface RoleModels {
+    planner?: string;
+    executor?: string;
+    refiner?: string;
+}
+export interface OrchestrationConfig {
+    roleModels?: RoleModels;
+    maxParallelWorkers?: number;
+    refinerEnabled?: boolean;
+    worktreeIsolation?: boolean;
+}
 export interface OpenConfig {
     version: string;
     currentEndpoint?: string;
@@ -117,6 +129,7 @@ export interface OpenConfig {
     enabledTools?: string[];
     safeEnvVars?: string[];
     orquesta?: OrquestaConfig;
+    orchestration?: OrchestrationConfig;
 }
 export interface TodoItem {
     id: string;
@@ -124,6 +137,9 @@ export interface TodoItem {
     status: 'pending' | 'in_progress' | 'completed' | 'failed';
     result?: string;
     error?: string;
+    dependsOn?: string[];
+    requiresFilesystem?: boolean;
+    parallelGroup?: string;
 }
 export interface PlanningResult {
     todos: TodoItem[];

package/dist/ui/components/TodoListView.js

@@ -42,26 +42,64 @@ export const TodoListView = ({ todos, showProgressBar = true, }) => {
         });
     }, [todos]);
     const completedCount = todos.filter(t => t.status === 'completed').length;
+    const inProgressCount = todos.filter(t => t.status === 'in_progress').length;
     const totalCount = todos.length;
     if (totalCount === 0) {
         return null;
     }
+    const hasParallelGroups = todos.some(t => t.parallelGroup);
+    const isParallel = inProgressCount >= 2 || hasParallelGroups;
+    const renderTodoRow = (todo, indent = 0) => {
+        const config = STATUS_CONFIG[todo.status] || STATUS_CONFIG.pending;
+        const isInProgress = todo.status === 'in_progress';
+        const isCompleted = todo.status === 'completed';
+        return (React.createElement(Box, { key: todo.id, flexDirection: "column", marginLeft: indent },
+            React.createElement(Box, null,
+                React.createElement(Box, { width: 2 }, isInProgress ? (React.createElement(Text, { color: "blueBright" },
+                    React.createElement(Spinner, { type: "dots2" }))) : (React.createElement(Text, { color: config.color }, config.icon))),
+                React.createElement(Text, { color: isCompleted ? 'gray' : isInProgress ? 'white' : 'gray', dimColor: isCompleted, strikethrough: isCompleted, bold: isInProgress }, todo.title),
+                isInProgress && React.createElement(Text, { color: "blueBright" }, " \u2190"),
+                todo.dependsOn && todo.dependsOn.length > 0 && (React.createElement(Text, { color: "gray", dimColor: true },
+                    " (after ",
+                    todo.dependsOn.join(','),
+                    ")")),
+                todo.requiresFilesystem && isInProgress && (React.createElement(Text, { color: "yellow", dimColor: true }, " [worktree]"))),
+            todo.error && (React.createElement(Box, { marginLeft: 2 },
+                React.createElement(Text, { color: "red", dimColor: true },
+                    "\u26A0 ",
+                    todo.error)))));
+    };
+    const sections = [];
+    if (hasParallelGroups) {
+        const seen = new Map();
+        for (const t of todos) {
+            const key = t.parallelGroup ?? null;
+            let s = seen.get(key);
+            if (!s) {
+                s = { label: t.parallelGroup ?? null, items: [] };
+                seen.set(key, s);
+                sections.push(s);
+            }
+            s.items.push(t);
+        }
+    }
+    else {
+        sections.push({ label: null, items: todos });
+    }
     return (React.createElement(Box, { flexDirection: "column", paddingX: 1 },
-        todos.map((todo) => {
-            const config = STATUS_CONFIG[todo.status] || STATUS_CONFIG.pending;
-            const isInProgress = todo.status === 'in_progress';
-            const isCompleted = todo.status === 'completed';
-            return (React.createElement(Box, { key: todo.id, flexDirection: "column" },
-                React.createElement(Box, null,
-                    React.createElement(Box, { width: 2 }, isInProgress ? (React.createElement(Text, { color: "blueBright" },
-                        React.createElement(Spinner, { type: "dots2" }))) : (React.createElement(Text, { color: config.color }, config.icon))),
-                    React.createElement(Text, { color: isCompleted ? 'gray' : isInProgress ? 'white' : 'gray', dimColor: isCompleted, strikethrough: isCompleted, bold: isInProgress }, todo.title),
-                    isInProgress && (React.createElement(Text, { color: "blueBright" }, " \u2190"))),
-                todo.error && (React.createElement(Box, { marginLeft: 2 },
-                    React.createElement(Text, { color: "red", dimColor: true },
-                        "\u26A0 ",
-                        todo.error)))));
-        }),
+        isParallel && (React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "magentaBright", bold: true },
+                "\u2AF6\u2AF6 ",
+                inProgressCount,
+                " worker",
+                inProgressCount === 1 ? '' : 's',
+                " running in parallel"))),
+        sections.map((section, sIdx) => (React.createElement(Box, { key: `section-${sIdx}-${section.label ?? 'flat'}`, flexDirection: "column" },
+            section.label && (React.createElement(Box, { marginTop: sIdx === 0 ? 0 : 1 },
+                React.createElement(Text, { color: "cyan", dimColor: true },
+                    "\u250C\u2500 ",
+                    section.label))),
+            section.items.map(t => renderTodoRow(t, section.label ? 2 : 0))))),
         showProgressBar && (React.createElement(Box, { marginTop: 1 },
             React.createElement(ProgressBar, { completed: completedCount, total: totalCount, width: 20 })))));
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orquesta-cli",
-  "version": "0.1.26",
+  "version": "0.2.0",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",