@leejungkiin/awkit 1.1.6 → 1.1.9

package/symphony/mcp/index.js

@@ -1,29 +0,0 @@
-/**
- * Symphony MCP — Tool Registry
- * Registers all 14 MCP tools on the server instance.
- */
-
-const { registerTaskTools } = require('./tools/tasks');
-const { registerLockTools } = require('./tools/locks');
-const { registerContextTools } = require('./tools/context');
-const { registerStatusTools } = require('./tools/status');
-const workspaceTools = require('./tools/workspace');
-
-/**
- * Register all Symphony MCP tools on the given server.
- * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
- * @param {() => string} getAgentId - Returns the current agent ID for this session
- */
-function registerAllTools(server, getAgentId) {
-    registerTaskTools(server, getAgentId);
-    registerLockTools(server, getAgentId);
-    registerContextTools(server, getAgentId);
-    registerStatusTools(server);
-
-    // Register workspace tools (array-based export)
-    for (const tool of workspaceTools) {
-        server.tool(tool.name, tool.description, tool.schema, tool.handler);
-    }
-}
-
-module.exports = { registerAllTools };

package/symphony/mcp/server.js

@@ -1,110 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Symphony MCP Server
- * Starts an MCP server via stdio transport for IDE ↔ Symphony communication.
- *
- * Usage:
- *   node mcp/server.js
- *   # Or via CLI:
- *   symphony mcp-serve
- *
- * Environment:
- *   SYMPHONY_AGENT_NAME  — Agent display name (default: auto-generated)
- *   SYMPHONY_PROJECT     — Project root path (default: cwd)
- */
-
-const { McpServer } = require('@modelcontextprotocol/sdk/server/mcp.js');
-const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
-const path = require('path');
-const { nanoid } = require('nanoid');
-
-// Initialize database (ensure core modules can access it)
-const SYMPHONY_ROOT = path.join(__dirname, '..');
-process.chdir(process.env.SYMPHONY_PROJECT || SYMPHONY_ROOT);
-
-// Import core DB to ensure it's initialized
-const db = require(path.join(SYMPHONY_ROOT, 'core', 'db'));
-const orchestrator = require(path.join(SYMPHONY_ROOT, 'core', 'orchestrator'));
-
-// Read package version
-let version = '0.1.0';
-try {
-    const pkg = require(path.join(SYMPHONY_ROOT, 'package.json'));
-    version = pkg.version || version;
-} catch (_) {
-    // Ignore
-}
-
-// Agent identification
-const agentName = process.env.SYMPHONY_AGENT_NAME || `agent-${nanoid(6)}`;
-let agentId = agentName;
-
-/**
- * Get the current agent ID for this MCP session.
- * @returns {string}
- */
-function getAgentId() {
-    return agentId;
-}
-
-/**
- * Main entry point — starts the MCP server.
- */
-async function main() {
-    // Create MCP server instance
-    const server = new McpServer(
-        {
-            name: 'awkit-symphony',
-            version,
-        },
-        {
-            capabilities: {
-                tools: {},
-            },
-        }
-    );
-
-    // Register all 12 tools
-    const { registerAllTools } = require('./index');
-    registerAllTools(server, getAgentId);
-
-    // Register agent on startup
-    orchestrator.registerAgent(agentId, agentName);
-
-    // Log to stderr (stdout is reserved for MCP JSON-RPC)
-    process.stderr.write(`🎼 Symphony MCP Server v${version}\n`);
-    process.stderr.write(`   Agent: ${agentName} (${agentId})\n`);
-    process.stderr.write(`   Transport: stdio\n`);
-    process.stderr.write(`   Tools: 12 registered\n\n`);
-
-    // Create stdio transport and connect
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-
-    // Graceful shutdown
-    const shutdown = () => {
-        process.stderr.write('\n🛑 Symphony MCP Server shutting down...\n');
-        try {
-            orchestrator.unregisterAgent(agentId);
-        } catch (_) {
-            // Ignore errors during shutdown
-        }
-        try {
-            db.close();
-        } catch (_) {
-            // Ignore
-        }
-        process.exit(0);
-    };
-
-    process.on('SIGINT', shutdown);
-    process.on('SIGTERM', shutdown);
-}
-
-// Run if executed directly
-main().catch((err) => {
-    process.stderr.write(`❌ Fatal error: ${err.message}\n`);
-    process.stderr.write(`${err.stack}\n`);
-    process.exit(1);
-});

package/symphony/mcp/tools/context.js

@@ -1,80 +0,0 @@
-/**
- * Symphony MCP Tools — Context Bus
- * 2 tools for inter-agent communication via event pub/sub.
- */
-const { z } = require('zod');
-const path = require('path');
-
-const CORE = path.join(__dirname, '..', '..', 'core');
-
-/**
- * Register context bus tools on the MCP server.
- * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
- * @param {() => string} getAgentId - Returns current agent ID
- */
-function registerContextTools(server, getAgentId) {
-    // Tool 9: Broadcast event
-    server.tool(
-        'symphony_broadcast',
-        'Broadcast an event to other agents. Use to notify about schema changes, file modifications, or API updates.',
-        {
-            event_type: z
-                .enum(['file_modified', 'api_changed', 'schema_updated', 'dependency_added', 'custom'])
-                .describe('Type of event'),
-            payload: z
-                .object({
-                    files: z.array(z.string()).optional().describe('Affected files'),
-                    description: z.string().describe('Human-readable description'),
-                    impact: z.enum(['low', 'medium', 'high']).default('medium').describe('Impact level'),
-                })
-                .describe('Event payload'),
-        },
-        async ({ event_type, payload }) => {
-            const cb = require(path.join(CORE, 'context-bus'));
-            const agentId = getAgentId();
-
-            cb.publish(agentId, event_type, payload);
-
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: `Event broadcasted: ${event_type} — ${payload.description}`,
-                    },
-                ],
-            };
-        }
-    );
-
-    // Tool 10: Query events
-    server.tool(
-        'symphony_events',
-        'Query recent events from other agents. Use to stay informed about changes made by teammates.',
-        {
-            since: z.string().optional().describe('ISO timestamp — only events after this time'),
-            event_type: z.string().optional().describe('Filter by event type'),
-            limit: z.number().int().min(1).max(100).default(20).describe('Max events to return'),
-        },
-        async ({ since, event_type, limit }) => {
-            const cb = require(path.join(CORE, 'context-bus'));
-
-            const filter = {};
-            if (since) filter.since = since;
-            if (event_type) filter.eventType = event_type;
-            filter.limit = limit;
-
-            const events = cb.query(filter);
-
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(events, null, 2),
-                    },
-                ],
-            };
-        }
-    );
-}
-
-module.exports = { registerContextTools };

package/symphony/mcp/tools/locks.js

@@ -1,99 +0,0 @@
-/**
- * Symphony MCP Tools — File Lock Management
- * 3 tools for checking, acquiring, and releasing file locks.
- */
-const { z } = require('zod');
-const path = require('path');
-
-const CORE = path.join(__dirname, '..', '..', 'core');
-
-/**
- * Register file lock tools on the MCP server.
- * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
- * @param {() => string} getAgentId - Returns current agent ID
- */
-function registerLockTools(server, getAgentId) {
-    // Tool 6: Check file availability
-    server.tool(
-        'symphony_check_files',
-        'Check if files are available (not locked by another agent). Use before editing to avoid conflicts.',
-        {
-            files: z.array(z.string()).min(1).describe('File paths to check'),
-        },
-        async ({ files }) => {
-            const flm = require(path.join(CORE, 'file-lock-manager'));
-            const result = flm.checkFiles(files);
-
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-            };
-        }
-    );
-
-    // Tool 7: Acquire file locks
-    server.tool(
-        'symphony_lock_files',
-        'Acquire locks on specific files to prevent other agents from editing them.',
-        {
-            task_id: z.string().describe('Task ID the locks are for'),
-            files: z.array(z.string()).min(1).describe('File paths to lock'),
-        },
-        async ({ task_id, files }) => {
-            const flm = require(path.join(CORE, 'file-lock-manager'));
-            const agentId = getAgentId();
-
-            try {
-                const result = flm.acquireLocks(agentId, task_id, files);
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify({ success: true, ...result }, null, 2),
-                        },
-                    ],
-                };
-            } catch (err) {
-                return {
-                    content: [
-                        {
-                            type: 'text',
-                            text: JSON.stringify(
-                                { success: false, error: err.message },
-                                null,
-                                2
-                            ),
-                        },
-                    ],
-                    isError: true,
-                };
-            }
-        }
-    );
-
-    // Tool 8: Release file locks
-    server.tool(
-        'symphony_unlock_files',
-        'Release locks on specific files. Other agents can then edit these files.',
-        {
-            task_id: z.string().describe('Task ID the locks belong to'),
-            files: z.array(z.string()).min(1).describe('File paths to unlock'),
-        },
-        async ({ task_id, files }) => {
-            const flm = require(path.join(CORE, 'file-lock-manager'));
-            const agentId = getAgentId();
-
-            flm.releaseSpecificLocks(agentId, files);
-
-            return {
-                content: [{ type: 'text', text: `Released locks: ${files.join(', ')}` }],
-            };
-        }
-    );
-}
-
-module.exports = { registerLockTools };

package/symphony/mcp/tools/status.js

@@ -1,82 +0,0 @@
-/**
- * Symphony MCP Tools — Status & Task Creation
- * 2 tools for system status overview and creating new tasks.
- */
-const { z } = require('zod');
-const path = require('path');
-
-const CORE = path.join(__dirname, '..', '..', 'core');
-
-/**
- * Register status tools on the MCP server.
- * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
- */
-function registerStatusTools(server) {
-    // Tool 11: System status
-    server.tool(
-        'symphony_status',
-        'Get full Symphony system status: connected agents, file locks, task queue, and statistics.',
-        {},
-        async () => {
-            const orchestrator = require(path.join(CORE, 'orchestrator'));
-            const status = orchestrator.getStatus();
-
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(status, null, 2),
-                    },
-                ],
-            };
-        }
-    );
-
-    // Tool 12: Create a new task
-    server.tool(
-        'symphony_create_task',
-        'Create a new task in the Symphony queue. The task will be available for any agent to claim.',
-        {
-            title: z.string().describe('Task title'),
-            description: z.string().optional().describe('Detailed description'),
-            priority: z.number().int().min(1).max(3).default(2).describe('Priority: 1=high, 2=medium, 3=low'),
-            acceptance: z.string().optional().describe('Acceptance criteria'),
-            phase: z.string().optional().describe('Phase/milestone'),
-            estimated_files: z
-                .array(z.string())
-                .optional()
-                .describe('Files this task will likely edit (for pre-locking)'),
-        },
-        async ({ title, description, priority, acceptance, phase, estimated_files }) => {
-            const tm = require(path.join(CORE, 'task-manager'));
-
-            const task = tm.createTask(title, {
-                description,
-                priority,
-                acceptance,
-                phase,
-                estimatedFiles: estimated_files,
-            });
-
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(
-                            {
-                                id: task.id,
-                                title: task.title,
-                                status: task.status,
-                                priority: task.priority,
-                            },
-                            null,
-                            2
-                        ),
-                    },
-                ],
-            };
-        }
-    );
-}
-
-module.exports = { registerStatusTools };

package/symphony/mcp/tools/tasks.js

@@ -1,216 +0,0 @@
-/**
- * Symphony MCP Tools — Task Management
- * 5 tools for task lifecycle: list, claim, progress, complete, abandon
- */
-const { z } = require('zod');
-const path = require('path');
-
-const CORE = path.join(__dirname, '..', '..', 'core');
-
-/**
- * Register all task management tools on the MCP server.
- * @param {import('@modelcontextprotocol/sdk/server/mcp.js').McpServer} server
- * @param {() => string} getAgentId - Returns current agent ID
- */
-function registerTaskTools(server, getAgentId) {
-    // Tool 1: List available tasks
-    server.tool(
-        'symphony_available_tasks',
-        'List tasks available for claiming. Use filter "ready" for unclaimed tasks, "my" for your tasks, or "all" for everything.',
-        {
-            filter: z.enum(['ready', 'all', 'my']).default('ready').describe('Task filter'),
-            limit: z.number().int().min(1).max(100).default(10).describe('Max results'),
-        },
-        async ({ filter, limit }) => {
-            const tm = require(path.join(CORE, 'task-manager'));
-            const agentId = getAgentId();
-
-            let tasks;
-            switch (filter) {
-                case 'ready':
-                    tasks = tm.listTasks({ status: 'ready', limit });
-                    break;
-                case 'my':
-                    tasks = tm.listTasks({ agentId, limit });
-                    break;
-                case 'all':
-                    tasks = tm.listTasks({ limit });
-                    break;
-                default:
-                    tasks = tm.listTasks({ status: 'ready', limit });
-            }
-
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(
-                            tasks.map((t) => ({
-                                id: t.id,
-                                title: t.title,
-                                description: t.description,
-                                status: t.status,
-                                priority: t.priority,
-                                acceptance: t.acceptance,
-                                phase: t.phase,
-                                estimated_files: t.estimated_files,
-                            })),
-                            null,
-                            2
-                        ),
-                    },
-                ],
-            };
-        }
-    );
-
-    // Tool 2: Claim a task
-    server.tool(
-        'symphony_claim_task',
-        'Claim a task to start working on it. This acquires file locks and prepares a workspace.',
-        {
-            task_id: z.string().describe('Task ID to claim'),
-            agent_name: z.string().optional().describe('Optional agent display name'),
-        },
-        async ({ task_id, agent_name }) => {
-            const orchestrator = require(path.join(CORE, 'orchestrator'));
-            const tm = require(path.join(CORE, 'task-manager'));
-            const flm = require(path.join(CORE, 'file-lock-manager'));
-            const agentId = getAgentId();
-
-            // Ensure agent is registered
-            orchestrator.registerAgent(agentId, agent_name || agentId);
-
-            // Dispatch task to agent
-            const task = orchestrator.dispatchTask(agentId, task_id);
-
-            // Acquire file locks if estimated files are provided
-            let lockedFiles = [];
-            if (task.estimated_files && task.estimated_files.length > 0) {
-                const lockResult = flm.acquireLocks(agentId, task_id, task.estimated_files);
-                lockedFiles = lockResult.acquired || task.estimated_files;
-            }
-
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(
-                            {
-                                task_id: task.id,
-                                title: task.title,
-                                workspace_path: task.workspace_path || null,
-                                branch: task.branch || null,
-                                locked_files: lockedFiles,
-                                acceptance_criteria: task.acceptance || null,
-                                description: task.description || null,
-                            },
-                            null,
-                            2
-                        ),
-                    },
-                ],
-            };
-        }
-    );
-
-    // Tool 3: Report progress
-    server.tool(
-        'symphony_report_progress',
-        'Report progress on a claimed task. Updates percentage and optionally current file being edited.',
-        {
-            task_id: z.string().describe('Task ID'),
-            progress: z.number().int().min(0).max(100).describe('Progress percentage 0-100'),
-            current_file: z.string().optional().describe('Current file being edited'),
-            last_action: z.string().optional().describe('Last action performed'),
-        },
-        async ({ task_id, progress, current_file, last_action }) => {
-            const tm = require(path.join(CORE, 'task-manager'));
-            tm.updateProgress(task_id, progress, { currentFile: current_file, lastAction: last_action });
-
-            return {
-                content: [{ type: 'text', text: `Progress updated: ${progress}%` }],
-            };
-        }
-    );
-
-    // Tool 4: Complete a task
-    server.tool(
-        'symphony_complete_task',
-        'Mark a task as complete. Releases file locks and marks agent as idle.',
-        {
-            task_id: z.string().describe('Task ID'),
-            summary: z.string().describe('Summary of what was done'),
-            files_changed: z.array(z.string()).default([]).describe('List of changed files'),
-        },
-        async ({ task_id, summary, files_changed }) => {
-            const tm = require(path.join(CORE, 'task-manager'));
-            const orchestrator = require(path.join(CORE, 'orchestrator'));
-            const flm = require(path.join(CORE, 'file-lock-manager'));
-            const agentId = getAgentId();
-
-            // Complete the task
-            const task = tm.completeTask(task_id, summary, files_changed);
-
-            // Release all file locks for this agent
-            flm.releaseLocks(agentId);
-
-            // Mark agent as idle
-            orchestrator.markIdle(agentId);
-
-            // Check for next available task
-            const nextTasks = tm.listTasks({ status: 'ready', limit: 1 });
-            const nextTask = nextTasks.length > 0 ? nextTasks[0] : null;
-
-            return {
-                content: [
-                    {
-                        type: 'text',
-                        text: JSON.stringify(
-                            {
-                                status: 'completed',
-                                merge_status: 'pr_created', // TODO: implement actual merge logic
-                                next_task: nextTask
-                                    ? { id: nextTask.id, title: nextTask.title, priority: nextTask.priority }
-                                    : null,
-                            },
-                            null,
-                            2
-                        ),
-                    },
-                ],
-            };
-        }
-    );
-
-    // Tool 5: Abandon a task
-    server.tool(
-        'symphony_abandon_task',
-        'Abandon a task you are working on. Releases all file locks and returns the task to the queue.',
-        {
-            task_id: z.string().describe('Task ID'),
-            reason: z.string().describe('Reason for abandoning'),
-        },
-        async ({ task_id, reason }) => {
-            const tm = require(path.join(CORE, 'task-manager'));
-            const orchestrator = require(path.join(CORE, 'orchestrator'));
-            const flm = require(path.join(CORE, 'file-lock-manager'));
-            const agentId = getAgentId();
-
-            // Abandon the task
-            tm.abandonTask(task_id, reason);
-
-            // Release file locks
-            flm.releaseLocks(agentId);
-
-            // Mark agent idle
-            orchestrator.markIdle(agentId);
-
-            return {
-                content: [{ type: 'text', text: `Task ${task_id} abandoned: ${reason}` }],
-            };
-        }
-    );
-}
-
-module.exports = { registerTaskTools };