atabey-mcp 0.0.4

package/dist/constants.js

@@ -0,0 +1,64 @@
+import path from "path";
+/**
+ * Agent Atabey — Single Source of Truth for framework constants.
+ * Import from here instead of hardcoding paths, phases, or directory names.
+ */
+// ─── Framework identity ───────────────────────────────────────────────────
+export const FRAMEWORK = {
+    NAME: "Agent Atabey",
+    CORE_DIR: ".atabey",
+    // This is the hub for unified adapter layouts (e.g. .agents/gemini, .agents/claude)
+    UNIFIED_HUB_DIR: ".agents",
+    // This is the default directory to scaffold new apps into
+    APPS_DIR: "apps",
+    // This is where all skills are stored
+    SKILLS_DIR: "skills",
+};
+export const FRAMEWORK_SUBDIRS = {
+    AGENTS: "agents",
+    SKILLS: "skills",
+    KNOWLEDGE: "knowledge",
+    MESSAGES: "messages",
+    MEMORY: "memory",
+    MEMORY_GRAPH: "memory-graph",
+    LOGS: "logs",
+    CONFIG: "config",
+};
+export const ROOT_CONFIG_FILES = {
+    MCP: "mcp.json",
+    NATIVE_MODULES: "native-modules.json",
+    TSCONFIG: "tsconfig.json",
+    ESLINT: "eslint.config.js",
+};
+export const MCP = {
+    // Environment variable used by MCP to identify project root
+    PROJECT_ROOT_ENV: "ATABEY_PROJECT_ROOT",
+    // Environment variable for test mode
+    TEST_DIR_ENV: "ATABEY_TEST_DIR",
+};
+export const MEMORY_FILES = {
+    STATE: "state.json",
+    SHARED_FACTS: "shared_facts.json",
+};
+export const NATIVE_AGENT_PATHS = {
+    gemini: ".gemini/agents",
+    claude: ".claude/agents",
+    cursor: ".cursor/rules",
+    codex: ".agents/instructions",
+    grok: ".grok",
+    "antigravity-cli": ".antigravity/agents",
+};
+// ─── Backward-compatible aliases ──────────────────────────────────────────
+export const CORE_FRAMEWORK_DIR = FRAMEWORK.CORE_DIR;
+export const UNIFIED_HUB_DIR = FRAMEWORK.UNIFIED_HUB_DIR;
+export const SKILLS_HUB_PATH = pathJoin(UNIFIED_HUB_DIR, FRAMEWORK_SUBDIRS.SKILLS);
+// ─── Path Helpers ─────────────────────────────────────────────────────────
+function pathJoin(...args) {
+    return path.join(...args);
+}
+function corePath(subdir, filename) {
+    return pathJoin(FRAMEWORK.CORE_DIR, subdir, filename);
+}
+export function knowledgePath(filename) {
+    return corePath(FRAMEWORK_SUBDIRS.KNOWLEDGE, filename);
+}

package/dist/index.js

@@ -0,0 +1,119 @@
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { TOOLS, toolHandlers } from "./tools/index.js";
+// ─── Server Setup ─────────────────────────────────────────────────
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// Robustly find package.json by walking up from __dirname
+function findPackageJson(startDir) {
+    let currentDir = startDir;
+    while (currentDir !== path.parse(currentDir).root) {
+        const pkgPath = path.join(currentDir, "package.json");
+        if (fs.existsSync(pkgPath))
+            return pkgPath;
+        currentDir = path.dirname(currentDir);
+    }
+    throw new Error("Could not find package.json for atabey-mcp");
+}
+const pkgPath = findPackageJson(__dirname);
+const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+const serverVersion = pkg.version;
+const server = new Server({
+    name: "atabey-mcp",
+    version: serverVersion,
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// Basic Schema Validator for Required Fields
+function validateArgs(toolName, args) {
+    const definition = TOOLS.find(t => t.name === toolName);
+    if (!definition)
+        return `Unknown tool: ${toolName}`;
+    const required = definition.inputSchema.required || [];
+    for (const field of required) {
+        if (args[field] === undefined || args[field] === null || args[field] === "") {
+            return `Missing required argument: '${field}' for tool '${toolName}'`;
+        }
+    }
+    return null;
+}
+server.setRequestHandler(ListToolsRequestSchema, async (request) => {
+    // 2026 Stateless Spec: Log client info from metadata if available
+    const meta = request._meta;
+    if (meta) {
+        process.stderr.write(`[MCP] Stateless ListTools from ${meta.client?.name || "unknown"} v${meta.client?.version || "?.?"}\n`);
+    }
+    return { tools: TOOLS };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const req = request;
+    const { name, arguments: args } = req.params;
+    const meta = request._meta;
+    // 2026 Stateless Spec: Prioritize metadata-driven context
+    if (meta) {
+        process.stderr.write(`[MCP] Stateless CallTool: ${name} (Client: ${meta.client?.name || "unknown"})\n`);
+    }
+    const projectRoot = process.env.ATABEY_PROJECT_ROOT || process.cwd();
+    try {
+        const handler = toolHandlers[name];
+        if (!handler) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `❌ Unknown tool: ${name}` }],
+            };
+        }
+        // 🛡️ Runtime Validation
+        const validationError = validateArgs(name, args || {});
+        if (validationError) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `❌ Validation Error: ${validationError}` }],
+            };
+        }
+        return await handler(projectRoot, args || {});
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error occurred";
+        return {
+            isError: true,
+            content: [{ type: "text", text: `❌ Execution failed: ${message}` }],
+        };
+    }
+});
+// ─── Graceful Startup & Shutdown ──────────────────────────────────
+async function run() {
+    const transport = new StdioServerTransport();
+    // Prevent unhandled errors from crashing the MCP stream
+    process.on("uncaughtException", (error) => {
+        process.stderr.write(`[atabey-mcp] Uncaught exception: ${error.message}
+`);
+    });
+    process.on("unhandledRejection", (reason) => {
+        const message = reason instanceof Error ? reason.message : String(reason);
+        process.stderr.write(`[atabey-mcp] Unhandled rejection: ${message}
+`);
+    });
+    // Graceful shutdown on SIGINT/SIGTERM
+    const shutdown = async () => {
+        try {
+            await server.close();
+        }
+        catch {
+            // Already closed or failed — safe to ignore
+        }
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    await server.connect(transport);
+}
+run().catch((error) => {
+    process.stderr.write(`[atabey-mcp] Fatal startup error: ${error.message}
+`);
+    process.exit(1);
+});

package/dist/tools/control_plane/locking.js

@@ -0,0 +1,82 @@
+import fs from "fs";
+import path from "path";
+import { resolveFrameworkDir } from "../../utils/security.js";
+/**
+ * Handles acquiring a stateful lock on a resource.
+ */
+export async function handleAcquireLock(projectRoot, args) {
+    const { resource, agent, ttl = 60 } = args;
+    const frameworkDir = resolveFrameworkDir(projectRoot);
+    const lockDir = path.join(projectRoot, frameworkDir, "locks");
+    const lockPath = path.join(lockDir, `${resource}.lock`);
+    try {
+        if (!fs.existsSync(lockDir))
+            fs.mkdirSync(lockDir, { recursive: true });
+        // Check for stale lock first
+        if (fs.existsSync(lockPath)) {
+            const stat = fs.statSync(lockPath);
+            const now = new Date().getTime();
+            const age = (now - stat.mtimeMs) / 1000;
+            if (age < ttl) {
+                return {
+                    isError: true,
+                    content: [{ type: "text", text: `Resource '${resource}' is currently locked by another agent.` }]
+                };
+            }
+            // Lock expired, safe to override by renaming first (POSIX atomic operation)
+            const tempLockPath = `${lockPath}.${Math.random().toString(36).substring(2)}.old`;
+            try {
+                fs.renameSync(lockPath, tempLockPath);
+                fs.unlinkSync(tempLockPath);
+            }
+            catch {
+                // If rename failed, it means another agent already evicting/deleting it.
+                // Do not delete anything else; proceed and let writeFileSync (wx flag) fail if a new lock exists.
+            }
+        }
+        // Use 'wx' flag for atomic file creation
+        const lockData = JSON.stringify({ agent, timestamp: new Date().toISOString() });
+        fs.writeFileSync(lockPath, lockData, { flag: "wx" });
+        return {
+            content: [{ type: "text", text: `✅ Lock acquired for resource '${resource}' by ${agent}.` }]
+        };
+    }
+    catch (e) {
+        const error = e;
+        if (error.code === "EEXIST") {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `Resource '${resource}' was just acquired by another agent.` }]
+            };
+        }
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to acquire lock: ${String(e)}` }]
+        };
+    }
+}
+/**
+ * Handles releasing a lock.
+ */
+export async function handleReleaseLock(projectRoot, args) {
+    const { resource, agent } = args;
+    const frameworkDir = resolveFrameworkDir(projectRoot);
+    const lockPath = path.join(projectRoot, frameworkDir, "locks", `${resource}.lock`);
+    try {
+        if (!fs.existsSync(lockPath)) {
+            return { content: [{ type: "text", text: `ℹ️ No lock found for resource '${resource}'.` }] };
+        }
+        const lockData = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+        if (lockData.agent !== agent) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `❌ Denied: You do not own the lock for '${resource}'. Owned by ${lockData.agent}.` }]
+            };
+        }
+        fs.unlinkSync(lockPath);
+        return { content: [{ type: "text", text: `✅ Lock released for resource '${resource}' by ${agent}.` }] };
+    }
+    catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Failed to release lock: ${String(e)}` }] };
+    }
+}

package/dist/tools/control_plane/registry.js

@@ -0,0 +1,34 @@
+import fs from "fs";
+import path from "path";
+import { resolveFrameworkDir } from "../../utils/security.js";
+/**
+ * Handles agent registration with the Control Plane.
+ * This can be used to validate permissions and active status.
+ */
+export async function handleRegisterAgent(projectRoot, args) {
+    const { agent, role, capability = 5 } = args;
+    const frameworkDir = resolveFrameworkDir(projectRoot);
+    const registryDir = path.join(projectRoot, frameworkDir, "registry");
+    const agentFile = path.join(registryDir, `${agent.replace("@", "")}_active.json`);
+    try {
+        if (!fs.existsSync(registryDir))
+            fs.mkdirSync(registryDir, { recursive: true });
+        const agentData = {
+            agent,
+            role,
+            capability,
+            last_seen: new Date().toISOString(),
+            status: "ACTIVE"
+        };
+        fs.writeFileSync(agentFile, JSON.stringify(agentData, null, 2));
+        return {
+            content: [{ type: "text", text: `🎖️ Agent ${agent} (${role}) registered successfully in the Atabey Control Plane.` }]
+        };
+    }
+    catch (e) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: `Failed to register agent: ${String(e)}` }]
+        };
+    }
+}

package/dist/tools/definitions.js

@@ -0,0 +1,290 @@
+export const TOOLS = [
+    {
+        name: "read_file",
+        description: "Read the content of a file within the project. Supports optional line range reading to prevent stream overload.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file relative to project root" },
+                startLine: { type: "number", description: "Optional starting line number (1-indexed)" },
+                endLine: { type: "number", description: "Optional ending line number (inclusive)" },
+            },
+            required: ["path"],
+        },
+    },
+    {
+        name: "list_dir",
+        description: "List the contents of a directory. Essential for codebase exploration.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the directory relative to project root (default: '.')" },
+            },
+        },
+    },
+    {
+        name: "grep_search",
+        description: "Perform a recursive regex search across the codebase to find functions, variables, or patterns.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                pattern: { type: "string", description: "The regex pattern to search for" },
+                includePattern: { type: "string", description: "Optional: Filter files by extension (e.g., '.ts')" },
+                excludePattern: { type: "string", description: "Optional: Directory pattern to exclude (default: 'node_modules')" },
+            },
+            required: ["pattern"],
+        },
+    },
+    {
+        name: "write_file",
+        description: "Write content to a file. Creates directories if missing.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file relative to project root" },
+                content: { type: "string", description: "Complete content of the file" },
+            },
+            required: ["path", "content"],
+        },
+    },
+    {
+        name: "replace_text",
+        description: "Surgically replace a string in a file with another string.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file" },
+                oldText: { type: "string", description: "The exact text to find" },
+                newText: { type: "string", description: "The text to replace it with" },
+                allowMultiple: { type: "boolean", description: "Allow multiple replacements if oldText is not unique." }
+            },
+            required: ["path", "oldText", "newText"],
+        },
+    },
+    {
+        name: "batch_surgical_edit",
+        description: "Perform multiple surgical text replacements across multiple files in a single batch request. More efficient for cross-cutting changes.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                edits: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        properties: {
+                            path: { type: "string", description: "Path to the file" },
+                            oldText: { type: "string", description: "The exact text to find" },
+                            newText: { type: "string", description: "The text to replace it with" },
+                            allowMultiple: { type: "boolean", description: "Allow multiple replacements in this file." }
+                        },
+                        required: ["path", "oldText", "newText"]
+                    }
+                }
+            },
+            required: ["edits"],
+        },
+    },
+    {
+        name: "patch_file",
+        description: "Safely update a file by replacing a specific line range with new content.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file" },
+                startLine: { type: "number", description: "Starting line number (1-indexed)" },
+                endLine: { type: "number", description: "Ending line number (inclusive)" },
+                newContent: { type: "string", description: "The new lines to insert" },
+            },
+            required: ["path", "startLine", "endLine", "newContent"],
+        },
+    },
+    {
+        name: "get_project_map",
+        description: "Generate a tree-view map of the project structure to visualize the layout. Useful for onboarding and architectural analysis.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                maxDepth: { type: "number", description: "Maximum directory depth to scan (default: 3)" },
+                includeFiles: { type: "boolean", description: "Whether to include files in the map (default: true)" }
+            }
+        }
+    },
+    {
+        name: "get_project_gaps",
+        description: "Scans the codebase for TODOs, FIXMEs, and empty function bodies. Helps identify what is left and where the agent might have skipped logic.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the source directory (default: 'src')" },
+            },
+        },
+    },
+    {
+        name: "audit_dependencies",
+        description: "Audits package.json for unused, redundant, or duplicate-like packages to ensure a clean dependency tree.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "run_tests",
+        description: "Execute project test suites (Vitest, Playwright, etc.) and capture detailed pass/fail reports for analysis.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "The test command to run (default: project's standard test command)" }
+            }
+        }
+    },
+    {
+        name: "get_system_health",
+        description: "Retrieve real-time system metrics like CPU load, RAM usage, and uptime.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "check_active_ports",
+        description: "Identify which network ports are currently active and listening. Helps verify if the dev server or API is running.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filter: { type: "string", description: "Optional: Filter results by port number or service name (e.g., ':3000')" }
+            }
+        }
+    },
+    {
+        name: "get_framework_status",
+        description: "Get the current project phase, active traces, and agent states.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "read_project_memory",
+        description: "Read the full project central memory (PROJECT_MEMORY.md). Use this at the start of a session to gain context.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "get_memory_insights",
+        description: "Retrieve a summarized version of the project memory (active phase, trace, and last 5 actions) to save tokens.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "update_project_memory",
+        description: "Update a specific section in PROJECT_MEMORY.md.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                section: { type: "string", description: "Section name (e.g., HISTORY, ACTIVE TASKS)" },
+                content: { type: "string", description: "Markdown content to append or set" },
+            },
+            required: ["section", "content"],
+        },
+    },
+    {
+        name: "orchestrate_loop",
+        description: "Process the pending Hermes messages and trigger dynamic state transitions.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "send_agent_message",
+        description: "Send a Hermes protocol message to another agent for collaboration or sub-tasking.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                from: { type: "string", description: "Sender agent (e.g., @manager, @backend)." },
+                to: { type: "string", description: "Target agent (e.g., @backend, @quality)." },
+                category: { type: "string", enum: ["ACTION", "DELEGATION", "SUBTASK", "REPLY", "ALERT"], description: "Message type." },
+                content: { type: "string", description: "Task description or message content." },
+                traceId: { type: "string", description: "Active Trace ID." },
+                parentId: { type: "string", description: "Optional parent task trace ID for hierarchical tracking." },
+                priority: { type: "string", enum: ["HIGH", "NORMAL", "LOW"], description: "Optional priority level (HIGH, NORMAL, LOW). Defaults to HIGH for ALERT/ACTION." },
+                requiresApproval: { type: "boolean", description: "If true, this message will require manager approval before being processed." },
+            },
+            required: ["from", "to", "category", "content", "traceId"],
+        },
+    },
+    {
+        name: "acquire_lock",
+        description: "Acquire a stateful lock on a shared resource (like PROJECT_MEMORY.md) to prevent concurrent write conflicts.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                resource: { type: "string", description: "The resource name or path to lock (e.g., 'memory')." },
+                agent: { type: "string", description: "The agent requesting the lock (e.g., '@backend')." },
+                ttl: { type: "number", description: "Time-to-live in seconds before the lock auto-expires (default: 60)." }
+            },
+            required: ["resource", "agent"]
+        }
+    },
+    {
+        name: "release_lock",
+        description: "Release a previously acquired lock on a resource.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                resource: { type: "string", description: "The resource name or path." },
+                agent: { type: "string", description: "The agent releasing the lock." }
+            },
+            required: ["resource", "agent"]
+        }
+    },
+    {
+        name: "register_agent",
+        description: "Register an agent instance with the Control Plane and validate its permissions.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agent: { type: "string", description: "The agent name (e.g., '@backend')." },
+                role: { type: "string", description: "The role of the agent." },
+                capability: { type: "number", description: "The capability score (1-10)." }
+            },
+            required: ["agent", "role"]
+        }
+    },
+    {
+        name: "log_agent_action",
+        description: "Log an agent action to the framework logs.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                agent: { type: "string", description: "The agent name (e.g., @manager, @backend)" },
+                action: { type: "string", description: "Action type or name" },
+                traceId: { type: "string", description: "The active Trace ID" },
+                status: { type: "string", enum: ["SUCCESS", "FAILURE"], description: "The status of the action" },
+                summary: { type: "string", description: "Brief description of the action taken" },
+                findings: { type: "string", description: "Optional comma-separated findings or details" }
+            },
+            required: ["agent", "action", "traceId", "status", "summary"]
+        }
+    },
+    {
+        name: "update_contract_hash",
+        description: "Re-generate and synchronize the backend contract SHA-256 hash.",
+        inputSchema: { type: "object", properties: {} }
+    },
+    {
+        name: "run_shell_command",
+        description: "Execute a shell command. For security, only a limited set of commands are allowed.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                command: { type: "string", description: "The shell command to execute." },
+            },
+            required: ["command"],
+        },
+    },
+    {
+        name: "check_lint",
+        description: "Run the project's linter (e.g., ESLint) to check for code quality and style issues.",
+        inputSchema: { type: "object", properties: {} },
+    },
+    {
+        name: "view_file",
+        description: "Alias for read_file. Reads the content of a file within the project.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                path: { type: "string", description: "Path to the file relative to project root" },
+                startLine: { type: "number", description: "Optional starting line number (1-indexed)" },
+                endLine: { type: "number", description: "Optional ending line number (inclusive)" },
+            },
+            required: ["path"],
+        },
+    }
+];

package/dist/tools/file_system/batch_surgical_edit.js

@@ -0,0 +1,59 @@
+import fs from "fs";
+import { safePath } from "../../utils/security.js";
+import { writeTextFileAtomic } from "../../utils/fs.js";
+import { Metrics } from "../../utils/metrics.js";
+import { verifyCorporateCompliance } from "../../utils/compliance.js";
+/**
+ * Performs multiple surgical text replacements across multiple files in a single batch.
+ */
+export function handleBatchSurgicalEdit(projectRoot, args) {
+    const edits = args.edits;
+    if (!Array.isArray(edits) || edits.length === 0) {
+        const err = "No edits provided in the batch request.";
+        Metrics.logError(projectRoot, "@mcp", "batch_surgical_edit", err);
+        throw new Error(err);
+    }
+    const results = [];
+    let totalTokens = 0;
+    for (const edit of edits) {
+        const filePath = safePath(projectRoot, edit.path);
+        if (!fs.existsSync(filePath)) {
+            const err = `File not found: ${edit.path}`;
+            Metrics.logError(projectRoot, "@mcp", `batch_surgical_edit:${edit.path}`, err);
+            throw new Error(err);
+        }
+        const content = fs.readFileSync(filePath, "utf8");
+        const { oldText, newText, allowMultiple = false } = edit;
+        if (!content.includes(oldText)) {
+            const err = `Text not found in file ${edit.path}`;
+            Metrics.logError(projectRoot, "@mcp", `batch_surgical_edit:${edit.path}`, err);
+            throw new Error(err);
+        }
+        // Surgical precision guard
+        if (!allowMultiple) {
+            const firstIndex = content.indexOf(oldText);
+            const lastIndex = content.lastIndexOf(oldText);
+            if (firstIndex !== lastIndex) {
+                const err = `Ambiguous replacement in ${edit.path}`;
+                Metrics.logError(projectRoot, "@mcp", `batch_surgical_edit:${edit.path}`, err);
+                throw new Error(err);
+            }
+        }
+        const newContent = allowMultiple
+            ? content.replace(new RegExp(oldText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), newText)
+            : content.replace(oldText, newText);
+        // ENFORCE CORPORATE COMPLIANCE
+        verifyCorporateCompliance(newContent, edit.path);
+        writeTextFileAtomic(filePath, newContent);
+        const tokens = Metrics.estimateTokens(newText);
+        totalTokens += tokens;
+        results.push(`✅ Edited ${edit.path}`);
+    }
+    Metrics.logUsage(projectRoot, "@mcp", `batch_surgical_edit: ${edits.length} files`, totalTokens);
+    return {
+        content: [{
+                type: "text",
+                text: `Successfully performed ${edits.length} edits:\n${results.join("\n")}`
+            }]
+    };
+}