recoder-code 2.5.2 → 2.5.3

package/dist/src/parallel/git-utils.js

@@ -0,0 +1,161 @@
+/**
+ * Git utilities for parallel mode
+ * Based on Kilo Code (Apache-2.0 License)
+ */
+import simpleGit from 'simple-git';
+/**
+ * Get Git repository information for a given directory
+ */
+export async function getGitInfo(cwd) {
+    const defaultResult = {
+        branch: null,
+        isClean: true,
+        isRepo: false,
+    };
+    if (!cwd) {
+        return defaultResult;
+    }
+    try {
+        const git = simpleGit(cwd);
+        // Check if it's a git repository
+        const isRepo = await git.checkIsRepo();
+        if (!isRepo) {
+            return defaultResult;
+        }
+        // Get current branch
+        const branch = await git.revparse(['--abbrev-ref', 'HEAD']);
+        // Check if working directory is clean
+        const status = await git.status();
+        const isClean = status.files.length === 0;
+        return {
+            branch: branch.trim() || null,
+            isClean,
+            isRepo: true,
+        };
+    }
+    catch (error) {
+        console.debug('Failed to get git info:', error);
+        return defaultResult;
+    }
+}
+/**
+ * Get just the branch name (faster than full git info)
+ */
+export async function getGitBranch(cwd) {
+    if (!cwd) {
+        return null;
+    }
+    try {
+        const git = simpleGit(cwd);
+        const isRepo = await git.checkIsRepo();
+        if (!isRepo) {
+            return null;
+        }
+        const branch = await git.revparse(['--abbrev-ref', 'HEAD']);
+        return branch.trim() || null;
+    }
+    catch (error) {
+        console.debug('Failed to get git branch:', error);
+        return null;
+    }
+}
+/**
+ * Check if a branch exists in the repository
+ */
+export async function branchExists(cwd, branchName) {
+    if (!cwd || !branchName) {
+        return false;
+    }
+    try {
+        const git = simpleGit(cwd);
+        const isRepo = await git.checkIsRepo();
+        if (!isRepo) {
+            return false;
+        }
+        // Get all branches (local and remote)
+        const branches = await git.branch();
+        // Check if branch exists in local branches
+        return branches.all.includes(branchName) || branches.all.includes(`remotes/origin/${branchName}`);
+    }
+    catch (error) {
+        console.debug('Failed to check if branch exists:', error);
+        return false;
+    }
+}
+/**
+ * Generate a valid git branch name from a prompt
+ * Sanitizes the prompt to create a safe branch name
+ */
+export function generateBranchName(prompt) {
+    // Take first 50 chars, convert to lowercase, replace spaces and special chars with hyphens
+    const sanitized = prompt
+        .slice(0, 50)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '') // Remove leading/trailing hyphens
+        .replace(/-+/g, '-'); // Collapse multiple hyphens
+    // Add timestamp to ensure uniqueness
+    const timestamp = Date.now();
+    return `recoder/${sanitized || 'task'}-${timestamp}`;
+}
+/**
+ * Check if a directory is a git worktree
+ */
+export async function isGitWorktree(cwd) {
+    if (!cwd) {
+        return false;
+    }
+    try {
+        const git = simpleGit(cwd);
+        const isRepo = await git.checkIsRepo();
+        if (!isRepo) {
+            return false;
+        }
+        // In a worktree, --git-dir points to .git/worktrees/<name>
+        // In a normal repo, --git-dir points to .git
+        const gitDir = await git.revparse(['--git-dir']);
+        return gitDir.trim().includes('worktrees');
+    }
+    catch (error) {
+        console.debug('Failed to check if git worktree:', error);
+        return false;
+    }
+}
+/**
+ * Create a git worktree
+ */
+export async function createWorktree(cwd, worktreePath, branchName, isNewBranch) {
+    const git = simpleGit(cwd);
+    const args = isNewBranch
+        ? ['worktree', 'add', '-b', branchName, worktreePath]
+        : ['worktree', 'add', worktreePath, branchName];
+    await git.raw(args);
+}
+/**
+ * Remove a git worktree
+ */
+export async function removeWorktree(cwd, worktreePath) {
+    const git = simpleGit(cwd);
+    await git.raw(['worktree', 'remove', worktreePath]);
+}
+/**
+ * List all worktrees for a repository
+ */
+export async function listWorktrees(cwd) {
+    try {
+        const git = simpleGit(cwd);
+        const result = await git.raw(['worktree', 'list', '--porcelain']);
+        const worktrees = [];
+        const lines = result.split('\n');
+        for (const line of lines) {
+            if (line.startsWith('worktree ')) {
+                worktrees.push(line.replace('worktree ', '').trim());
+            }
+        }
+        return worktrees;
+    }
+    catch (error) {
+        console.debug('Failed to list worktrees:', error);
+        return [];
+    }
+}

package/dist/src/parallel/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Parallel Mode - Git Worktree-based Parallel Execution
+ *
+ * Allows multiple Recoder instances to work on the same repository
+ * without conflicts by using separate git worktrees.
+ *
+ * Usage:
+ *   recoder --parallel "implement feature X"
+ *   recoder --parallel --existing-branch recoder/feature-x-123 "continue work"
+ *
+ * Based on Kilo Code (Apache-2.0 License)
+ */
+export { startParallelMode, finishParallelMode, getParallelModeParams, listParallelWorktrees, cleanupStaleWorktrees, type ParallelModeInput, type ParallelModeParams, type ParallelModeResult, } from './parallel-mode.js';
+export { getGitInfo, getGitBranch, branchExists, generateBranchName, isGitWorktree, createWorktree, removeWorktree, listWorktrees, type GitInfo, } from './git-utils.js';

package/dist/src/parallel/index.js

@@ -0,0 +1,14 @@
+/**
+ * Parallel Mode - Git Worktree-based Parallel Execution
+ *
+ * Allows multiple Recoder instances to work on the same repository
+ * without conflicts by using separate git worktrees.
+ *
+ * Usage:
+ *   recoder --parallel "implement feature X"
+ *   recoder --parallel --existing-branch recoder/feature-x-123 "continue work"
+ *
+ * Based on Kilo Code (Apache-2.0 License)
+ */
+export { startParallelMode, finishParallelMode, getParallelModeParams, listParallelWorktrees, cleanupStaleWorktrees, } from './parallel-mode.js';
+export { getGitInfo, getGitBranch, branchExists, generateBranchName, isGitWorktree, createWorktree, removeWorktree, listWorktrees, } from './git-utils.js';

package/dist/src/parallel/parallel-mode.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Parallel Mode - Execute multiple tasks simultaneously using git worktrees
+ * Based on Kilo Code (Apache-2.0 License)
+ *
+ * Parallel mode allows multiple Recoder instances to work on the same repository
+ * without conflicts. Each instance operates in a separate git worktree.
+ */
+export declare const COMMIT_COMPLETION_TIMEOUT = 40000;
+export interface ParallelModeInput {
+    cwd: string;
+    prompt: string;
+    timeout?: number;
+    existingBranch?: string;
+}
+export interface ParallelModeParams {
+    worktreeBranch: string;
+    worktreePath: string;
+}
+export interface ParallelModeResult {
+    success: boolean;
+    branch: string;
+    worktreePath: string;
+    message: string;
+}
+/**
+ * Determine the branch and worktree path for parallel mode
+ */
+export declare function determineParallelBranch({ cwd, prompt, existingBranch, }: ParallelModeInput): Promise<ParallelModeParams>;
+/**
+ * Get parameters for parallel mode execution
+ */
+export declare function getParallelModeParams({ cwd, prompt, existingBranch, }: ParallelModeInput): Promise<ParallelModeParams>;
+/**
+ * Finish parallel mode by committing changes and cleaning up worktree
+ */
+export declare function finishParallelMode(worktreePath: string, worktreeBranch: string, originalCwd: string): Promise<ParallelModeResult>;
+/**
+ * Start parallel mode - creates worktree and returns the working directory
+ */
+export declare function startParallelMode(cwd: string, prompt: string, existingBranch?: string): Promise<ParallelModeParams>;
+/**
+ * List active parallel mode worktrees
+ */
+export declare function listParallelWorktrees(cwd: string): Promise<string[]>;
+/**
+ * Clean up stale parallel mode worktrees
+ */
+export declare function cleanupStaleWorktrees(cwd: string): Promise<number>;

package/dist/src/parallel/parallel-mode.js

@@ -0,0 +1,224 @@
+/**
+ * Parallel Mode - Execute multiple tasks simultaneously using git worktrees
+ * Based on Kilo Code (Apache-2.0 License)
+ *
+ * Parallel mode allows multiple Recoder instances to work on the same repository
+ * without conflicts. Each instance operates in a separate git worktree.
+ */
+import path from 'path';
+import os from 'os';
+import simpleGit from 'simple-git';
+import { getGitInfo, generateBranchName, branchExists, createWorktree, removeWorktree, } from './git-utils.js';
+export const COMMIT_COMPLETION_TIMEOUT = 40000;
+/**
+ * Determine the branch and worktree path for parallel mode
+ */
+export async function determineParallelBranch({ cwd, prompt, existingBranch, }) {
+    const { isRepo, branch } = await getGitInfo(cwd);
+    if (!isRepo) {
+        throw new Error('Parallel mode requires the current working directory to be a git repository');
+    }
+    if (!branch) {
+        throw new Error('Could not determine current git branch');
+    }
+    // Determine the branch to use
+    let worktreeBranch;
+    if (existingBranch) {
+        // Check if the existing branch exists
+        const exists = await branchExists(cwd, existingBranch);
+        if (!exists) {
+            throw new Error(`Branch "${existingBranch}" does not exist`);
+        }
+        worktreeBranch = existingBranch;
+        console.log(`📌 Using existing branch: ${worktreeBranch}`);
+    }
+    else {
+        // Generate branch name from prompt
+        worktreeBranch = generateBranchName(prompt);
+        console.log(`🌿 Creating new branch: ${worktreeBranch}`);
+    }
+    // Create worktree directory path in OS temp directory
+    const tempDir = os.tmpdir();
+    const worktreePath = path.join(tempDir, `recoder-worktree-${worktreeBranch.replace(/\//g, '-')}`);
+    // Create worktree
+    try {
+        await createWorktree(cwd, worktreePath, worktreeBranch, !existingBranch);
+        console.log(`📁 Created worktree at: ${worktreePath}`);
+    }
+    catch (error) {
+        console.error('Failed to create worktree:', error);
+        throw error;
+    }
+    return { worktreeBranch, worktreePath };
+}
+/**
+ * Get parameters for parallel mode execution
+ */
+export async function getParallelModeParams({ cwd, prompt, existingBranch, }) {
+    try {
+        return await determineParallelBranch({ cwd, prompt, existingBranch });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to start parallel mode: ${message}`);
+        throw error;
+    }
+}
+/**
+ * Helper function to commit changes with a fallback message
+ */
+async function commitWithFallback(cwd) {
+    const fallbackMessage = 'chore: recoder parallel mode task completion';
+    const git = simpleGit(cwd);
+    await git.commit(fallbackMessage);
+    console.log('📝 Changes committed with fallback message');
+}
+/**
+ * Poll git status to check if commit is complete
+ * Returns true if commit was made, false if timeout reached
+ */
+async function waitForCommitCompletion(cwd) {
+    const pollIntervalMs = 1000;
+    const startTime = Date.now();
+    const git = simpleGit(cwd);
+    while (Date.now() - startTime < COMMIT_COMPLETION_TIMEOUT) {
+        try {
+            const stagedDiff = await git.diff(['--staged']);
+            // If no staged changes, commit was successful
+            if (!stagedDiff.trim()) {
+                return true;
+            }
+            // Wait before next poll
+            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        }
+        catch (error) {
+            console.error('Error checking commit status:', error);
+            return false;
+        }
+    }
+    return false;
+}
+/**
+ * Finish parallel mode by committing changes and cleaning up worktree
+ */
+export async function finishParallelMode(worktreePath, worktreeBranch, originalCwd) {
+    const git = simpleGit(worktreePath);
+    try {
+        const status = await git.status();
+        if (!status.isClean()) {
+            console.log('📦 Staging all changes...');
+            await git.add('-A');
+            const diff = await git.diff(['--staged']);
+            if (!diff.trim()) {
+                console.warn('⚠️ No staged changes found after git add');
+            }
+            else {
+                console.log('📝 Committing changes...');
+                await commitWithFallback(worktreePath);
+            }
+        }
+        else {
+            console.log('✨ No changes to commit');
+        }
+        // Print completion message
+        const green = '\x1b[32m';
+        const cyan = '\x1b[36m';
+        const yellow = '\x1b[33m';
+        const bold = '\x1b[1m';
+        const reset = '\x1b[0m';
+        console.log('\n' + cyan + '─'.repeat(80) + reset);
+        console.log(`${green}✓${reset} ${bold}Parallel mode complete!${reset} Changes committed to: ${cyan}${worktreeBranch}${reset}`);
+        console.log(`\n${bold}Review and merge changes:${reset}`);
+        console.log(`  ${yellow}git diff ...${worktreeBranch}${reset}`);
+        console.log(`  ${yellow}git merge ${worktreeBranch}${reset}`);
+        console.log(`\n${bold}💡 Tip:${reset} Resume work with ${yellow}--existing-branch${reset}:`);
+        console.log(`  ${yellow}recoder --parallel --existing-branch ${worktreeBranch} "<prompt>"${reset}`);
+        console.log(cyan + '─'.repeat(80) + reset + '\n');
+        return {
+            success: true,
+            branch: worktreeBranch,
+            worktreePath,
+            message: `Changes committed to branch: ${worktreeBranch}`,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error('Failed to commit changes:', errorMessage);
+        return {
+            success: false,
+            branch: worktreeBranch,
+            worktreePath,
+            message: `Failed to commit: ${errorMessage}`,
+        };
+    }
+    finally {
+        // Clean up worktree
+        try {
+            console.log(`🧹 Removing worktree at: ${worktreePath}`);
+            await removeWorktree(originalCwd, worktreePath);
+            console.log('✅ Worktree removed successfully');
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            console.warn('⚠️ Failed to remove worktree:', errorMessage);
+        }
+    }
+}
+/**
+ * Start parallel mode - creates worktree and returns the working directory
+ */
+export async function startParallelMode(cwd, prompt, existingBranch) {
+    console.log('\n🚀 Starting Recoder Parallel Mode...\n');
+    const params = await getParallelModeParams({
+        cwd,
+        prompt,
+        existingBranch,
+    });
+    console.log(`\n✅ Parallel mode ready!`);
+    console.log(`📍 Working in: ${params.worktreePath}`);
+    console.log(`🌿 Branch: ${params.worktreeBranch}\n`);
+    return params;
+}
+/**
+ * List active parallel mode worktrees
+ */
+export async function listParallelWorktrees(cwd) {
+    const git = simpleGit(cwd);
+    try {
+        const result = await git.raw(['worktree', 'list', '--porcelain']);
+        const worktrees = [];
+        const lines = result.split('\n');
+        for (const line of lines) {
+            if (line.startsWith('worktree ')) {
+                const path = line.replace('worktree ', '').trim();
+                // Only include recoder worktrees
+                if (path.includes('recoder-worktree-')) {
+                    worktrees.push(path);
+                }
+            }
+        }
+        return worktrees;
+    }
+    catch (error) {
+        console.debug('Failed to list worktrees:', error);
+        return [];
+    }
+}
+/**
+ * Clean up stale parallel mode worktrees
+ */
+export async function cleanupStaleWorktrees(cwd) {
+    const worktrees = await listParallelWorktrees(cwd);
+    let cleaned = 0;
+    for (const worktreePath of worktrees) {
+        try {
+            await removeWorktree(cwd, worktreePath);
+            cleaned++;
+            console.log(`🧹 Removed stale worktree: ${worktreePath}`);
+        }
+        catch (error) {
+            console.debug(`Failed to remove worktree ${worktreePath}:`, error);
+        }
+    }
+    return cleaned;
+}

package/dist/src/services/AgentBridgeService.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Agent Bridge Service
+ *
+ * Connects recoder-code CLI to the A2A workspace system on docker-backend
+ * via WebSocket. Enables local agents to:
+ *   - Register as workspace members
+ *   - Receive task assignments in real-time
+ *   - Report task progress and results
+ *   - Participate in channel conversations
+ *
+ * Uses existing RecoderAuthService for authentication tokens.
+ * Auto-reconnects with exponential backoff (same pattern as PlatformSyncService).
+ */
+import { EventEmitter } from 'events';
+export interface TaskAssignment {
+    taskId: string;
+    prompt: string;
+    context: Record<string, unknown>;
+    worktreeBranch?: string;
+}
+export interface ChannelMessageEvent {
+    channelId: string;
+    from: string;
+    content: string;
+}
+export interface WorkspaceAgent {
+    agentId: string;
+    status: string;
+    isLocal: boolean;
+    capabilities: string[];
+}
+export declare class AgentBridgeService extends EventEmitter {
+    private ws;
+    private reconnectTimeout;
+    private heartbeatInterval;
+    private connected;
+    private agentId;
+    private workspaceId;
+    private reconnectAttempts;
+    private readonly maxReconnectDelay;
+    private getToken;
+    constructor(getToken: () => Promise<string | null>, agentId?: string);
+    connect(workspaceId: string, capabilities?: string[]): Promise<void>;
+    private connectWebSocket;
+    disconnect(): void;
+    private scheduleReconnect;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private send;
+    joinWorkspace(workspaceId: string): void;
+    leaveWorkspace(workspaceId: string): void;
+    sendProgress(taskId: string, progress: number, output: string): void;
+    completeTask(taskId: string, result: unknown): void;
+    failTask(taskId: string, error: string): void;
+    sendChannelMessage(channelId: string, content: string): void;
+    private handleMessage;
+    isConnected(): boolean;
+    getAgentId(): string;
+    getWorkspaceId(): string | null;
+    displayStatus(): void;
+}