@leejungkiin/awkit 1.1.6 → 1.1.9

package/symphony/core/file-lock-manager.js

@@ -1,154 +0,0 @@
-/**
- * Symphony File Lock Manager
- * Pessimistic file locking to prevent 2 agents editing the same file.
- */
-const { getDb } = require('./db');
-
-/**
- * Acquire locks on files for an agent.
- * Atomic: all-or-nothing — if any file is locked by another agent, none are acquired.
- * 
- * @param {string} agentId - Agent requesting locks
- * @param {string} taskId - Task the agent is working on
- * @param {string[]} files - File paths to lock
- * @returns {{ success: boolean, conflicts?: Object[] }}
- */
-function acquireLocks(agentId, taskId, files) {
-    const db = getDb();
-
-    return db.transaction(() => {
-        // Check for conflicts
-        const conflicts = [];
-        const checkStmt = db.prepare('SELECT * FROM file_locks WHERE file_path = ?');
-
-        for (const file of files) {
-            const existing = checkStmt.get(file);
-            if (existing && existing.agent_id !== agentId) {
-                conflicts.push({
-                    file,
-                    agent: existing.agent_id,
-                    task: existing.task_id,
-                    since: existing.acquired_at,
-                });
-            }
-        }
-
-        if (conflicts.length > 0) {
-            return { success: false, conflicts };
-        }
-
-        // Acquire all locks (upsert)
-        const upsertStmt = db.prepare(`
-      INSERT INTO file_locks (file_path, agent_id, task_id) 
-      VALUES (?, ?, ?)
-      ON CONFLICT(file_path) DO UPDATE SET agent_id = ?, task_id = ?, acquired_at = datetime('now')
-    `);
-
-        for (const file of files) {
-            upsertStmt.run(file, agentId, taskId, agentId, taskId);
-        }
-
-        return { success: true };
-    })();
-}
-
-/**
- * Release all locks held by an agent.
- * @param {string} agentId - Agent ID
- * @returns {number} Number of locks released
- */
-function releaseLocks(agentId) {
-    const db = getDb();
-    const result = db.prepare('DELETE FROM file_locks WHERE agent_id = ?').run(agentId);
-    return result.changes;
-}
-
-/**
- * Release specific file locks for an agent.
- * @param {string} agentId - Agent ID
- * @param {string[]} files - File paths to release
- * @returns {number} Number of locks released
- */
-function releaseSpecificLocks(agentId, files) {
-    const db = getDb();
-    let released = 0;
-    const stmt = db.prepare('DELETE FROM file_locks WHERE file_path = ? AND agent_id = ?');
-    for (const file of files) {
-        const result = stmt.run(file, agentId);
-        released += result.changes;
-    }
-    return released;
-}
-
-/**
- * Check if files are available (not locked by another agent).
- * @param {string[]} files - File paths to check
- * @returns {{ available: string[], locked: Object[] }}
- */
-function checkFiles(files) {
-    const db = getDb();
-    const stmt = db.prepare('SELECT * FROM file_locks WHERE file_path = ?');
-
-    const available = [];
-    const locked = [];
-
-    for (const file of files) {
-        const lock = stmt.get(file);
-        if (lock) {
-            locked.push({
-                file,
-                agent: lock.agent_id,
-                task: lock.task_id,
-                since: lock.acquired_at,
-            });
-        } else {
-            available.push(file);
-        }
-    }
-
-    return { available, locked };
-}
-
-/**
- * Get all currently locked files.
- * @returns {Object[]}
- */
-function getAllLocks() {
-    const db = getDb();
-    return db.prepare('SELECT * FROM file_locks ORDER BY acquired_at DESC').all();
-}
-
-/**
- * Force-release a specific file lock (admin operation).
- * @param {string} filePath - File path to unlock
- * @returns {boolean} Whether a lock was released
- */
-function forceRelease(filePath) {
-    const db = getDb();
-    const result = db.prepare('DELETE FROM file_locks WHERE file_path = ?').run(filePath);
-    return result.changes > 0;
-}
-
-/**
- * Auto-release stale locks older than the given seconds.
- * @param {number} maxAge - Max age in seconds (default: 3600)
- * @returns {number} Number of locks released
- */
-function autoReleaseStale(maxAge = 3600) {
-    const db = getDb();
-    const result = db.prepare(`
-    DELETE FROM file_locks 
-    WHERE acquired_at < datetime('now', '-' || ? || ' seconds')
-  `).run(maxAge);
-    return result.changes;
-}
-
-module.exports = {
-    acquireLocks,
-    releaseLocks,
-    releaseSpecificLocks,
-    checkFiles,
-    getAllLocks,
-    forceRelease,
-    autoReleaseStale,
-};

package/symphony/core/merge-pipeline.js

@@ -1,234 +0,0 @@
-/**
- * Symphony Merge Pipeline
- * Auto-rebase, merge, and conflict detection for completed tasks.
- */
-const { execSync } = require('child_process');
-const { getDb } = require('./db');
-const workspaceManager = require('./workspace-manager');
-
-/**
- * Get the main branch name (main or master).
- * @param {string} repoPath
- * @returns {string}
- */
-function getMainBranch(repoPath) {
-    try {
-        const branches = execSync('git branch -l main master', {
-            cwd: repoPath,
-            encoding: 'utf8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
-        if (branches.includes('main')) return 'main';
-        if (branches.includes('master')) return 'master';
-    } catch (_) { /* ignore */ }
-    return 'main'; // default
-}
-
-/**
- * Get diff stats between task branch and main.
- * @param {string} taskId
- * @param {string} repoPath
- * @returns {{ files: number, insertions: number, deletions: number, summary: string }}
- */
-function getDiff(taskId, repoPath) {
-    const ws = workspaceManager.getWorkspace(taskId);
-    if (!ws) return { files: 0, insertions: 0, deletions: 0, summary: 'No workspace found' };
-
-    const mainBranch = getMainBranch(repoPath);
-
-    try {
-        const stat = execSync(`git diff ${mainBranch}...${ws.branch} --stat`, {
-            cwd: repoPath,
-            encoding: 'utf8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
-
-        const shortstat = execSync(`git diff ${mainBranch}...${ws.branch} --shortstat`, {
-            cwd: repoPath,
-            encoding: 'utf8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        }).trim();
-
-        // Parse shortstat: "3 files changed, 10 insertions(+), 2 deletions(-)"
-        const filesMatch = shortstat.match(/(\d+) files? changed/);
-        const insertMatch = shortstat.match(/(\d+) insertions?\(\+\)/);
-        const deleteMatch = shortstat.match(/(\d+) deletions?\(-\)/);
-
-        return {
-            files: filesMatch ? parseInt(filesMatch[1]) : 0,
-            insertions: insertMatch ? parseInt(insertMatch[1]) : 0,
-            deletions: deleteMatch ? parseInt(deleteMatch[1]) : 0,
-            summary: stat,
-        };
-    } catch (e) {
-        return { files: 0, insertions: 0, deletions: 0, summary: `Error: ${e.message}` };
-    }
-}
-
-/**
- * Check for merge conflicts without actually merging.
- * @param {string} taskId
- * @param {string} repoPath
- * @returns {{ hasConflicts: boolean, conflictingFiles: string[] }}
- */
-function checkConflicts(taskId, repoPath) {
-    const ws = workspaceManager.getWorkspace(taskId);
-    if (!ws) return { hasConflicts: false, conflictingFiles: [] };
-
-    const mainBranch = getMainBranch(repoPath);
-
-    try {
-        // Try a dry-run merge
-        execSync(`git merge-tree $(git merge-base ${mainBranch} ${ws.branch}) ${mainBranch} ${ws.branch}`, {
-            cwd: repoPath,
-            encoding: 'utf8',
-            stdio: ['pipe', 'pipe', 'pipe'],
-        });
-        return { hasConflicts: false, conflictingFiles: [] };
-    } catch (e) {
-        // Parse conflict markers
-        const output = e.stdout || '';
-        const conflicting = [];
-        const regex = /changed in both[\s\S]*?'([^']+)'/g;
-        let match;
-        while ((match = regex.exec(output))) {
-            conflicting.push(match[1]);
-        }
-        return { hasConflicts: conflicting.length > 0, conflictingFiles: conflicting };
-    }
-}
-
-/**
- * Auto-merge a completed task branch into main.
- * Steps: fetch → rebase → fast-forward merge → cleanup
- * 
- * @param {string} taskId
- * @param {string} repoPath
- * @returns {{ status: 'merged'|'conflict'|'error', message: string, conflictingFiles?: string[] }}
- */
-function autoMerge(taskId, repoPath) {
-    const ws = workspaceManager.getWorkspace(taskId);
-    if (!ws) {
-        return { status: 'error', message: 'No active workspace found for this task' };
-    }
-
-    const mainBranch = getMainBranch(repoPath);
-
-    try {
-        // Step 1: Fetch latest from remote (if available)
-        try {
-            execSync(`git fetch origin ${mainBranch}`, {
-                cwd: repoPath,
-                stdio: 'pipe',
-            });
-        } catch (_) {
-            // No remote or fetch failed — continue with local
-        }
-
-        // Step 2: Rebase task branch onto main
-        try {
-            execSync(`git rebase ${mainBranch}`, {
-                cwd: ws.path,
-                stdio: 'pipe',
-            });
-        } catch (rebaseError) {
-            // Rebase failed — abort and report conflicts
-            try {
-                execSync('git rebase --abort', { cwd: ws.path, stdio: 'pipe' });
-            } catch (_) { /* ignore */ }
-
-            const conflicts = checkConflicts(taskId, repoPath);
-            return {
-                status: 'conflict',
-                message: `Rebase failed: conflicts detected in ${conflicts.conflictingFiles.length} file(s)`,
-                conflictingFiles: conflicts.conflictingFiles,
-            };
-        }
-
-        // Step 3: Merge into main (fast-forward)
-        try {
-            execSync(`git checkout ${mainBranch}`, {
-                cwd: repoPath,
-                stdio: 'pipe',
-            });
-            execSync(`git merge --ff-only ${ws.branch}`, {
-                cwd: repoPath,
-                stdio: 'pipe',
-            });
-        } catch (mergeError) {
-            // FF merge failed — try regular merge
-            try {
-                execSync(`git merge ${ws.branch} --no-edit`, {
-                    cwd: repoPath,
-                    stdio: 'pipe',
-                });
-            } catch (e) {
-                execSync('git merge --abort', { cwd: repoPath, stdio: 'pipe' });
-                return {
-                    status: 'conflict',
-                    message: `Merge failed: could not fast-forward or auto-merge`,
-                    conflictingFiles: [],
-                };
-            }
-        }
-
-        // Step 4: Cleanup
-        workspaceManager.markMerged(taskId);
-        workspaceManager.removeWorkspace(taskId, repoPath);
-
-        // Step 5: Delete the branch
-        try {
-            execSync(`git branch -d ${ws.branch}`, {
-                cwd: repoPath,
-                stdio: 'pipe',
-            });
-        } catch (_) { /* branch cleanup is best-effort */ }
-
-        return {
-            status: 'merged',
-            message: `Successfully merged ${ws.branch} into ${mainBranch}`,
-        };
-    } catch (error) {
-        return {
-            status: 'error',
-            message: `Merge pipeline error: ${error.message}`,
-        };
-    }
-}
-
-/**
- * Get branch log (commits on task branch not on main).
- * @param {string} taskId
- * @param {string} repoPath
- * @returns {Object[]}
- */
-function getBranchLog(taskId, repoPath) {
-    const ws = workspaceManager.getWorkspace(taskId);
-    if (!ws) return [];
-
-    const mainBranch = getMainBranch(repoPath);
-
-    try {
-        const log = execSync(
-            `git log ${mainBranch}..${ws.branch} --oneline --format="%H|%s|%an|%ai"`,
-            { cwd: repoPath, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
-        ).trim();
-
-        if (!log) return [];
-
-        return log.split('\n').map(line => {
-            const [hash, subject, author, date] = line.split('|');
-            return { hash, subject, author, date };
-        });
-    } catch (_) {
-        return [];
-    }
-}
-
-module.exports = {
-    autoMerge,
-    getDiff,
-    checkConflicts,
-    getBranchLog,
-    getMainBranch,
-};

package/symphony/core/orchestrator.js

@@ -1,236 +0,0 @@
-/**
- * Symphony Orchestrator
- * Central state machine managing agent dispatch, concurrency, and lifecycle.
- */
-const { getDb } = require('./db');
-const taskManager = require('./task-manager');
-const fileLockManager = require('./file-lock-manager');
-const config = require('../symphony.config');
-
-/**
- * Register a new agent (IDE session connects).
- * @param {string} agentId - Agent identifier
- * @param {string} [name] - Human-readable name
- * @returns {Object} Agent record
- */
-function registerAgent(agentId, name) {
-    const db = getDb();
-    db.prepare(`
-    INSERT INTO agents (id, name, status) VALUES (?, ?, 'idle')
-    ON CONFLICT(id) DO UPDATE SET status = 'idle', last_heartbeat = datetime('now')
-  `).run(agentId, name || agentId);
-    return db.prepare('SELECT * FROM agents WHERE id = ?').get(agentId);
-}
-
-/**
- * Unregister an agent (IDE session disconnects).
- * Releases all file locks held by this agent.
- * @param {string} agentId
- */
-function unregisterAgent(agentId) {
-    const db = getDb();
-    fileLockManager.releaseLocks(agentId);
-
-    // Reset any claimed tasks back to ready
-    db.prepare(`
-    UPDATE tasks SET status = 'ready', agent_id = NULL 
-    WHERE agent_id = ? AND status IN ('claimed', 'in_progress')
-  `).run(agentId);
-
-    db.prepare("UPDATE agents SET status = 'disconnected' WHERE id = ?").run(agentId);
-}
-
-/**
- * Update agent heartbeat.
- * @param {string} agentId
- */
-function heartbeat(agentId) {
-    const db = getDb();
-    db.prepare("UPDATE agents SET last_heartbeat = datetime('now') WHERE id = ?").run(agentId);
-}
-
-/**
- * Get all connected agents.
- * @returns {Object[]}
- */
-function getAgents() {
-    const db = getDb();
-    return db.prepare("SELECT * FROM agents WHERE status != 'disconnected' ORDER BY connected_at").all();
-}
-
-/**
- * Get a single agent.
- * @param {string} agentId
- * @returns {Object|null}
- */
-function getAgent(agentId) {
-    const db = getDb();
-    return db.prepare('SELECT * FROM agents WHERE id = ?').get(agentId) || null;
-}
-
-/**
- * Check if there are available slots for new agents.
- * @returns {boolean}
- */
-function hasAvailableSlots() {
-    const agents = getAgents();
-    const workingAgents = agents.filter(a => a.status === 'working');
-    return workingAgents.length < config.maxAgents;
-}
-
-/**
- * Get number of available slots.
- * @returns {number}
- */
-function availableSlots() {
-    const agents = getAgents();
-    const workingAgents = agents.filter(a => a.status === 'working');
-    return Math.max(0, config.maxAgents - workingAgents.length);
-}
-
-/**
- * Dispatch a task to an agent.
- * Sets agent to 'working' status and claims the task.
- * @param {string} agentId
- * @param {string} taskId
- * @returns {Object} The claimed task
- */
-function dispatchTask(agentId, taskId) {
-    const db = getDb();
-
-    if (!hasAvailableSlots()) {
-        const agent = getAgent(agentId);
-        // Allow re-dispatch to same agent
-        if (!agent || agent.status !== 'working') {
-            throw new Error('No available agent slots');
-        }
-    }
-
-    const task = taskManager.claimTask(taskId, agentId);
-
-    db.prepare(`
-    UPDATE agents SET status = 'working', current_task_id = ? WHERE id = ?
-  `).run(taskId, agentId);
-
-    return task;
-}
-
-/**
- * Mark an agent as idle (after task completion).
- * @param {string} agentId
- */
-function markIdle(agentId) {
-    const db = getDb();
-    db.prepare(`
-    UPDATE agents SET status = 'idle', current_task_id = NULL WHERE id = ?
-  `).run(agentId);
-}
-
-/**
- * Get full system status.
- * @returns {Object}
- */
-function getStatus() {
-    const agents = getAgents();
-    const locks = fileLockManager.getAllLocks();
-    const stats = taskManager.getStats();
-    const readyTasks = taskManager.listTasks({ status: 'ready', limit: 10 });
-
-    return {
-        agents: agents.map(a => ({
-            id: a.id,
-            name: a.name,
-            status: a.status,
-            currentTask: a.current_task_id,
-            lastHeartbeat: a.last_heartbeat,
-        })),
-        lockedFiles: locks.map(l => ({
-            file: l.file_path,
-            agent: l.agent_id,
-            task: l.task_id,
-            since: l.acquired_at,
-        })),
-        queue: readyTasks,
-        stats,
-        config: {
-            maxAgents: config.maxAgents,
-            availableSlots: availableSlots(),
-        },
-    };
-}
-
-/**
- * Update agent profile (name, specialties, color, maxConcurrent).
- * @param {string} agentId - Agent ID
- * @param {Object} fields - { name, specialties, color, max_concurrent }
- * @returns {Object} Updated agent
- */
-function updateAgentProfile(agentId, fields) {
-    const db = getDb();
-    const sets = [];
-    const params = [];
-
-    if (fields.name !== undefined) { sets.push('name = ?'); params.push(fields.name); }
-    if (fields.specialties !== undefined) { sets.push('specialties = ?'); params.push(JSON.stringify(fields.specialties)); }
-    if (fields.color !== undefined) { sets.push('color = ?'); params.push(fields.color); }
-    if (fields.max_concurrent !== undefined) { sets.push('max_concurrent = ?'); params.push(fields.max_concurrent); }
-
-    if (sets.length === 0) return getAgent(agentId);
-
-    params.push(agentId);
-    db.prepare(`UPDATE agents SET ${sets.join(', ')} WHERE id = ?`).run(...params);
-    return getAgent(agentId);
-}
-
-/**
- * Remove an agent (must be idle or disconnected).
- * @param {string} agentId - Agent ID
- * @returns {boolean} Success
- */
-function removeAgent(agentId) {
-    const db = getDb();
-    const agent = getAgent(agentId);
-    if (!agent) throw new Error(`Agent not found: ${agentId}`);
-    if (agent.status === 'working') {
-        throw new Error(`Cannot remove working agent: ${agentId}`);
-    }
-    fileLockManager.releaseLocks(agentId);
-    db.prepare('DELETE FROM agents WHERE id = ?').run(agentId);
-    return true;
-}
-
-/**
- * List all agents (including disconnected).
- * @returns {Object[]}
- */
-function listAllAgents() {
-    const db = getDb();
-    return db.prepare('SELECT * FROM agents ORDER BY status ASC, connected_at DESC').all()
-        .map(a => ({
-            id: a.id,
-            name: a.name,
-            status: a.status,
-            currentTask: a.current_task_id,
-            specialties: a.specialties ? JSON.parse(a.specialties) : [],
-            color: a.color || '#8888a0',
-            maxConcurrent: a.max_concurrent || 1,
-            lastHeartbeat: a.last_heartbeat,
-        }));
-}
-
-module.exports = {
-    registerAgent,
-    unregisterAgent,
-    heartbeat,
-    getAgents,
-    getAgent,
-    hasAvailableSlots,
-    availableSlots,
-    dispatchTask,
-    markIdle,
-    getStatus,
-    updateAgentProfile,
-    removeAgent,
-    listAllAgents,
-};
-