atabey 0.0.11 → 0.0.13

package/framework-mcp/dist/framework-mcp/src/tools/file_system/patch_file.js

@@ -0,0 +1,34 @@
+import fs from "fs";
+import { safePath } from "../../utils/security.js";
+import { Metrics } from "../../utils/metrics.js";
+import { verifyCorporateCompliance, verifyRiskAndAwaitApproval } from "../../utils/compliance.js";
+import { verifyWritePermission } from "../../utils/permissions.js";
+export async function handlePatchFile(projectRoot, args) {
+    const filePath = safePath(projectRoot, args.path);
+    // ENFORCE PERMISSION MATRIX
+    verifyWritePermission(projectRoot, args.path);
+    const lines = fs.readFileSync(filePath, "utf8").split("\n");
+    const start = args.startLine - 1;
+    const end = args.endLine;
+    const newContent = args.newContent.split("\n");
+    if (start < 0 || start > lines.length) {
+        const err = `Invalid start line: ${start + 1}. File has ${lines.length} lines.`;
+        Metrics.logError(projectRoot, "@mcp", `patch_file:${args.path}`, err);
+        throw new Error(err);
+    }
+    if (end < start + 1 || end > lines.length) {
+        const err = `Invalid end line: ${end}. Must be between ${start + 1} and ${lines.length}.`;
+        Metrics.logError(projectRoot, "@mcp", `patch_file:${args.path}`, err);
+        throw new Error(err);
+    }
+    lines.splice(start, end - start, ...newContent);
+    const patchedContent = lines.join("\n");
+    // ENFORCE CORPORATE COMPLIANCE
+    verifyCorporateCompliance(patchedContent, args.path);
+    // ENFORCE RISK & HUMAN APPROVAL GATEWAY
+    await verifyRiskAndAwaitApproval(projectRoot, patchedContent, args.path);
+    fs.writeFileSync(filePath, patchedContent);
+    const tokens = Metrics.estimateTokens(args.newContent);
+    Metrics.logUsage(projectRoot, "@mcp", `patch_file: ${args.path}`, tokens);
+    return { content: [{ type: "text", text: `[OK] File patched successfully: ${args.path}` }] };
+}

package/framework-mcp/dist/framework-mcp/src/tools/file_system/read_file.js

@@ -0,0 +1,51 @@
+import fs from "fs";
+import { safePath } from "../../utils/security.js";
+import { Metrics } from "../../utils/metrics.js";
+export function handleReadFile(projectRoot, args) {
+    if (!args.path) {
+        const err = "Missing 'path' argument.";
+        Metrics.logError(projectRoot, "@mcp", "read_file", err);
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
+    }
+    try {
+        const filePath = safePath(projectRoot, args.path);
+        if (!fs.existsSync(filePath)) {
+            const err = `File not found: ${args.path}`;
+            Metrics.logError(projectRoot, "@mcp", "read_file", err);
+            return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
+        }
+        const startLine = args.startLine;
+        const endLine = args.endLine;
+        const content = fs.readFileSync(filePath, "utf8");
+        const lines = content.split(/\r?\n/);
+        if (startLine !== undefined || endLine !== undefined) {
+            const start = startLine !== undefined ? Math.max(1, startLine) - 1 : 0;
+            const end = endLine !== undefined ? Math.min(lines.length, endLine) : lines.length;
+            const sliced = lines.slice(start, end).join("\n");
+            const tokens = Metrics.estimateTokens(sliced);
+            Metrics.logUsage(projectRoot, "@mcp", `read_file: ${args.path}`, tokens);
+            return { content: [{ type: "text", text: sliced }] };
+        }
+        // ENFORCE TOKEN ECONOMY: Hard Limit for large files
+        const HARD_LIMIT_LINES = 300;
+        if (lines.length > HARD_LIMIT_LINES && (startLine === undefined || endLine === undefined)) {
+            const errMsg = `[TOKEN ECONOMY GUARD] File '${args.path}' is too large (${lines.length} lines). To prevent context overflow and token waste, you MUST provide both 'startLine' and 'endLine' parameters to read specific sections of this file.`;
+            Metrics.logError(projectRoot, "@mcp", `read_file: ${args.path} (blocked)`, errMsg);
+            return {
+                isError: true,
+                content: [{
+                        type: "text",
+                        text: `[ERROR] ${errMsg}`
+                    }]
+            };
+        }
+        const tokens = Metrics.estimateTokens(content);
+        Metrics.logUsage(projectRoot, "@mcp", `read_file: ${args.path}`, tokens);
+        return { content: [{ type: "text", text: content }] };
+    }
+    catch (e) {
+        const err = `Failed to read file: ${String(e)}`;
+        Metrics.logError(projectRoot, "@mcp", `read_file:${args.path}`, err);
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
+    }
+}

package/framework-mcp/dist/framework-mcp/src/tools/file_system/replace_text.js

@@ -0,0 +1,50 @@
+import fs from "fs";
+import { writeTextFile } from "../../utils/fs.js";
+import { Metrics } from "../../utils/metrics.js";
+import { safePath } from "../../utils/security.js";
+import { verifyCorporateCompliance, verifyRiskAndAwaitApproval } from "../../utils/compliance.js";
+import { verifyWritePermission } from "../../utils/permissions.js";
+export async function handleReplaceText(projectRoot, args) {
+    const filePath = safePath(projectRoot, args.path);
+    // ENFORCE PERMISSION MATRIX
+    verifyWritePermission(projectRoot, args.path);
+    const content = fs.readFileSync(filePath, "utf8");
+    const oldText = args.oldText;
+    const newText = args.newText;
+    const allowMultiple = args.allowMultiple || false; // Default to false
+    if (!content.includes(oldText)) {
+        const err = `Text not found in file: ${oldText.slice(0, 100)}...`;
+        Metrics.logError(projectRoot, "@mcp", `replace_text:${args.path}`, err);
+        throw new Error(err);
+    }
+    // Surgical precision guard: reject ambiguous replacements unless allowMultiple is true.
+    if (!allowMultiple) {
+        const firstIndex = content.indexOf(oldText);
+        const lastIndex = content.lastIndexOf(oldText);
+        if (firstIndex !== lastIndex) {
+            const count = (content.match(new RegExp(oldText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g")) || []).length;
+            const err = `Ambiguous replacement: "${oldText.slice(0, 80)}..." found ${count} times in ${args.path}. ` +
+                "Provide a longer, unique context string or set 'allow_multiple' to true.";
+            Metrics.logError(projectRoot, "@mcp", `replace_text:${args.path}`, err);
+            throw new Error(err);
+        }
+    }
+    // Perform replacement(s).
+    // Use a function replacer so special patterns ($&, $1, $$) inside newText
+    // are treated literally and never reinterpreted as regex backreferences.
+    let newContent;
+    if (allowMultiple) {
+        newContent = content.replace(new RegExp(oldText.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"), () => newText);
+    }
+    else {
+        newContent = content.replace(oldText, () => newText);
+    }
+    // ENFORCE CORPORATE COMPLIANCE
+    verifyCorporateCompliance(newContent, args.path);
+    // ENFORCE RISK & HUMAN APPROVAL GATEWAY
+    await verifyRiskAndAwaitApproval(projectRoot, newContent, args.path);
+    writeTextFile(filePath, newContent);
+    const tokens = Metrics.estimateTokens(newText);
+    Metrics.logUsage(projectRoot, "@mcp", `replace_text: ${args.path}`, tokens);
+    return { content: [{ type: "text", text: `[OK] Surgical edit successful in ${args.path}` }] };
+}

package/framework-mcp/dist/framework-mcp/src/tools/file_system/write_file.js

@@ -0,0 +1,55 @@
+import fs from "fs";
+import path from "path";
+import { appendFile, writeTextFile } from "../../utils/fs.js";
+import { Metrics } from "../../utils/metrics.js";
+import { resolveFrameworkDir, safePath } from "../../utils/security.js";
+import { verifyCorporateCompliance, verifyRiskAndAwaitApproval } from "../../utils/compliance.js";
+import { verifyWritePermission } from "../../utils/permissions.js";
+export async function handleWriteFile(projectRoot, args) {
+    if (!args.path || args.content === undefined) {
+        const err = "Missing 'path' or 'content' argument.";
+        Metrics.logError(projectRoot, "@mcp", "write_file", err);
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
+    }
+    try {
+        const filePath = safePath(projectRoot, args.path);
+        // ENFORCE TOKEN ECONOMY: Prevent full-file rewrites of existing files
+        if (fs.existsSync(filePath)) {
+            const errMsg = `[TOKEN ECONOMY GUARD] The file '${args.path}' already exists. Overwriting entire existing files is FORBIDDEN to save tokens and prevent context drift. You MUST use 'patch_file' or 'replace_text' tools to make surgical edits.`;
+            Metrics.logError(projectRoot, "@mcp", `write_file: ${args.path} (blocked)`, errMsg);
+            return {
+                isError: true,
+                content: [{
+                        type: "text",
+                        text: `[ERROR] ${errMsg}`
+                    }]
+            };
+        }
+        const content = args.content;
+        // ENFORCE PERMISSION MATRIX
+        verifyWritePermission(projectRoot, args.path);
+        // ENFORCE CORPORATE COMPLIANCE
+        verifyCorporateCompliance(content, args.path);
+        // ENFORCE RISK & HUMAN APPROVAL GATEWAY
+        await verifyRiskAndAwaitApproval(projectRoot, content, args.path);
+        writeTextFile(filePath, content);
+        // AUTO-LOGGING & METRICS
+        const tokens = Metrics.estimateTokens(content);
+        Metrics.logUsage(projectRoot, "@mcp", `write_file: ${args.path}`, tokens);
+        try {
+            const frameworkDir = resolveFrameworkDir(projectRoot);
+            const memoryPath = path.join(projectRoot, frameworkDir, "memory/PROJECT_MEMORY.md");
+            if (fs.existsSync(memoryPath)) {
+                const entry = `\n### ${new Date().toISOString().split("T")[0]} — Auto-Update\n- **Action:** wrote file \`${args.path}\` (${tokens} tokens estimated).\n`;
+                appendFile(memoryPath, entry);
+            }
+        }
+        catch { /* ignore memory logging errors */ }
+        return { content: [{ type: "text", text: `[OK] File written: ${args.path}` }] };
+    }
+    catch (e) {
+        const err = `Failed to write file: ${String(e)}`;
+        Metrics.logError(projectRoot, "@mcp", `write_file:${args.path}`, err);
+        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
+    }
+}

package/framework-mcp/dist/framework-mcp/src/tools/framework/audit_deps.js

@@ -0,0 +1,41 @@
+import fs from "fs";
+import path from "path";
+/**
+ * Audits package.json for unused or duplicate-like packages.
+ * Focuses on project health and cleanup.
+ */
+export function handleAuditDependencies(projectRoot, _args) {
+    const pkgPath = path.join(projectRoot, "package.json");
+    if (!fs.existsSync(pkgPath)) {
+        throw new Error("package.json not found.");
+    }
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    const depNames = Object.keys(deps);
+    const results = [];
+    // 1. Look for similar packages (potential duplicates)
+    const similarityGroups = {
+        "CSS/Styling": ["tailwind", "panda", "styled-components", "emotion", "sass"],
+        "Testing": ["vitest", "jest", "mocha", "jasmine"],
+        "Fetching": ["axios", "ky", "fetch"]
+    };
+    for (const [group, patterns] of Object.entries(similarityGroups)) {
+        const found = depNames.filter(d => patterns.some(p => d.includes(p)));
+        if (found.length > 1) {
+            results.push(`[WARN]  Potential redundancy in [${group}]: Found ${found.join(", ")}`);
+        }
+    }
+    // 2. Scan for "any" usage in package names (bad practice markers)
+    const legacyDeps = depNames.filter(d => d.includes("legacy") || d.includes("compat"));
+    if (legacyDeps.length > 0) {
+        results.push(`[INFO]  Legacy compatibility packages detected: ${legacyDeps.join(", ")}`);
+    }
+    return {
+        content: [{
+                type: "text",
+                text: results.length > 0
+                    ? `Dependency Audit Results:\n\n${results.join("\n")}`
+                    : "[OK] Dependencies look clean and consolidated."
+            }]
+    };
+}

package/framework-mcp/dist/framework-mcp/src/tools/framework/get_status.js

@@ -0,0 +1,5 @@
+import { safeExec } from "../../utils/cli.js";
+export function handleGetFrameworkStatus(projectRoot, args) {
+    const output = safeExec("npx", ["atabey", "status"], projectRoot, args.timeout);
+    return { content: [{ type: "text", text: output }] };
+}

package/framework-mcp/dist/framework-mcp/src/tools/framework/orchestrate.js

@@ -0,0 +1,5 @@
+import { safeExec } from "../../utils/cli.js";
+export function handleOrchestrateLoop(projectRoot, args) {
+    const output = safeExec("npx", ["atabey", "orchestrate"], projectRoot, args.timeout);
+    return { content: [{ type: "text", text: output }] };
+}

package/framework-mcp/dist/framework-mcp/src/tools/framework/run_tests.js

@@ -0,0 +1,27 @@
+import { execSync } from "child_process";
+import { getBackendLanguage, getDefaultTestCommand } from "../../utils/cli.js";
+/**
+ * Executes project tests and returns results for agent analysis.
+ */
+export function handleRunTests(projectRoot, args) {
+    const language = getBackendLanguage(projectRoot);
+    const testCommand = args.command || getDefaultTestCommand(language);
+    try {
+        const output = execSync(testCommand, { cwd: projectRoot, encoding: "utf8", stdio: "pipe" });
+        return {
+            content: [{ type: "text", text: `[OK] Tests passed successfully for ${language}!\n\n${output}` }]
+        };
+    }
+    catch (error) {
+        const err = error;
+        const stderr = err.stderr?.toString() || "";
+        const stdout = err.stdout?.toString() || "";
+        return {
+            isError: true,
+            content: [{
+                    type: "text",
+                    text: `[ERROR] Tests FAILED for ${language}!\n\n--- STDOUT ---\n${stdout}\n\n--- STDERR ---\n${stderr}`
+                }]
+        };
+    }
+}

package/framework-mcp/dist/framework-mcp/src/tools/framework/submit_plan.js

@@ -0,0 +1,13 @@
+import { safeExec } from "../../utils/cli.js";
+export function handleSubmitPlan(projectRoot, args) {
+    if (!args.tasks || !Array.isArray(args.tasks)) {
+        return {
+            isError: true,
+            content: [{ type: "text", text: "[ERROR] Error: 'tasks' array is required for submit_plan." }]
+        };
+    }
+    const planJson = JSON.stringify(args.tasks);
+    // Escape for shell if necessary, but safeExec handles arguments as an array
+    const output = safeExec("npx", ["atabey", "plan:submit", planJson], projectRoot);
+    return { content: [{ type: "text", text: output }] };
+}

package/framework-mcp/dist/framework-mcp/src/tools/framework/update_contract_hash.js

@@ -0,0 +1,5 @@
+import { safeExec } from "../../utils/cli.js";
+export function handleUpdateContractHash(projectRoot, args) {
+    const output = safeExec("npx", ["atabey", "update-contract"], projectRoot, args.timeout);
+    return { content: [{ type: "text", text: output }] };
+}

package/framework-mcp/dist/framework-mcp/src/tools/framework/update_memory.js

@@ -0,0 +1,8 @@
+import { safeExec } from "../../utils/cli.js";
+export function handleUpdateProjectMemory(projectRoot, args) {
+    const section = args.section;
+    const content = args.content;
+    // Using execFileSync with array args prevents command injection
+    safeExec("npx", ["atabey", "update_project_memory", section, content], projectRoot);
+    return { content: [{ type: "text", text: `[OK] Section ${section} updated.` }] };
+}

package/framework-mcp/dist/framework-mcp/src/tools/gateway/llm_gateway_query.js

@@ -0,0 +1,137 @@
+/**
+ * ATABEY MCP Tool — LLM Gateway Query
+ *
+ * Sends a chat completion request through the ATABEY LLM Gateway.
+ * The gateway automatically selects the best provider based on the
+ * configured load balancing strategy (failover, round-robin, cost-optimized, etc.)
+ *
+ * This tool allows ANY MCP-connected AI (Gemini CLI, Claude CLI, Cursor, Grok, etc.)
+ * to route LLM requests through the gateway to any supported provider.
+ *
+ * The gateway module is loaded dynamically from the project root at runtime,
+ * not at compile time (since it lives outside the MCP workspace).
+ */
+import path from "path";
+/**
+ * Dynamically load the LLM Gateway from the project root.
+ * Falls back gracefully if the gateway module is not available.
+ */
+async function loadGateway(projectRoot) {
+    try {
+        const gatewayPath = path.join(projectRoot, "dist/src/modules/gateway/index.js");
+        const mod = await import(gatewayPath);
+        return mod.gateway;
+    }
+    catch {
+        try {
+            // Fallback: try tsx resolution for development
+            const gatewayPath = path.join(projectRoot, "src/modules/gateway/index.ts");
+            const mod = await import(gatewayPath);
+            return mod.gateway;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/**
+ * Handle llm_gateway_query tool call.
+ * Routes the request through the LLM Gateway with load balancing.
+ */
+export async function handleLLMGatewayQuery(projectRoot, args) {
+    const startTime = Date.now();
+    try {
+        // Load gateway dynamically
+        const gateway = await loadGateway(projectRoot);
+        if (!gateway) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: false,
+                            error: "LLM Gateway is not initialized. The project may need to be built first. " +
+                                "Run: npm run build:core",
+                            solution: "Gateway module not found at dist/src/modules/gateway/index.js. " +
+                                "Ensure the main package is built and ATABEY_PROJECT_ROOT is set correctly.",
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        // Build gateway request
+        const gatewayRequest = {
+            messages: args.messages.map(m => ({
+                role: m.role,
+                content: m.content,
+            })),
+            system: args.system,
+            model: args.model,
+            temperature: args.temperature ?? 0.7,
+            maxTokens: args.maxTokens ?? 4096,
+            traceId: args.traceId || `MCP-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`,
+        };
+        // Provider override
+        if (args.provider) {
+            gatewayRequest.provider = args.provider;
+        }
+        // Strategy override
+        if (args.strategy) {
+            gatewayRequest.strategy = args.strategy;
+        }
+        // Send through gateway
+        const response = await gateway.chat(gatewayRequest);
+        const elapsed = Date.now() - startTime;
+        if (response.success) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            success: true,
+                            content: response.content,
+                            provider: response.provider,
+                            model: response.model,
+                            usage: response.usage,
+                            latencyMs: response.latencyMs,
+                            cost: response.cost,
+                            traceId: response.traceId,
+                            elapsed,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: false,
+                        error: response.content,
+                        provider: response.provider,
+                        traceId: response.traceId,
+                        elapsed,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: false,
+                        error: `Gateway query failed: ${error.message}`,
+                        elapsed: Date.now() - startTime,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+}

package/framework-mcp/dist/framework-mcp/src/tools/gateway/llm_gateway_status.js

@@ -0,0 +1,90 @@
+/**
+ * ATABEY MCP Tool — LLM Gateway Status
+ *
+ * Returns the current status of the LLM Gateway, including provider health,
+ * current load balancing strategy, usage statistics, and budget info.
+ *
+ * Useful for monitoring and debugging gateway behavior without CLI access.
+ */
+import path from "path";
+/**
+ * Dynamically load the LLM Gateway from the project root.
+ */
+async function loadGateway(projectRoot) {
+    try {
+        const gatewayPath = path.join(projectRoot, "dist/src/modules/gateway/index.js");
+        const mod = await import(gatewayPath);
+        return mod.gateway;
+    }
+    catch {
+        try {
+            const gatewayPath = path.join(projectRoot, "src/modules/gateway/index.ts");
+            const mod = await import(gatewayPath);
+            return mod.gateway;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/**
+ * Handle llm_gateway_status tool call.
+ */
+export async function handleLLMGatewayStatus(projectRoot, args) {
+    const detail = args.detail || "overview";
+    try {
+        const gateway = await loadGateway(projectRoot);
+        if (!gateway) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            status: "unavailable",
+                            message: "LLM Gateway is not initialized. " +
+                                "Build the project first with: npm run build:core",
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        const result = {
+            status: "active",
+            strategy: gateway.loadBalancer.getStrategy(),
+        };
+        if (detail === "providers" || detail === "overview") {
+            result.providers = gateway.getProviderHealth();
+        }
+        if (detail === "stats" || detail === "overview") {
+            result.stats = gateway.getStats();
+        }
+        if (detail === "overview" || detail === "stats") {
+            const budget = gateway.costTracker.getBudgetStatus();
+            if (budget) {
+                result.budget = budget;
+            }
+        }
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        return {
+            isError: true,
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        status: "error",
+                        error: `Failed to get gateway status: ${error.message}`,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+}

package/framework-mcp/dist/framework-mcp/src/tools/index.js

@@ -0,0 +1,126 @@
+import { handleAcquireLock, handleReleaseLock } from "./control_plane/locking.js";
+import { handleRegisterAgent } from "./control_plane/registry.js";
+import { TOOLS } from "./definitions.js";
+import { handleBatchSurgicalEdit } from "./file_system/batch_surgical_edit.js";
+import { handlePatchFile } from "./file_system/patch_file.js";
+import { handleReadFile } from "./file_system/read_file.js";
+import { handleReplaceText } from "./file_system/replace_text.js";
+import { handleWriteFile } from "./file_system/write_file.js";
+import { handleAuditDependencies } from "./framework/audit_deps.js";
+import { handleGetFrameworkStatus } from "./framework/get_status.js";
+import { handleOrchestrateLoop } from "./framework/orchestrate.js";
+import { handleRunTests } from "./framework/run_tests.js";
+import { handleSubmitPlan } from "./framework/submit_plan.js";
+import { handleUpdateContractHash } from "./framework/update_contract_hash.js";
+import { handleUpdateProjectMemory } from "./framework/update_memory.js";
+import { handleLLMGatewayQuery } from "./gateway/llm_gateway_query.js";
+import { handleLLMGatewayStatus } from "./gateway/llm_gateway_status.js";
+import { handleDeleteKnowledge } from "./memory/delete_knowledge.js";
+import { handleGetMemoryInsights } from "./memory/get_insights.js";
+import { handleReadProjectMemory } from "./memory/read_memory.js";
+import { handleSearchKnowledge } from "./memory/search_knowledge.js";
+import { handleStoreKnowledge } from "./memory/store_knowledge.js";
+import { handleAskHuman } from "./messaging/ask_human.js";
+import { handleLogAgentAction } from "./messaging/log_action.js";
+import { handleSendAgentMessage } from "./messaging/send_message.js";
+import { handleCheckPorts } from "./observability/check_ports.js";
+import { handleGetSystemHealth } from "./observability/get_health.js";
+import { handleAnalyzeCodeQuality } from "./quality/analyze_code_quality.js";
+import { handleCheckArchitectureCompliance } from "./quality/check_architecture_compliance.js";
+import { handleCheckLint } from "./quality/check_lint.js";
+import * as schemas from "./schemas.js";
+import { handleGetProjectGaps } from "./search/get_gaps.js";
+import { handleGetProjectMap } from "./search/get_map.js";
+import { handleGrepSearch } from "./search/grep_search.js";
+import { handleListDir } from "./search/list_dir.js";
+import { handleRunCommand } from "./shell/run_command.js";
+// Map of tool names to their handler functions
+const bind = (fn) => {
+    return (root, args) => fn(root, args);
+};
+export const toolHandlers = {
+    read_file: bind(handleReadFile),
+    view_file: bind(handleReadFile), // Alias
+    list_dir: bind(handleListDir),
+    grep_search: bind(handleGrepSearch),
+    get_project_map: bind(handleGetProjectMap),
+    get_project_gaps: bind(handleGetProjectGaps),
+    write_file: bind(handleWriteFile),
+    replace_text: bind(handleReplaceText),
+    batch_surgical_edit: bind(handleBatchSurgicalEdit),
+    patch_file: bind(handlePatchFile),
+    get_framework_status: bind(handleGetFrameworkStatus),
+    read_project_memory: bind(handleReadProjectMemory),
+    get_memory_insights: bind(handleGetMemoryInsights),
+    store_knowledge: bind(handleStoreKnowledge),
+    search_knowledge: bind(handleSearchKnowledge),
+    delete_knowledge: bind(handleDeleteKnowledge),
+    update_project_memory: bind(handleUpdateProjectMemory),
+    audit_dependencies: bind(handleAuditDependencies),
+    run_tests: bind(handleRunTests),
+    get_system_health: bind(handleGetSystemHealth),
+    check_active_ports: bind(handleCheckPorts),
+    orchestrate_loop: bind(handleOrchestrateLoop),
+    submit_plan: bind(handleSubmitPlan),
+    send_agent_message: bind(handleSendAgentMessage),
+    log_agent_action: bind(handleLogAgentAction),
+    ask_human: bind(handleAskHuman),
+    update_contract_hash: bind(handleUpdateContractHash),
+    acquire_lock: bind(handleAcquireLock),
+    release_lock: bind(handleReleaseLock),
+    register_agent: bind(handleRegisterAgent),
+    run_shell_command: bind(handleRunCommand),
+    check_lint: bind(handleCheckLint),
+    analyze_code_quality: bind(handleAnalyzeCodeQuality),
+    check_architecture_compliance: bind(handleCheckArchitectureCompliance),
+    // LLM Gateway
+    llm_gateway_query: bind(handleLLMGatewayQuery),
+    llm_gateway_status: bind(handleLLMGatewayStatus),
+};
+// Map of tool names to their Zod validation schemas
+export const toolSchemas = {
+    // File System
+    read_file: schemas.ReadFileSchema,
+    view_file: schemas.ReadFileSchema,
+    write_file: schemas.WriteFileSchema,
+    replace_text: schemas.ReplaceTextSchema,
+    batch_surgical_edit: schemas.BatchSurgicalEditSchema,
+    patch_file: schemas.PatchFileSchema,
+    // Search & Exploration
+    list_dir: schemas.ListDirSchema,
+    grep_search: schemas.GrepSearchSchema,
+    get_project_map: schemas.GetProjectMapSchema,
+    get_project_gaps: schemas.GetProjectGapsSchema,
+    // Framework & System
+    run_shell_command: schemas.RunShellCommandSchema,
+    run_tests: schemas.RunTestsSchema,
+    get_system_health: schemas.GetSystemHealthSchema,
+    check_active_ports: schemas.CheckPortsSchema,
+    get_framework_status: schemas.GetFrameworkStatusSchema,
+    read_project_memory: schemas.ReadProjectMemorySchema,
+    get_memory_insights: schemas.GetMemoryInsightsSchema,
+    store_knowledge: schemas.StoreKnowledgeSchema,
+    search_knowledge: schemas.SearchKnowledgeSchema,
+    delete_knowledge: schemas.DeleteKnowledgeSchema,
+    update_project_memory: schemas.UpdateProjectMemorySchema,
+    orchestrate_loop: schemas.OrchestrateLoopSchema,
+    submit_plan: schemas.SubmitPlanSchema,
+    update_contract_hash: schemas.UpdateContractHashSchema,
+    audit_dependencies: schemas.AuditDependenciesSchema,
+    check_lint: schemas.CheckLintSchema,
+    // Control Plane
+    acquire_lock: schemas.AcquireLockSchema,
+    release_lock: schemas.ReleaseLockSchema,
+    register_agent: schemas.RegisterAgentSchema,
+    // Messaging (Hermes)
+    send_agent_message: schemas.SendAgentMessageSchema,
+    log_agent_action: schemas.LogAgentActionSchema,
+    ask_human: schemas.AskHumanSchema,
+    // Code Quality
+    analyze_code_quality: schemas.AnalyzeCodeQualitySchema,
+    check_architecture_compliance: schemas.CheckArchitectureComplianceSchema,
+    // LLM Gateway
+    llm_gateway_query: schemas.LLMGatewayQuerySchema,
+    llm_gateway_status: schemas.LLMGatewayStatusSchema,
+};
+export { TOOLS };