codex-linux 1.0.0

package/dist/main/agents/AgentOrchestrator.js

@@ -0,0 +1,787 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentOrchestrator = void 0;
+const events_1 = require("events");
+const uuid_1 = require("uuid");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+const electron_log_1 = __importDefault(require("electron-log"));
+const types_1 = require("../../shared/types");
+const PermissionManager_1 = require("../security/PermissionManager");
+const ClaudeMdParser_1 = require("../config/ClaudeMdParser");
+class AgentOrchestrator extends events_1.EventEmitter {
+    aiProviderManager;
+    gitWorktreeManager;
+    skillsManager;
+    dbManager;
+    agents = new Map();
+    activeTasks = new Map();
+    lastActivity = new Map();
+    cleanupInterval = null;
+    INACTIVE_THRESHOLD = 24 * 60 * 60 * 1000; // 24 hours
+    MAX_RETRIES = 3;
+    RETRY_DELAY = 1000; // 1 second
+    AUTO_CONTEXT_MAX_FILES = 12;
+    AUTO_CONTEXT_MAX_CHARS_PER_FILE = 4000;
+    AUTO_CONTEXT_MAX_TOTAL_CHARS = 24000;
+    permissionManager;
+    constructor(aiProviderManager, gitWorktreeManager, skillsManager, dbManager) {
+        super();
+        this.aiProviderManager = aiProviderManager;
+        this.gitWorktreeManager = gitWorktreeManager;
+        this.skillsManager = skillsManager;
+        this.dbManager = dbManager;
+        this.permissionManager = new PermissionManager_1.PermissionManager();
+        this.startCleanupInterval();
+    }
+    startCleanupInterval() {
+        // Cleanup inactive agents every hour
+        this.cleanupInterval = setInterval(() => {
+            this.cleanupInactiveAgents();
+        }, 60 * 60 * 1000);
+        // Don't keep the process alive (important for tests)
+        this.cleanupInterval.unref?.();
+    }
+    async getAgentOrThrow(agentId) {
+        const cached = this.agents.get(agentId);
+        if (cached)
+            return cached;
+        const fromDb = await this.dbManager.getAgent(agentId);
+        if (!fromDb) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        this.agents.set(agentId, fromDb);
+        this.lastActivity.set(agentId, fromDb.lastActiveAt || fromDb.updatedAt);
+        return fromDb;
+    }
+    async cleanupInactiveAgents() {
+        const now = new Date();
+        const agentsToDelete = [];
+        for (const [agentId, lastActive] of this.lastActivity) {
+            const inactiveTime = now.getTime() - lastActive.getTime();
+            if (inactiveTime > this.INACTIVE_THRESHOLD) {
+                const agent = this.agents.get(agentId);
+                if (agent && agent.status !== types_1.AgentStatus.RUNNING) {
+                    agentsToDelete.push(agentId);
+                }
+            }
+        }
+        for (const agentId of agentsToDelete) {
+            try {
+                await this.deleteAgent(agentId);
+                electron_log_1.default.info(`Cleaned up inactive agent: ${agentId}`);
+            }
+            catch (error) {
+                electron_log_1.default.error(`Failed to cleanup agent ${agentId}:`, error);
+            }
+        }
+    }
+    async initialize() {
+        // Load existing agents from database
+        const agents = await this.dbManager.getAllAgents();
+        for (const agent of agents) {
+            this.agents.set(agent.id, agent);
+            this.lastActivity.set(agent.id, agent.lastActiveAt || agent.updatedAt);
+            if (agent.status === types_1.AgentStatus.RUNNING) {
+                // Mark as error since we can't restore running state
+                agent.status = types_1.AgentStatus.ERROR;
+                await this.dbManager.updateAgent(agent);
+            }
+        }
+        electron_log_1.default.info(`Loaded ${agents.length} agents from database`);
+    }
+    async cleanup() {
+        // Stop cleanup interval
+        if (this.cleanupInterval) {
+            clearInterval(this.cleanupInterval);
+            this.cleanupInterval = null;
+        }
+        // Stop all running agents
+        const cleanupPromises = [];
+        for (const [agentId, agent] of this.agents) {
+            if (agent.status === types_1.AgentStatus.RUNNING) {
+                cleanupPromises.push(this.pauseAgent(agentId));
+            }
+        }
+        await Promise.all(cleanupPromises);
+        // Clear maps
+        this.agents.clear();
+        this.activeTasks.clear();
+        this.lastActivity.clear();
+    }
+    async createAgent(config) {
+        const agentId = (0, uuid_1.v4)();
+        const worktreeName = `codex-agent-${agentId.slice(0, 8)}`;
+        // Create worktree for isolation
+        const worktree = await this.gitWorktreeManager.createWorktree(config.projectPath, worktreeName);
+        // Load CLAUDE.md configuration
+        const claudeMdParser = new ClaudeMdParser_1.ClaudeMdParser();
+        const claudeMdConfig = await claudeMdParser.load(config.projectPath);
+        // Merge CLAUDE.md config with provided config
+        const mergedConfig = {
+            ...config,
+            // Override with CLAUDE.md agent settings if present
+            model: claudeMdConfig?.agents?.defaultModel || config.model,
+            providerId: claudeMdConfig?.agents?.defaultProvider || config.providerId,
+            skills: [...(config.skills || []), ...(claudeMdConfig?.agents?.skills || [])],
+            systemPrompt: this.buildSystemPrompt(config.systemPrompt, claudeMdConfig)
+        };
+        const agent = {
+            id: agentId,
+            name: mergedConfig.name,
+            status: types_1.AgentStatus.IDLE,
+            projectPath: mergedConfig.projectPath,
+            worktreeName,
+            worktreePath: worktree.path,
+            providerId: mergedConfig.providerId,
+            model: mergedConfig.model,
+            skills: mergedConfig.skills || [],
+            permissionMode: claudeMdConfig?.agents?.permissionMode || this.permissionManager.getDefaultMode(),
+            createdAt: new Date(),
+            updatedAt: new Date(),
+            lastActiveAt: null,
+            messages: [],
+            tasks: [],
+            metadata: {
+                ...mergedConfig.metadata,
+                worktreePath: worktree.path,
+                claudeMdConfig: claudeMdConfig ? {
+                    version: claudeMdConfig.version,
+                    projectName: claudeMdConfig.project?.name,
+                    loadedAt: new Date().toISOString()
+                } : undefined
+            }
+        };
+        // Add system message if provided
+        if (mergedConfig.systemPrompt) {
+            agent.messages.push({
+                id: (0, uuid_1.v4)(),
+                role: 'system',
+                content: mergedConfig.systemPrompt,
+                timestamp: new Date()
+            });
+        }
+        // Apply skills
+        if (agent.skills.length > 0) {
+            await this.applySkillsInternal(agent, agent.skills);
+        }
+        this.agents.set(agentId, agent);
+        this.lastActivity.set(agentId, new Date());
+        await this.dbManager.createAgent(agent);
+        this.emit('agent:created', agent);
+        electron_log_1.default.info(`Created agent ${agentId} (${agent.name})`);
+        return agent;
+    }
+    async listAgents() {
+        return Array.from(this.agents.values());
+    }
+    async getAgent(agentId) {
+        return this.agents.get(agentId) || null;
+    }
+    async sendMessage(agentId, message, options) {
+        const agent = await this.getAgentOrThrow(agentId);
+        const userMessage = {
+            id: (0, uuid_1.v4)(),
+            role: 'user',
+            content: message,
+            timestamp: new Date()
+        };
+        agent.messages.push(userMessage);
+        agent.lastActiveAt = new Date();
+        agent.status = types_1.AgentStatus.RUNNING;
+        this.lastActivity.set(agentId, new Date());
+        await this.dbManager.updateAgent(agent);
+        this.emit('agent:message', { agentId, message: userMessage });
+        // Get AI response with retry logic
+        try {
+            const autoContext = await this.buildAutoContext(agent, message);
+            const response = await this.getAIResponseWithRetry(agent, options, autoContext?.systemMessage);
+            const assistantMessage = {
+                id: (0, uuid_1.v4)(),
+                role: 'assistant',
+                content: response.content,
+                timestamp: new Date(),
+                metadata: {
+                    ...response.metadata,
+                    autoContext: autoContext?.metadata
+                }
+            };
+            agent.messages.push(assistantMessage);
+            agent.status = types_1.AgentStatus.IDLE;
+            await this.dbManager.updateAgent(agent);
+            this.emit('agent:message', { agentId, message: assistantMessage });
+            return assistantMessage;
+        }
+        catch (error) {
+            agent.status = types_1.AgentStatus.ERROR;
+            await this.dbManager.updateAgent(agent);
+            throw error;
+        }
+    }
+    async sendMessageStream(agentId, message, callbacks) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        const userMessage = {
+            id: (0, uuid_1.v4)(),
+            role: 'user',
+            content: message,
+            timestamp: new Date()
+        };
+        agent.messages.push(userMessage);
+        agent.lastActiveAt = new Date();
+        agent.status = types_1.AgentStatus.RUNNING;
+        this.lastActivity.set(agentId, new Date());
+        await this.dbManager.updateAgent(agent);
+        this.emit('agent:message', { agentId, message: userMessage });
+        try {
+            const provider = this.aiProviderManager.getProvider(agent.providerId);
+            if (!provider) {
+                throw new Error(`Provider ${agent.providerId} not found`);
+            }
+            const autoContext = await this.buildAutoContext(agent, message);
+            const modelMessages = (autoContext?.systemMessage
+                ? [...agent.messages, autoContext.systemMessage]
+                : agent.messages);
+            // Check if provider supports streaming
+            if (typeof provider.sendMessageStream === 'function') {
+                await provider.sendMessageStream(agent.model, modelMessages, {
+                    onChunk: (chunk) => {
+                        callbacks.onChunk(chunk);
+                    },
+                    onComplete: async () => {
+                        const response = await this.getAIResponseWithRetry(agent, undefined, autoContext?.systemMessage);
+                        const assistantMessage = {
+                            id: (0, uuid_1.v4)(),
+                            role: 'assistant',
+                            content: response.content,
+                            timestamp: new Date(),
+                            metadata: {
+                                ...response.metadata,
+                                autoContext: autoContext?.metadata
+                            }
+                        };
+                        agent.messages.push(assistantMessage);
+                        agent.status = types_1.AgentStatus.IDLE;
+                        await this.dbManager.updateAgent(agent);
+                        this.emit('agent:message', { agentId, message: assistantMessage });
+                        callbacks.onComplete();
+                    },
+                    onError: async (error) => {
+                        agent.status = types_1.AgentStatus.ERROR;
+                        await this.dbManager.updateAgent(agent);
+                        callbacks.onError(error);
+                    }
+                });
+            }
+            else {
+                // Fallback to non-streaming
+                const response = await this.getAIResponseWithRetry(agent, undefined, autoContext?.systemMessage);
+                callbacks.onChunk(response.content);
+                const assistantMessage = {
+                    id: (0, uuid_1.v4)(),
+                    role: 'assistant',
+                    content: response.content,
+                    timestamp: new Date(),
+                    metadata: {
+                        ...response.metadata,
+                        autoContext: autoContext?.metadata
+                    }
+                };
+                agent.messages.push(assistantMessage);
+                agent.status = types_1.AgentStatus.IDLE;
+                await this.dbManager.updateAgent(agent);
+                this.emit('agent:message', { agentId, message: assistantMessage });
+                callbacks.onComplete();
+            }
+        }
+        catch (error) {
+            agent.status = types_1.AgentStatus.ERROR;
+            await this.dbManager.updateAgent(agent);
+            callbacks.onError(error);
+        }
+    }
+    async getAIResponseWithRetry(agent, options, ephemeralSystemMessage, attempt = 1) {
+        try {
+            return await this.getAIResponse(agent, options, ephemeralSystemMessage);
+        }
+        catch (error) {
+            if (attempt < this.MAX_RETRIES && this.isRetryableError(error)) {
+                electron_log_1.default.warn(`Retrying AI request for agent ${agent.id}, attempt ${attempt + 1}/${this.MAX_RETRIES}`);
+                await this.delay(this.RETRY_DELAY * attempt); // Exponential backoff
+                return this.getAIResponseWithRetry(agent, options, ephemeralSystemMessage, attempt + 1);
+            }
+            throw error;
+        }
+    }
+    async getAIResponse(agent, options, ephemeralSystemMessage) {
+        const provider = this.aiProviderManager.getProvider(agent.providerId);
+        if (!provider) {
+            throw new Error(`Provider ${agent.providerId} not found`);
+        }
+        const messages = (ephemeralSystemMessage
+            ? [...agent.messages, ephemeralSystemMessage]
+            : agent.messages).map(m => ({ role: m.role, content: m.content }));
+        return await provider.sendMessage(agent.model, messages, {
+            signal: options?.signal,
+            onProgress: options?.onProgress,
+            extendedThinking: options?.extendedThinking,
+            reasoningEffort: options?.reasoningEffort
+        });
+    }
+    async buildAutoContext(agent, userIntent) {
+        const enabled = agent.metadata?.autoContext !== false;
+        if (!enabled)
+            return null;
+        if (!agent.projectPath || typeof agent.projectPath !== 'string') {
+            return null;
+        }
+        const worktreePath = agent.worktreePath
+            ? agent.worktreePath
+            : (agent.worktreeName
+                ? path.join(agent.projectPath, '.codex', 'worktrees', agent.worktreeName)
+                : agent.projectPath);
+        if (!worktreePath || typeof worktreePath !== 'string') {
+            return null;
+        }
+        const candidates = [];
+        const addCandidate = (relPath, reason) => {
+            if (!relPath)
+                return;
+            if (candidates.some(c => c.relPath === relPath))
+                return;
+            candidates.push({ relPath, reason });
+        };
+        // Always-valuable files
+        addCandidate('CLAUDE.md', 'Project conventions');
+        addCandidate('README.md', 'Project overview');
+        addCandidate('package.json', 'Dependencies/scripts');
+        addCandidate('tsconfig.json', 'TypeScript config');
+        addCandidate('tsconfig.main.json', 'Main TS config');
+        addCandidate('tsconfig.renderer.json', 'Renderer TS config');
+        // Recently changed files in this worktree
+        try {
+            const changes = await this.gitWorktreeManager.getChanges(worktreePath);
+            const recent = [...changes.staged, ...changes.unstaged].slice(0, 6);
+            for (const f of recent) {
+                addCandidate(f, 'Recently changed in worktree');
+            }
+        }
+        catch {
+            // ignore
+        }
+        const selected = candidates.slice(0, this.AUTO_CONTEXT_MAX_FILES);
+        let totalChars = 0;
+        const used = [];
+        const parts = [];
+        for (const c of selected) {
+            const abs = path.join(worktreePath, c.relPath);
+            try {
+                const raw = await fs.readFile(abs, 'utf-8');
+                const clipped = raw.length > this.AUTO_CONTEXT_MAX_CHARS_PER_FILE
+                    ? raw.slice(0, this.AUTO_CONTEXT_MAX_CHARS_PER_FILE) + '\n\n[TRUNCATED]'
+                    : raw;
+                if (totalChars + clipped.length > this.AUTO_CONTEXT_MAX_TOTAL_CHARS)
+                    break;
+                totalChars += clipped.length;
+                used.push({ path: c.relPath, reason: c.reason });
+                parts.push(`## ${c.relPath}\nReason: ${c.reason}\n\n${clipped}`);
+            }
+            catch {
+                // ignore
+            }
+        }
+        if (parts.length === 0)
+            return null;
+        const systemMessage = {
+            id: (0, uuid_1.v4)(),
+            role: 'system',
+            content: `# Auto-context (ephemeral)\nUser intent: ${userIntent}\n\n${parts.join('\n\n')}`,
+            timestamp: new Date(),
+            metadata: {
+                autoContext: {
+                    files: used,
+                    totalChars
+                }
+            }
+        };
+        return {
+            systemMessage,
+            metadata: {
+                files: used,
+                totalChars
+            }
+        };
+    }
+    isRetryableError(error) {
+        // Retry on network errors, timeouts, rate limits
+        if (!error)
+            return false;
+        const retryableCodes = ['ECONNRESET', 'ETIMEDOUT', 'ECONNREFUSED', 'RATE_LIMITED'];
+        const retryableStatuses = [429, 502, 503, 504];
+        return retryableCodes.includes(error.code) ||
+            retryableStatuses.includes(error.status) ||
+            error.message?.includes('timeout') ||
+            error.message?.includes('rate limit');
+    }
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    async executeTask(agentId, task, timeout = 30 * 60 * 1000) {
+        const agent = await this.getAgentOrThrow(agentId);
+        const taskId = (0, uuid_1.v4)();
+        const agentTask = {
+            id: taskId,
+            description: task,
+            status: types_1.TaskStatus.RUNNING,
+            progress: 0,
+            startedAt: new Date()
+        };
+        agent.tasks.push(agentTask);
+        agent.status = types_1.AgentStatus.RUNNING;
+        this.lastActivity.set(agentId, new Date());
+        await this.dbManager.updateAgent(agent);
+        this.emit('agent:taskStarted', { agentId, task: agentTask });
+        // Create abort controller for this task
+        const abortController = new AbortController();
+        this.activeTasks.set(taskId, abortController);
+        // Set up timeout
+        const timeoutId = setTimeout(() => {
+            abortController.abort();
+            electron_log_1.default.warn(`Task ${taskId} timed out after ${timeout}ms`);
+        }, timeout);
+        // Execute task in background
+        this.runTask(agent, agentTask, abortController)
+            .then(() => {
+            clearTimeout(timeoutId);
+        })
+            .catch(error => {
+            clearTimeout(timeoutId);
+            electron_log_1.default.error(`Task ${taskId} failed:`, error);
+            agentTask.status = types_1.TaskStatus.FAILED;
+            agentTask.error = error.message;
+            agentTask.completedAt = new Date();
+            this.emit('agent:taskFailed', { agentId, task: agentTask, error });
+        });
+        return agentTask;
+    }
+    async runTask(agent, task, abortController) {
+        try {
+            // Set up task context
+            const taskMessage = {
+                id: (0, uuid_1.v4)(),
+                role: 'user',
+                content: `[TASK] ${task.description}`,
+                timestamp: new Date()
+            };
+            agent.messages.push(taskMessage);
+            // Process the task with streaming updates
+            const autoContext = await this.buildAutoContext(agent, task.description);
+            const response = await this.getAIResponse(agent, {
+                signal: abortController.signal,
+                onProgress: (progress) => {
+                    task.progress = progress;
+                    this.emit('agent:progress', { agentId: agent.id, taskId: task.id, progress });
+                }
+            }, autoContext?.systemMessage);
+            // Parse and apply code changes
+            const changes = await this.parseAndApplyChanges(agent, response.content);
+            task.result = response.content;
+            task.status = types_1.TaskStatus.COMPLETED;
+            task.progress = 100;
+            task.completedAt = new Date();
+            const assistantMessage = {
+                id: (0, uuid_1.v4)(),
+                role: 'assistant',
+                content: response.content,
+                timestamp: new Date(),
+                metadata: {
+                    changes: changes.map(c => c.id),
+                    autoContext: autoContext?.metadata
+                }
+            };
+            agent.messages.push(assistantMessage);
+            agent.status = types_1.AgentStatus.IDLE;
+            agent.lastActiveAt = new Date();
+            await this.dbManager.updateAgent(agent);
+            this.emit('agent:taskCompleted', { agentId: agent.id, task });
+        }
+        catch (error) {
+            if (abortController.signal.aborted) {
+                task.status = types_1.TaskStatus.CANCELLED;
+            }
+            else {
+                task.status = types_1.TaskStatus.FAILED;
+                task.error = error instanceof Error ? error.message : String(error);
+            }
+            task.completedAt = new Date();
+            agent.status = types_1.AgentStatus.ERROR;
+            await this.dbManager.updateAgent(agent);
+            throw error;
+        }
+        finally {
+            this.activeTasks.delete(task.id);
+        }
+    }
+    async pauseAgent(agentId) {
+        const agent = await this.getAgentOrThrow(agentId);
+        // Abort any running tasks
+        for (const [taskId, controller] of this.activeTasks) {
+            const task = agent.tasks.find(t => t.id === taskId);
+            if (task && task.status === types_1.TaskStatus.RUNNING) {
+                controller.abort();
+                task.status = types_1.TaskStatus.PAUSED;
+            }
+        }
+        agent.status = types_1.AgentStatus.PAUSED;
+        await this.dbManager.updateAgent(agent);
+        this.emit('agent:paused', { agentId });
+    }
+    async resumeAgent(agentId) {
+        const agent = await this.getAgentOrThrow(agentId);
+        agent.status = types_1.AgentStatus.IDLE;
+        await this.dbManager.updateAgent(agent);
+        this.emit('agent:resumed', { agentId });
+    }
+    async stopAgent(agentId) {
+        const agent = await this.getAgentOrThrow(agentId);
+        // Abort all tasks
+        for (const [taskId, controller] of this.activeTasks) {
+            const task = agent.tasks.find(t => t.id === taskId);
+            if (task) {
+                controller.abort();
+                task.status = types_1.TaskStatus.CANCELLED;
+                task.completedAt = new Date();
+            }
+        }
+        agent.status = types_1.AgentStatus.IDLE;
+        await this.dbManager.updateAgent(agent);
+        this.emit('agent:stopped', { agentId });
+    }
+    async deleteAgent(agentId) {
+        const agent = await this.getAgentOrThrow(agentId);
+        // Stop any running tasks
+        await this.stopAgent(agentId);
+        // Remove worktree
+        try {
+            await this.gitWorktreeManager.removeWorktree(agent.projectPath, agent.worktreeName);
+        }
+        catch (error) {
+            electron_log_1.default.warn(`Failed to remove worktree for agent ${agentId}:`, error);
+        }
+        this.agents.delete(agentId);
+        this.lastActivity.delete(agentId);
+        await this.dbManager.deleteAgent(agentId);
+        this.emit('agent:deleted', { agentId });
+        electron_log_1.default.info(`Deleted agent ${agentId}`);
+    }
+    async applySkills(agentId, skillIds) {
+        const agent = await this.getAgentOrThrow(agentId);
+        await this.applySkillsInternal(agent, skillIds);
+        agent.skills = [...new Set([...agent.skills, ...skillIds])];
+        await this.dbManager.updateAgent(agent);
+        this.emit('skill:applied', { agentId, skillIds });
+    }
+    async applySkillsInternal(agent, skillIds) {
+        for (const skillId of skillIds) {
+            const skill = await this.skillsManager.getSkill(skillId);
+            if (skill) {
+                // Add skill instructions to system context
+                const instructionFiles = skill.files.filter(f => f.type === 'instruction');
+                for (const file of instructionFiles) {
+                    agent.messages.push({
+                        id: (0, uuid_1.v4)(),
+                        role: 'system',
+                        content: `[SKILL: ${skill.name}]\n${file.content}`,
+                        timestamp: new Date(),
+                        metadata: { skillId, skillName: skill.name }
+                    });
+                }
+            }
+        }
+    }
+    async parseAndApplyChanges(agent, content) {
+        const changes = [];
+        const diffRegex = /diff --git a\/(.+?) b\/(.+?)\n([\s\S]*?)(?=\ndiff --git|$)/g;
+        let match;
+        const worktreePath = agent.worktreePath
+            ? agent.worktreePath
+            : (agent.worktreeName
+                ? path.join(agent.projectPath, '.codex', 'worktrees', agent.worktreeName)
+                : agent.projectPath);
+        while ((match = diffRegex.exec(content)) !== null) {
+            const [, oldFile, newFile, diffContent] = match;
+            const filePath = newFile.trim();
+            let originalContent = '';
+            let newContent = '';
+            try {
+                const fullFilePath = path.join(worktreePath, filePath);
+                originalContent = await fs.readFile(fullFilePath, 'utf-8');
+            }
+            catch {
+                electron_log_1.default.warn(`Could not read original file: ${filePath}, file may be new`);
+            }
+            newContent = this.applyDiff(originalContent, diffContent);
+            const change = {
+                id: (0, uuid_1.v4)(),
+                filePath,
+                originalContent,
+                newContent,
+                diff: diffContent,
+                agentId: agent.id,
+                taskId: agent.tasks[agent.tasks.length - 1]?.id || '',
+                status: types_1.ChangeStatus.PENDING,
+                createdAt: new Date()
+            };
+            changes.push(change);
+            await this.dbManager.createCodeChange(change);
+            this.emit('changes:created', { agentId: agent.id, changeId: change.id });
+        }
+        return changes;
+    }
+    applyDiff(originalContent, diffContent) {
+        const lines = diffContent.split('\n');
+        const result = [];
+        let i = 0;
+        while (i < lines.length) {
+            const line = lines[i];
+            if (line.startsWith('@@')) {
+                const hunkHeader = line;
+                const match = hunkHeader.match(/@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@/);
+                if (match) {
+                    const [, oldStart, oldCount, newStart, newCount] = match.map(Number);
+                    const originalLines = originalContent.split('\n');
+                    const beforeContext = originalLines.slice(Math.max(0, oldStart - 2), oldStart - 1);
+                    result.push(...beforeContext);
+                    i++;
+                    const hunkOldLines = [];
+                    const hunkNewLines = [];
+                    while (i < lines.length && !lines[i].startsWith('@@') && !lines[i].startsWith('diff ')) {
+                        if (lines[i].startsWith('-')) {
+                            hunkOldLines.push(lines[i].substring(1));
+                        }
+                        else if (lines[i].startsWith('+')) {
+                            hunkNewLines.push(lines[i].substring(1));
+                        }
+                        else if (!lines[i].startsWith('\\')) {
+                            hunkOldLines.push(lines[i]);
+                            hunkNewLines.push(lines[i]);
+                        }
+                        i++;
+                    }
+                    result.push(...hunkNewLines);
+                    const afterContext = originalLines.slice(oldStart - 1 + (oldCount || hunkOldLines.length), oldStart - 1 + (oldCount || hunkOldLines.length) + 2);
+                    result.push(...afterContext);
+                    continue;
+                }
+            }
+            i++;
+        }
+        if (result.length === 0 && diffContent.includes('new file')) {
+            const newFileMatch = diffContent.match(/\+\+\+ b\/(.+)/);
+            if (newFileMatch) {
+                const newLines = [];
+                for (const line of lines) {
+                    if (line.startsWith('+') && !line.startsWith('+++')) {
+                        newLines.push(line.substring(1));
+                    }
+                    else if (line.startsWith(' ')) {
+                        newLines.push(line.substring(1));
+                    }
+                }
+                return newLines.join('\n');
+            }
+        }
+        return result.join('\n');
+    }
+    // Permission Management
+    setAgentPermissionMode(agentId, mode) {
+        const agent = this.agents.get(agentId);
+        if (!agent) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        agent.permissionMode = mode;
+        this.permissionManager.setAgentMode(agentId, mode);
+        this.emit('agent:permissionModeChanged', { agentId, mode });
+        electron_log_1.default.info(`Permission mode changed to ${mode} for agent ${agentId}`);
+    }
+    getAgentPermissionMode(agentId) {
+        return this.permissionManager.getAgentMode(agentId);
+    }
+    getPermissionManager() {
+        return this.permissionManager;
+    }
+    setAllowBypassMode(allowed) {
+        this.permissionManager.setAllowBypassMode(allowed);
+    }
+    isBypassModeAllowed() {
+        return this.permissionManager.isBypassAllowed();
+    }
+    async checkPermission(agentId, action) {
+        return this.permissionManager.checkPermission(agentId, action);
+    }
+    async approvePermissionRequest(requestId) {
+        await this.permissionManager.approveRequest(requestId);
+    }
+    async rejectPermissionRequest(requestId) {
+        await this.permissionManager.rejectRequest(requestId);
+    }
+    getPendingPermissionRequests(agentId) {
+        return this.permissionManager.getPendingRequests(agentId);
+    }
+    buildSystemPrompt(userPrompt, claudeMdConfig) {
+        const parts = [];
+        if (claudeMdConfig) {
+            const parser = new ClaudeMdParser_1.ClaudeMdParser();
+            // Temporarily set config to generate prompt
+            parser.config = claudeMdConfig;
+            const claudePrompt = parser.generateSystemPrompt();
+            if (claudePrompt) {
+                parts.push(claudePrompt);
+            }
+        }
+        if (userPrompt) {
+            parts.push(userPrompt);
+        }
+        return parts.join('\n\n');
+    }
+}
+exports.AgentOrchestrator = AgentOrchestrator;
+//# sourceMappingURL=AgentOrchestrator.js.map