npm - atabey - Versions diffs - 0.0.11 → 0.0.13 - Mend

atabey 0.0.11 → 0.0.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (522) hide show

package/framework-mcp/dist/dashboard/index.html ADDED Viewed

@@ -0,0 +1,15 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Hermes Control Center | Agent Atabey</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet" />
+    <script type="module" crossorigin src="/assets/index-BAPGLiWE.js"></script>
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

package/framework-mcp/dist/framework-mcp/src/constants.js ADDED Viewed

@@ -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": ".agents/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/framework-mcp/dist/framework-mcp/src/index.js ADDED Viewed

@@ -0,0 +1,156 @@
+#!/usr/bin/env node
+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, ListResourcesRequestSchema, ReadResourceRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { TOOLS, toolHandlers, toolSchemas } from "./tools/index.js";
+import { RESOURCES, handleReadResource } from "./resources/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: {},
+        resources: {},
+    },
+});
+/**
+ * Validates tool arguments using Zod schemas for "Zero Type Hole" compliance.
+ * Falls back to basic presence check if no Zod schema is defined for the tool.
+ */
+function validateArgs(toolName, args) {
+    const schema = toolSchemas[toolName];
+    if (schema) {
+        const result = schema.safeParse(args);
+        if (!result.success) {
+            return result.error.errors.map(e => `${e.path.join(".")}: ${e.message}`).join(", ");
+        }
+        return null;
+    }
+    // Fallback for tools without Zod schemas yet
+    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(ListResourcesRequestSchema, async () => {
+    return { resources: RESOURCES };
+});
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const uri = request.params.uri;
+    try {
+        const content = await handleReadResource(uri);
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: "text/markdown",
+                    text: content,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read resource: ${message}`, { cause: error });
+    }
+});
+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: `[ERROR] Unknown tool: ${name}` }],
+            };
+        }
+        // [SECURITY] Runtime Validation
+        const validationError = validateArgs(name, args || {});
+        if (validationError) {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `[ERROR] 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: `[ERROR] 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/framework-mcp/dist/framework-mcp/src/resources/index.js ADDED Viewed

@@ -0,0 +1,58 @@
+import { Storage } from "../utils/storage.js";
+/**
+ * [DATA] MCP Resource Definitions
+ */
+export const RESOURCES = [
+    {
+        uri: "atabey://AL/status",
+        name: "AL Registry Status",
+        description: "Real-time state and active tasks of all specialized agents.",
+        mimeType: "text/markdown"
+    },
+    {
+        uri: "atabey://plan/active",
+        name: "Active Execution Plan",
+        description: "The current DAG of tasks and their completion status.",
+        mimeType: "text/markdown"
+    },
+    {
+        uri: "atabey://memory/project",
+        name: "Project Memory",
+        description: "The central source of truth for project context (PROJECT_MEMORY.md).",
+        mimeType: "text/markdown"
+    }
+];
+export async function handleReadResource(uri) {
+    if (uri === "atabey://AL/status") {
+        const agents = Storage.getAllAgents();
+        let md = "# [AI] AL Registry Status\n\n| Agent | State | Active Task | Last Updated |\n| :--- | :--- | :--- | :--- |\n";
+        agents.forEach((a) => {
+            md += `| @${a.name} | ${a.state} | ${a.task} | ${a.last_updated} |\n`;
+        });
+        return md;
+    }
+    if (uri === "atabey://plan/active") {
+        const tasks = Storage.getTasks();
+        let md = "# [LIST] Active Execution Plan\n\n| ID | Task | Agent | Status | Dependencies |\n| :--- | :--- | :--- | :--- | :--- |\n";
+        tasks.forEach((t) => {
+            const deps = t.dependencies.join(", ") || "-";
+            md += `| ${t.id} | ${t.description} | ${t.agent} | ${t.status} | ${deps} |\n`;
+        });
+        return md;
+    }
+    if (uri === "atabey://memory/project") {
+        const fs = await import("fs");
+        const path = await import("path");
+        const { getFrameworkDir } = await import("../utils/memory.js");
+        const projectRoot = process.env.ATABEY_PROJECT_ROOT || process.cwd();
+        const fwDir = getFrameworkDir();
+        const p = path.isAbsolute(fwDir)
+            ? path.join(fwDir, "memory", "PROJECT_MEMORY.md")
+            : path.join(projectRoot, fwDir, "memory", "PROJECT_MEMORY.md");
+        if (fs.existsSync(p)) {
+            return fs.readFileSync(p, "utf8");
+        }
+        return "Project memory not found. Run 'atabey init' first.";
+    }
+    throw new Error(`Unknown resource URI: ${uri}`);
+}

package/framework-mcp/dist/framework-mcp/src/tools/control_plane/locking.js ADDED Viewed

@@ -0,0 +1,84 @@
+import fs from "fs";
+import path from "path";
+import { resolveFrameworkDir } from "../../utils/security.js";
+import { Metrics } from "../../utils/metrics.js";
+/**
+ * Handles acquiring a stateful lock on a resource with Deadlock Resolution.
+ */
+export async function handleAcquireLock(projectRoot, args) {
+    const { resource, agent, ttl = 300 } = args; // Default TTL 5 minutes to prevent deadlocks
+    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 (DEADLOCK RESOLUTION)
+        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: `[LOCKED] Resource '${resource}' is currently locked by another agent. Try again later.` }]
+                };
+            }
+            // Lock expired: Force Eviction
+            const oldLockData = JSON.parse(fs.readFileSync(lockPath, "utf8"));
+            Metrics.logError(projectRoot, "@mcp", "lock_eviction", `Forcefully evicted stale lock on '${resource}' held by ${oldLockData.agent} for ${Math.round(age)}s.`);
+            const tempLockPath = `${lockPath}.${Math.random().toString(36).substring(2)}.old`;
+            try {
+                fs.renameSync(lockPath, tempLockPath);
+                fs.unlinkSync(tempLockPath);
+            }
+            catch {
+                // Ignore if already evicted by race condition
+            }
+        }
+        // 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: `[OK] Lock acquired for resource '${resource}' by ${agent}.` }]
+        };
+    }
+    catch (e) {
+        const error = e;
+        if (error.code === "EEXIST") {
+            return {
+                isError: true,
+                content: [{ type: "text", text: `[LOCKED] 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: `[INFO] 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: `[ERROR] Denied: You do not own the lock for '${resource}'. Owned by ${lockData.agent}.` }]
+            };
+        }
+        fs.unlinkSync(lockPath);
+        return { content: [{ type: "text", text: `[OK] Lock released for resource '${resource}' by ${agent}.` }] };
+    }
+    catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Failed to release lock: ${String(e)}` }] };
+    }
+}

package/framework-mcp/dist/framework-mcp/src/tools/control_plane/registry.js ADDED Viewed

@@ -0,0 +1,35 @@
+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, specialties } = 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,
+            specialties,
+            last_seen: new Date().toISOString(),
+            status: "ACTIVE"
+        };
+        fs.writeFileSync(agentFile, JSON.stringify(agentData, null, 2));
+        return {
+            content: [{ type: "text", text: `[ATABEY] 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/framework-mcp/dist/framework-mcp/src/tools/definitions.js ADDED Viewed

@@ -0,0 +1,197 @@
+import { zodToMcpSchema } from "../utils/zod-to-mcp.js";
+import * as schemas from "./schemas.js";
+/**
+ * ─── SUPREME TOOL REGISTRY ─────────────────────────────────────────
+ * Every tool is dynamically generated from its Zod schema.
+ * ZERO manual JSON schema maintenance permitted.
+ */
+export const TOOLS = [
+    // File System
+    {
+        name: "read_file",
+        description: "Read the content of a file within the project. Supports optional line range reading to prevent stream overload.",
+        inputSchema: zodToMcpSchema(schemas.ReadFileSchema),
+    },
+    {
+        name: "view_file",
+        description: "Alias for read_file. Reads the content of a file within the project.",
+        inputSchema: zodToMcpSchema(schemas.ReadFileSchema),
+    },
+    {
+        name: "write_file",
+        description: "Write content to a file. Creates directories if missing.",
+        inputSchema: zodToMcpSchema(schemas.WriteFileSchema),
+    },
+    {
+        name: "replace_text",
+        description: "Surgically replace a string in a file with another string.",
+        inputSchema: zodToMcpSchema(schemas.ReplaceTextSchema),
+    },
+    {
+        name: "batch_surgical_edit",
+        description: "Perform multiple surgical text replacements across multiple files in a single batch request.",
+        inputSchema: zodToMcpSchema(schemas.BatchSurgicalEditSchema),
+    },
+    {
+        name: "patch_file",
+        description: "Safely update a file by replacing a specific line range with new content.",
+        inputSchema: zodToMcpSchema(schemas.PatchFileSchema),
+    },
+    // Search & Exploration
+    {
+        name: "list_dir",
+        description: "List the contents of a directory. Essential for codebase exploration.",
+        inputSchema: zodToMcpSchema(schemas.ListDirSchema),
+    },
+    {
+        name: "grep_search",
+        description: "Perform a recursive regex search across the codebase.",
+        inputSchema: zodToMcpSchema(schemas.GrepSearchSchema),
+    },
+    {
+        name: "get_project_map",
+        description: "Generate a tree-view map of the project structure.",
+        inputSchema: zodToMcpSchema(schemas.GetProjectMapSchema),
+    },
+    {
+        name: "get_project_gaps",
+        description: "Scans the codebase for TODOs, FIXMEs, and empty function bodies.",
+        inputSchema: zodToMcpSchema(schemas.GetProjectGapsSchema),
+    },
+    // Framework & System
+    {
+        name: "run_shell_command",
+        description: "Execute a shell command. Restricted for security.",
+        inputSchema: zodToMcpSchema(schemas.RunShellCommandSchema),
+    },
+    {
+        name: "run_tests",
+        description: "Execute project test suites and capture pass/fail reports.",
+        inputSchema: zodToMcpSchema(schemas.RunTestsSchema),
+    },
+    {
+        name: "get_system_health",
+        description: "Retrieve real-time system metrics (CPU, RAM).",
+        inputSchema: zodToMcpSchema(schemas.GetSystemHealthSchema),
+    },
+    {
+        name: "check_active_ports",
+        description: "Identify which network ports are currently active.",
+        inputSchema: zodToMcpSchema(schemas.CheckPortsSchema),
+    },
+    {
+        name: "get_framework_status",
+        description: "Get the current project phase, active traces, and agent states.",
+        inputSchema: zodToMcpSchema(schemas.GetFrameworkStatusSchema),
+    },
+    {
+        name: "read_project_memory",
+        description: "Read the full project central memory (PROJECT_MEMORY.md).",
+        inputSchema: zodToMcpSchema(schemas.ReadProjectMemorySchema),
+    },
+    {
+        name: "get_memory_insights",
+        description: "Retrieve a summarized version of the project memory.",
+        inputSchema: zodToMcpSchema(schemas.GetMemoryInsightsSchema),
+    },
+    {
+        name: "update_project_memory",
+        description: "Update a specific section in PROJECT_MEMORY.md.",
+        inputSchema: zodToMcpSchema(schemas.UpdateProjectMemorySchema),
+    },
+    // Memory (Core Memory)
+    {
+        name: "store_knowledge",
+        description: "Store a new piece of project knowledge, decision, or code snippet into the vector-based core memory.",
+        inputSchema: zodToMcpSchema(schemas.StoreKnowledgeSchema),
+    },
+    {
+        name: "search_knowledge",
+        description: "Search the vector-based core memory for relevant project knowledge, past decisions, or rules.",
+        inputSchema: zodToMcpSchema(schemas.SearchKnowledgeSchema),
+    },
+    {
+        name: "delete_knowledge",
+        description: "Delete an obsolete or incorrect knowledge entry from the Core Memory.",
+        inputSchema: zodToMcpSchema(schemas.DeleteKnowledgeSchema),
+    },
+    {
+        name: "orchestrate_loop",
+        description: "Process pending Hermes messages and trigger transitions.",
+        inputSchema: zodToMcpSchema(schemas.OrchestrateLoopSchema),
+    },
+    {
+        name: "submit_plan",
+        description: "Submit a structured DAG plan of tasks for the project.",
+        inputSchema: zodToMcpSchema(schemas.SubmitPlanSchema),
+    },
+    {
+        name: "update_contract_hash",
+        description: "Re-generate and synchronize the backend contract SHA-256 hash.",
+        inputSchema: zodToMcpSchema(schemas.UpdateContractHashSchema),
+    },
+    {
+        name: "audit_dependencies",
+        description: "Audits package.json for unused or redundant packages.",
+        inputSchema: zodToMcpSchema(schemas.AuditDependenciesSchema),
+    },
+    {
+        name: "check_lint",
+        description: "Run the project's linter (e.g., ESLint).",
+        inputSchema: zodToMcpSchema(schemas.CheckLintSchema),
+    },
+    // Control Plane
+    {
+        name: "acquire_lock",
+        description: "Acquire a stateful lock on a shared resource.",
+        inputSchema: zodToMcpSchema(schemas.AcquireLockSchema),
+    },
+    {
+        name: "release_lock",
+        description: "Release a previously acquired lock.",
+        inputSchema: zodToMcpSchema(schemas.ReleaseLockSchema),
+    },
+    {
+        name: "register_agent",
+        description: "Register an agent instance with the Control Plane.",
+        inputSchema: zodToMcpSchema(schemas.RegisterAgentSchema),
+    },
+    // Messaging (Hermes)
+    {
+        name: "send_agent_message",
+        description: "Send a Hermes protocol message to another agent.",
+        inputSchema: zodToMcpSchema(schemas.SendAgentMessageSchema),
+    },
+    {
+        name: "log_agent_action",
+        description: "Log an agent action to the framework logs.",
+        inputSchema: zodToMcpSchema(schemas.LogAgentActionSchema),
+    },
+    {
+        name: "ask_human",
+        description: "Pause execution and ask the human developer a clarifying question via the terminal.",
+        inputSchema: zodToMcpSchema(schemas.AskHumanSchema),
+    },
+    // ─── Code Quality ─────────────────────────────────────────────
+    {
+        name: "analyze_code_quality",
+        description: "Analyze code quality in a given path. Checks TypeScript types, lint rules, and code complexity.",
+        inputSchema: zodToMcpSchema(schemas.AnalyzeCodeQualitySchema),
+    },
+    {
+        name: "check_architecture_compliance",
+        description: "Check architecture compliance in a given path. Verifies layer boundaries (Controller→Service→Repository), import direction rules, and strict mode.",
+        inputSchema: zodToMcpSchema(schemas.CheckArchitectureComplianceSchema),
+    },
+    // ─── LLM Gateway ─────────────────────────────────────────
+    {
+        name: "llm_gateway_query",
+        description: "Send a chat completion request through the ATABEY LLM Gateway. The gateway automatically load-balances across providers (OpenAI, Anthropic, Google, Grok, Ollama) using configurable strategies (failover, round-robin, cost-optimized). Allows any MCP-connected AI to route LLM requests through the gateway.",
+        inputSchema: zodToMcpSchema(schemas.LLMGatewayQuerySchema),
+    },
+    {
+        name: "llm_gateway_status",
+        description: "Get the current status of the LLM Gateway including provider health, load balancing strategy, usage statistics, and budget information.",
+        inputSchema: zodToMcpSchema(schemas.LLMGatewayStatusSchema),
+    },
+];

package/framework-mcp/dist/framework-mcp/src/tools/file_system/batch_surgical_edit.js ADDED Viewed

@@ -0,0 +1,64 @@
+import fs from "fs";
+import { verifyCorporateCompliance, verifyRiskAndAwaitApproval } from "../../utils/compliance.js";
+import { writeTextFile } from "../../utils/fs.js";
+import { Metrics } from "../../utils/metrics.js";
+import { verifyWritePermission } from "../../utils/permissions.js";
+import { safePath } from "../../utils/security.js";
+/**
+ * Performs multiple surgical text replacements across multiple files in a single batch.
+ */
+export async 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);
+        // ENFORCE PERMISSION MATRIX
+        verifyWritePermission(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);
+        // ENFORCE RISK & HUMAN APPROVAL GATEWAY
+        await verifyRiskAndAwaitApproval(projectRoot, newContent, edit.path);
+        writeTextFile(filePath, newContent);
+        const tokens = Metrics.estimateTokens(newText);
+        totalTokens += tokens;
+        results.push(`[OK] 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")}`
+            }]
+    };
+}