atabey 0.0.16 → 0.0.18

package/framework-mcp/dist/framework-mcp/src/tools/memory/read_memory.js

@@ -1,28 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { resolveFrameworkDir } from "../../utils/security.js";
-/**
- * Reads the project's central memory (PROJECT_MEMORY.md).
- * This is the "brain" of the project.
- */
-export function handleReadProjectMemory(projectRoot, _args) {
-    try {
-        const frameworkDir = resolveFrameworkDir(projectRoot);
-        const memoryPath = path.join(projectRoot, frameworkDir, "memory/PROJECT_MEMORY.md");
-        if (!fs.existsSync(memoryPath)) {
-            return {
-                content: [{ type: "text", text: "[INFO] Project memory file not found. It might be a new project." }]
-            };
-        }
-        const content = fs.readFileSync(memoryPath, "utf8");
-        return {
-            content: [{ type: "text", text: content }]
-        };
-    }
-    catch (e) {
-        return {
-            isError: true,
-            content: [{ type: "text", text: `Failed to read project memory: ${String(e)}` }]
-        };
-    }
-}

package/framework-mcp/dist/framework-mcp/src/tools/memory/search_knowledge.js

@@ -1,48 +0,0 @@
-import { CoreMemory } from "../../../../src/modules/memory/core.js";
-export async function handleSearchKnowledge(root, args) {
-    try {
-        await CoreMemory.init();
-        const results = await CoreMemory.recall(args.query, {
-            category: args.category,
-            limit: args.limit
-        });
-        if (results.length === 0) {
-            return {
-                content: [{
-                        type: "text",
-                        text: "[INFO] No relevant knowledge found."
-                    }]
-            };
-        }
-        const output = results.map(r => {
-            const meta = r.entry.metadata;
-            return `---
-ID: ${r.entry.id}
-Score: ${r.score.toFixed(4)}
-Category: ${meta.category}
-Tags: ${meta.tags.join(", ") || "none"}
-File: ${meta.filePath || "N/A"}
-Trace: ${meta.traceId || "N/A"}
-
-Content:
-${r.entry.content}
-`;
-        }).join("\n");
-        return {
-            content: [{
-                    type: "text",
-                    text: `[SUCCESS] Found ${results.length} relevant entries:\n\n${output}`
-                }]
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            isError: true,
-            content: [{
-                    type: "text",
-                    text: `[ERROR] Search failed: ${message}`
-                }]
-        };
-    }
-}

package/framework-mcp/dist/framework-mcp/src/tools/memory/store_knowledge.js

@@ -1,30 +0,0 @@
-import { CoreMemory } from "../../../../src/modules/memory/core.js";
-import { asTraceID } from "../../../../src/shared/types.js";
-export async function handleStoreKnowledge(root, args) {
-    try {
-        await CoreMemory.init();
-        const id = await CoreMemory.remember({
-            content: args.content,
-            category: args.category,
-            tags: args.tags,
-            filePath: args.filePath,
-            traceId: args.traceId ? asTraceID(args.traceId) : undefined
-        });
-        return {
-            content: [{
-                    type: "text",
-                    text: `[SUCCESS] Knowledge stored with ID: ${id}`
-                }]
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            isError: true,
-            content: [{
-                    type: "text",
-                    text: `[ERROR] Failed to store knowledge: ${message}`
-                }]
-        };
-    }
-}

package/framework-mcp/dist/framework-mcp/src/tools/messaging/approve_operation.js

@@ -1,80 +0,0 @@
-import { approveOperation, getPendingApprovals, rejectOperation } from "../../utils/human-in-loop.js";
-/**
- * MCP Tool: approve_operation
- *
- * In AI CLI (Claude Code, Gemini CLI), running "atabey approve <traceId>"
- * is not possible — anything typed in chat is treated as a message, not a CLI command.
- *
- * This tool moves the risk gate approval flow directly into an MCP tool call:
- *
- * 1. Atabey blocks a high-risk operation
- * 2. Tells the developer: "call the approve_operation tool"
- * 3. AI calls this tool → operation is approved/rejected
- *
- * Developer never has to switch to terminal.
- */
-export async function handleApproveOperation(_root, args) {
-    const { action, traceId, reason } = args;
-    // LIST: Show pending approvals
-    if (action === "list") {
-        const pending = getPendingApprovals();
-        if (pending.length === 0) {
-            return {
-                content: [{ type: "text", text: "[APPROVALS] No pending operations waiting for approval." }],
-            };
-        }
-        const lines = [
-            `[APPROVALS] ${pending.length} pending operation(s):\n`,
-            ...pending.map(req => [
-                "  ─────────────────────────────────────",
-                `  Trace ID:   ${req.traceId}`,
-                `  Tool:       ${req.toolName}`,
-                `  Agent:      ${req.agent}`,
-                `  Risk Score: ${req.riskScore}/100 (${req.riskLevel})`,
-                `  Reason:     ${req.reason}`,
-                `  Expires:    ${new Date(req.expiresAt).toISOString()}`,
-            ].join("\n")),
-            "",
-            "To approve: call approve_operation with action=\"approve\" and traceId=\"<id>\"",
-            "To reject:  call approve_operation with action=\"reject\" and traceId=\"<id>\"",
-        ];
-        return {
-            content: [{ type: "text", text: lines.join("\n") }],
-        };
-    }
-    // APPROVE or REJECT: traceId is required
-    if (!traceId) {
-        return {
-            isError: true,
-            content: [{ type: "text", text: `[ERROR] traceId is required for "${action}" action.` }],
-        };
-    }
-    if (action === "approve") {
-        const result = approveOperation(traceId, args.passcode, args.userRole);
-        return {
-            content: [{
-                    type: "text",
-                    text: result.success
-                        ? `[APPROVED] ✅ ${result.message}\nYou may retry the blocked operation now.`
-                        : `[ERROR] ${result.message}`,
-                }],
-            isError: !result.success,
-        };
-    }
-    if (action === "reject") {
-        const result = rejectOperation(traceId);
-        return {
-            content: [{
-                    type: "text",
-                    text: result.success
-                        ? `[REJECTED] ⛔ ${result.message}${reason ? `\nReason: ${reason}` : ""}`
-                        : `[ERROR] ${result.message}`,
-                }],
-            isError: !result.success,
-        };
-    }
-    return {
-        isError: true,
-        content: [{ type: "text", text: `[ERROR] Unknown action: "${String(action)}". Use "approve", "reject", or "list".` }],
-    };
-}

package/framework-mcp/dist/framework-mcp/src/tools/messaging/ask_human.js

@@ -1,99 +0,0 @@
-import fs from "fs";
-import path from "path";
-/**
- * ─── ASK HUMAN — File Bridge ─────────────────────────────────────────
- *
- * AI CLIs (Claude Code, Gemini CLI) start the MCP server as a stdio subprocess.
- * In this subprocess, stdin is isTTY=false (used for MCP JSON-RPC).
- *
- * Solution: File-based Q&A bridge.
- * 1. Question → written to .atabey/hitl/question.txt
- * 2. Developer answers via `atabey hitl` command
- * 3. Answer → written to .atabey/hitl/answer.txt
- * 4. This handler reads the answer and returns it to the AI
- *
- * Dashboard: Can also be answered via /api/approvals endpoint on the web dashboard.
- */
-export async function handleAskHuman(root, args) {
-    const timeoutSeconds = args.timeoutSeconds ?? 120;
-    const hitlDir = path.join(root, ".atabey", "hitl");
-    const questionFile = path.join(hitlDir, "question.txt");
-    const answerFile = path.join(hitlDir, "answer.txt");
-    try {
-        // Ensure hitl directory exists
-        fs.mkdirSync(hitlDir, { recursive: true });
-        // Clear any stale answer file
-        if (fs.existsSync(answerFile)) {
-            fs.unlinkSync(answerFile);
-        }
-        // Write the question with metadata
-        const questionPayload = JSON.stringify({
-            timestamp: new Date().toISOString(),
-            question: args.question,
-            timeoutAt: new Date(Date.now() + timeoutSeconds * 1000).toISOString(),
-        }, null, 2);
-        fs.writeFileSync(questionFile, questionPayload);
-        // Write human-readable prompt file alongside
-        fs.writeFileSync(path.join(hitlDir, "PENDING.txt"), [
-            "═══════════════════════════════════════════════════",
-            " [ATABEY] AGENT WAITING FOR YOUR ANSWER",
-            "═══════════════════════════════════════════════════",
-            "",
-            `QUESTION: ${args.question}`,
-            "",
-            "To answer, run in your terminal:",
-            "  atabey hitl answer \"your answer here\"",
-            "",
-            "Or use the dashboard: http://localhost:5858",
-            "═══════════════════════════════════════════════════",
-        ].join("\n"));
-        process.stderr.write(`[HITL] Question written to ${questionFile}\n`);
-        process.stderr.write("[HITL] Run: atabey hitl answer \"your answer\"\n");
-        // Poll for answer file
-        const pollIntervalMs = 1000;
-        const maxAttempts = timeoutSeconds;
-        for (let attempt = 0; attempt < maxAttempts; attempt++) {
-            await new Promise(resolve => setTimeout(resolve, pollIntervalMs));
-            if (fs.existsSync(answerFile)) {
-                const answer = fs.readFileSync(answerFile, "utf8").trim();
-                // Clean up
-                try {
-                    fs.unlinkSync(questionFile);
-                    fs.unlinkSync(answerFile);
-                    const pendingFile = path.join(hitlDir, "PENDING.txt");
-                    if (fs.existsSync(pendingFile))
-                        fs.unlinkSync(pendingFile);
-                }
-                catch { /* cleanup is best-effort */ }
-                process.stderr.write("[HITL] Answer received.\n");
-                return {
-                    content: [{ type: "text", text: `[HUMAN RESPONSE] ${answer}` }],
-                };
-            }
-        }
-        // Timeout — clean up question file
-        try {
-            if (fs.existsSync(questionFile))
-                fs.unlinkSync(questionFile);
-            const pendingFile = path.join(hitlDir, "PENDING.txt");
-            if (fs.existsSync(pendingFile))
-                fs.unlinkSync(pendingFile);
-        }
-        catch { /* cleanup is best-effort */ }
-        return {
-            content: [{
-                    type: "text",
-                    text: `[HITL TIMEOUT] No answer received within ${timeoutSeconds}s.\n` +
-                        `Question was: "${args.question}"\n` +
-                        "To answer pending questions, run: atabey hitl answer \"your answer\"",
-                }],
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return {
-            isError: true,
-            content: [{ type: "text", text: `[ERROR] ask_human failed: ${message}` }],
-        };
-    }
-}

package/framework-mcp/dist/framework-mcp/src/tools/messaging/log_action.js

@@ -1,22 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { resolveFrameworkDir } from "../../utils/security.js";
-export function handleLogAgentAction(projectRoot, args) {
-    const { agent, action, traceId, status, summary } = args;
-    const findings = args.findings ? args.findings.split(",").map(f => f.trim()) : [];
-    const frameworkDir = resolveFrameworkDir(projectRoot);
-    const agentName = agent.replace("@", "");
-    const logPath = path.join(projectRoot, frameworkDir, "logs", `${agentName}.json`);
-    const logEntry = {
-        timestamp: new Date().toISOString(),
-        agent,
-        action,
-        requestId: traceId,
-        status,
-        summary,
-        findings
-    };
-    fs.mkdirSync(path.dirname(logPath), { recursive: true });
-    fs.appendFileSync(logPath, JSON.stringify(logEntry) + "\n");
-    return { content: [{ type: "text", text: `[OK] Action logged for ${agent} to ${path.join(frameworkDir, "logs", `${agentName}.json`)}` }] };
-}

package/framework-mcp/dist/framework-mcp/src/tools/messaging/send_message.js

@@ -1,110 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { resolveFrameworkDir } from "../../utils/security.js";
-import { Metrics } from "../../utils/metrics.js";
-import { verifyMessagingPermission, resolveActiveAgent } from "../../utils/permissions.js";
-export async function handleSendAgentMessage(projectRoot, args) {
-    const { to, category, content, traceId, parentId, requiresApproval } = args;
-    const frameworkDir = resolveFrameworkDir(projectRoot);
-    const absoluteFrameworkPath = path.isAbsolute(frameworkDir)
-        ? frameworkDir
-        : path.resolve(projectRoot, frameworkDir);
-    const activeAgent = resolveActiveAgent(absoluteFrameworkPath);
-    const from = activeAgent || args.from || "@mcp";
-    if (!to || !category || !content || !traceId) {
-        const err = "Missing required messaging arguments (to, category, content, or traceId).";
-        Metrics.logError(projectRoot, from, "send_agent_message", err);
-        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
-    }
-    // ENFORCE AGENT TIER MESSAGING RBAC
-    // Prevents core agents from delegating to recon agents, bypassing the quality gate.
-    // This is the AI Governance enforcement point for Claude Code, Gemini CLI, Cursor.
-    try {
-        verifyMessagingPermission(from, to);
-    }
-    catch (e) {
-        const err = String(e instanceof Error ? e.message : e);
-        Metrics.logError(projectRoot, from, "send_agent_message", err);
-        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
-    }
-    const messagesDir = path.join(projectRoot, frameworkDir, "messages");
-    const agentName = to.replace("@", "");
-    const messagePath = path.join(messagesDir, `${agentName}.json`);
-    const lockPath = path.join(messagesDir, `${agentName}.lock`);
-    // Hermes Lock Protocol: Retry 20 times with 500ms delay
-    let retries = 20;
-    let acquired = false;
-    while (retries > 0) {
-        try {
-            if (fs.existsSync(lockPath)) {
-                try {
-                    const stats = fs.statSync(lockPath);
-                    if (Date.now() - stats.mtimeMs > 15000) {
-                        const tempLockPath = `${lockPath}.${Math.random().toString(36).substring(2)}.old`;
-                        fs.renameSync(lockPath, tempLockPath);
-                        fs.unlinkSync(tempLockPath);
-                    }
-                }
-                catch {
-                    // ignore if concurrently unlinked or renamed
-                }
-            }
-            fs.mkdirSync(messagesDir, { recursive: true });
-            fs.writeFileSync(lockPath, `Locked by ${from} at ${new Date().toISOString()}`, { flag: "wx" });
-            acquired = true;
-            break;
-        }
-        catch (err) {
-            const error = err;
-            if (error.code === "EEXIST") {
-                retries--;
-                if (retries > 0) {
-                    await new Promise((resolve) => setTimeout(resolve, 500));
-                }
-            }
-            else {
-                return { content: [{ type: "text", text: `[ERROR] Unexpected lock acquisition error: ${error.message || String(err)}` }], isError: true };
-            }
-        }
-    }
-    if (!acquired) {
-        const err = `Could not send message to ${to}: Hermes lock is busy.`;
-        Metrics.logError(projectRoot, from, "send_agent_message", err);
-        return { content: [{ type: "text", text: `[ERROR] ${err}` }], isError: true };
-    }
-    try {
-        const defaultPriority = (category === "ALERT" || category === "ACTION") ? "HIGH" : "NORMAL";
-        const finalRequiresApproval = requiresApproval !== undefined
-            ? requiresApproval
-            : category === "ALERT";
-        const message = {
-            timestamp: new Date().toISOString(),
-            from,
-            to,
-            category,
-            traceId,
-            parentId,
-            content,
-            priority: args.priority || defaultPriority,
-            status: "PENDING",
-            requiresApproval: finalRequiresApproval
-        };
-        fs.appendFileSync(messagePath, JSON.stringify(message) + "\n");
-        return { content: [{ type: "text", text: `[OK] Message sent to ${to} (from: ${from})` }] };
-    }
-    catch (e) {
-        const err = `Failed to write message: ${String(e)}`;
-        Metrics.logError(projectRoot, from, "send_agent_message", err);
-        return { isError: true, content: [{ type: "text", text: `[ERROR] ${err}` }] };
-    }
-    finally {
-        if (acquired && fs.existsSync(lockPath)) {
-            try {
-                fs.unlinkSync(lockPath);
-            }
-            catch {
-                // ignore
-            }
-        }
-    }
-}

package/framework-mcp/dist/framework-mcp/src/tools/observability/check_ports.js

@@ -1,42 +0,0 @@
-import { spawnSync } from "child_process";
-/**
- * Checks for active network ports and their status.
- * Uses spawnSync instead of execSync to prevent shell injection.
- */
-export function handleCheckPorts(projectRoot, args) {
-    const rawFilter = args.filter || "";
-    // Sanitize filter to prevent command injection (allow only alphanumeric, dots, colons, dashes, underscores)
-    const filter = rawFilter.replace(/[^a-zA-Z0-9.:_-]/g, "");
-    try {
-        let output;
-        if (process.platform === "win32") {
-            const result = spawnSync("netstat", ["-ano"], { encoding: "utf8" });
-            if (result.error)
-                throw result.error;
-            const lines = (result.stdout || "").split("\n").filter(l => l.includes("LISTENING"));
-            output = filter
-                ? lines.filter(l => l.includes(filter)).join("\n")
-                : lines.join("\n");
-        }
-        else {
-            const result = spawnSync("lsof", ["-i", "-P", "-n"], { encoding: "utf8" });
-            if (result.error)
-                throw result.error;
-            const lines = (result.stdout || "").split("\n").filter(l => l.includes("LISTEN"));
-            output = filter
-                ? lines.filter(l => l.includes(filter)).join("\n")
-                : lines.join("\n");
-        }
-        return {
-            content: [{
-                    type: "text",
-                    text: `[SIGNAL] **Active Listening Ports:**\n\n${output || "No active listening ports found matching filter."}`
-                }]
-        };
-    }
-    catch (_e) {
-        return {
-            content: [{ type: "text", text: "[INFO] No active ports found or command failed (this is normal if nothing is listening)." }]
-        };
-    }
-}

package/framework-mcp/dist/framework-mcp/src/tools/observability/get_health.js

@@ -1,19 +0,0 @@
-import os from "os";
-/**
- * Retrieves system health metrics including CPU load and memory usage.
- */
-export function handleGetSystemHealth(_projectRoot, _args) {
-    const totalMem = os.totalmem();
-    const freeMem = os.freemem();
-    const usedMem = totalMem - freeMem;
-    const memUsagePercent = ((usedMem / totalMem) * 100).toFixed(2);
-    const loadAvg = os.loadavg(); // [1, 5, 15] minute averages
-    const healthReport = `[SERVER] **System Health Report**
-- **Memory:** ${memUsagePercent}% used (${(usedMem / 1024 / 1024 / 1024).toFixed(2)} GB / ${(totalMem / 1024 / 1024 / 1024).toFixed(2)} GB)
-- **CPU Load (1m, 5m, 15m):** ${loadAvg.map(l => l.toFixed(2)).join(", ")}
-- **Platform:** ${os.platform()} (${os.release()})
-- **Uptime:** ${(os.uptime() / 3600).toFixed(2)} hours`;
-    return {
-        content: [{ type: "text", text: healthReport }]
-    };
-}

package/framework-mcp/dist/framework-mcp/src/tools/quality/analyze_code_quality.js

@@ -1,114 +0,0 @@
-import { execSync } from "child_process";
-import fs from "fs";
-import path from "path";
-import { analyzePathQuality } from "../../utils/quality.js";
-/**
- * Code quality analysis tool for Atabey MCP.
- *
- * Performs three checks on the provided source code:
- * - TypeScript type checking (checkTypes)
- * - Lint checking (checkLint)
- * - Code complexity analysis (checkComplexity)
- */
-export function handleAnalyzeCodeQuality(projectRoot, args) {
-    // Validate path parameter to prevent command injection
-    if (!/^[a-zA-Z0-9_./-]+$/.test(args.path)) {
-        return {
-            isError: true,
-            content: [{ type: "text", text: `[ERROR] Invalid path characters detected: ${args.path}` }]
-        };
-    }
-    const targetPath = path.resolve(projectRoot, args.path);
-    if (!fs.existsSync(targetPath)) {
-        return {
-            isError: true,
-            content: [{ type: "text", text: `[ERROR] Path does not exist: ${args.path}` }]
-        };
-    }
-    const results = ["# Code Quality Analysis Report", "", `**Target:** ${args.path}`, `**Timestamp:** ${new Date().toISOString()}`, ""];
-    let hasErrors = false;
-    // 1. TypeScript Type Check
-    if (args.checkTypes !== false) {
-        try {
-            execSync("npx tsc --noEmit", {
-                cwd: projectRoot,
-                stdio: "pipe",
-                timeout: 30000,
-                encoding: "utf8"
-            });
-            results.push("## ✅ TypeScript Check: PASSED");
-            results.push("No type errors found.");
-        }
-        catch (err) {
-            hasErrors = true;
-            const error = err;
-            const stderr = error.stderr || error.stdout || error.message || "Unknown error";
-            results.push("## ❌ TypeScript Check: FAILED");
-            results.push("```");
-            results.push(stderr.substring(0, 2000));
-            results.push("```");
-        }
-        results.push("");
-    }
-    // 2. Lint Check
-    if (args.checkLint !== false) {
-        try {
-            const lintOutput = execSync("npx eslint --format compact " + args.path, {
-                cwd: projectRoot,
-                stdio: "pipe",
-                timeout: 30000,
-                encoding: "utf8"
-            });
-            const lintStr = lintOutput.trim();
-            if (lintStr) {
-                results.push("## ⚠️ Lint Check: ISSUES FOUND");
-                results.push("```");
-                results.push(lintStr.substring(0, 2000));
-                results.push("```");
-            }
-            else {
-                results.push("## ✅ Lint Check: PASSED");
-                results.push("No lint issues found.");
-            }
-        }
-        catch (err) {
-            const error = err;
-            const stderr = error.stderr || error.stdout || error.message || "Unknown error";
-            // ESLint returns non-zero exit code when issues are found
-            if (stderr.includes("ESLint")) {
-                results.push("## ❌ Lint Check: FAILED");
-                results.push("```");
-                results.push(stderr.substring(0, 2000));
-                results.push("```");
-            }
-            else {
-                results.push("## ✅ Lint Check: PASSED (no ESLint config)");
-            }
-        }
-        results.push("");
-    }
-    // 3. Code Complexity Check (basic heuristic)
-    if (args.checkComplexity !== false) {
-        const qualityResult = analyzePathQuality(projectRoot, args.path);
-        const complexityIssues = qualityResult.issues.filter(issue => issue.type === "complexity");
-        if (complexityIssues.length > 0) {
-            hasErrors = true;
-            results.push(`## ⚠️ Code Complexity Issues (${complexityIssues.length})`);
-            complexityIssues.forEach(issue => {
-                results.push(`- ${issue.file}:${issue.line} — ${issue.message}`);
-            });
-        }
-        else {
-            results.push("## ✅ Code Complexity: OK");
-            results.push("No complexity issues found.");
-        }
-        results.push("");
-    }
-    // Summary
-    results.push("---");
-    results.push(`**Overall Status:** ${hasErrors ? "⚠️ Issues Found" : "✅ All Checks Passed"}`);
-    return {
-        content: [{ type: "text", text: results.join("\n") }],
-        isError: hasErrors
-    };
-}