npm - atabey - Versions diffs - 0.0.14 → 0.0.15 - Mend

atabey 0.0.14 → 0.0.15

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 (71) hide show

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

@@ -7,7 +7,7 @@
     <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-B2mYld0c.js"></script>
+    <script type="module" crossorigin src="/assets/index-B_rK57vi.js"></script>
   </head>
   <body>
     <div id="root"></div>

package/framework-mcp/dist/framework-mcp/src/index.js CHANGED Viewed

@@ -16,6 +16,28 @@ import { RESOURCES, handleReadResource } from "./resources/index.js";
 import { TOOLS, toolHandlers, toolSchemas } from "./tools/index.js";
 // ─── Paths ────────────────────────────────────────────────────────
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+// ─── Friendly Startup Validation ──────────────────────────────────
+function validateEnvironment() {
+    // Node.js version check
+    const nodeMajor = parseInt(process.versions.node.split(".")[0], 10);
+    if (nodeMajor < 18) {
+        process.stderr.write(`
+╔══════════════════════════════════════════════════════════╗
+║  ⚠️  Unsupported Node.js version                       ║
+╠══════════════════════════════════════════════════════════╣
+║  Atabey MCP requires Node.js >= 18.0.0                  ║
+║                                                         ║
+║  Current version: ${process.versions.node}                             ║
+║                                                         ║
+║  📋  To fix this:                                       ║
+║     nvm install 18 && nvm use 18   (if using nvm)      ║
+║     brew install node             (if using Homebrew)  ║
+║     https://nodejs.org            (official installer) ║
+╚══════════════════════════════════════════════════════════╝
+`);
+        process.exit(1);
+    }
+}
 function findPackageJson(startDir) {
     let currentDir = startDir;
     while (currentDir !== path.parse(currentDir).root) {
@@ -24,16 +46,68 @@ function findPackageJson(startDir) {
             return pkgPath;
         currentDir = path.dirname(currentDir);
     }
-    throw new Error("Could not find package.json for atabey-mcp");
+    process.stderr.write(`
+╔══════════════════════════════════════════════════════════╗
+║  🚧  Package not found                                 ║
+╠══════════════════════════════════════════════════════════╣
+║  Atabey MCP package.json could not be located.          ║
+║                                                         ║
+║  This usually means:                                    ║
+║    1. The package was not installed correctly           ║
+║    2. Node modules are missing                          ║
+║                                                         ║
+║  📋  To fix this:                                       ║
+║     npm install -g atabey        (global install)      ║
+║     npm install                 (local install)        ║
+║     npm run build               (if developing)        ║
+╚══════════════════════════════════════════════════════════╝
+`);
+    process.exit(1);
 }
+validateEnvironment();
 const pkgPath = findPackageJson(__dirname);
 const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
 const serverVersion = pkg.version;
+// Validate environment variables with friendly messages
 const PROJECT_ROOT = process.env.ATABEY_PROJECT_ROOT || process.cwd();
+if (!process.env.ATABEY_PROJECT_ROOT) {
+    const transportMode = process.env.MCP_TRANSPORT || "unified";
+    if (transportMode !== "stdio") {
+        process.stderr.write(`
+╔══════════════════════════════════════════════════════════╗
+║  💡  Tip: Set ATABEY_PROJECT_ROOT                      ║
+╠══════════════════════════════════════════════════════════╣
+║  In HTTP/SSE mode, it's recommended to explicitly set   ║
+║  the project root to avoid confusion.                   ║
+║                                                         ║
+║  Example:                                               ║
+║    export ATABEY_PROJECT_ROOT=/path/to/your/project    ║
+║                                                         ║
+║  Using current directory: ${process.cwd()}         ║
+╚══════════════════════════════════════════════════════════╝
+`);
+    }
+}
 const FRAMEWORK_DIR = process.env.ATABEY_FRAMEWORK_DIR || path.join(PROJECT_ROOT, ".atabey");
-const UI_DIST_PATH = path.join(__dirname, "../../dist/dashboard");
+const UI_DIST_PATH = path.join(__dirname, "../../dashboard/dist");
 // ─── Ports ────────────────────────────────────────────────────────
 const PORT = parseInt(process.env.MCP_PORT || "5858", 10);
+if (isNaN(PORT) || PORT < 1 || PORT > 65535) {
+    process.stderr.write(`
+╔══════════════════════════════════════════════════════════╗
+║  ❌  Invalid MCP_PORT                                   ║
+╠══════════════════════════════════════════════════════════╣
+║  The port must be a number between 1 and 65535.        ║
+║                                                         ║
+║  You set: MCP_PORT=${process.env.MCP_PORT || "(empty)"}                        ║
+║                                                         ║
+║  📋  To fix this:                                       ║
+║     export MCP_PORT=5858   (default)                   ║
+║     export MCP_PORT=8080   (alternative)               ║
+╚══════════════════════════════════════════════════════════╝
+`);
+    process.exit(1);
+}
 const HOST = process.env.MCP_HOST || "0.0.0.0";
 // ─── MCP Server ───────────────────────────────────────────────────
 const server = new Server({ name: "atabey-mcp", version: serverVersion }, { capabilities: { tools: {}, resources: {} } });
@@ -242,7 +316,6 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         // [AUTO-ROLLBACK] Check write results for governance violations
         if (name === "write_file" || name === "replace_text" || name === "patch_file") {
             try {
-                const responseText = result.content?.filter(b => b.type === "text").map(b => b.text).join(" ") || "";
                 const filePath = maskedArgs.path || "";
                 const content = maskedArgs.content || "";
                 if (filePath && content) {

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

@@ -1,21 +1,21 @@
-import { approveOperation, rejectOperation, getPendingApprovals } from "../../utils/human-in-loop.js";
+import { approveOperation, getPendingApprovals, rejectOperation } from "../../utils/human-in-loop.js";
 /**
- * ─── APPROVE OPERATION — In-Chat Risk Gate ──────────────────────────
+ * MCP Tool: approve_operation
  *
- * AI CLI kullanımında "atabey approve <traceId>" CLI komutu çalıştırmak mümkün
- * değildir — chat'e yazılan şey CLI komutu olarak değil mesaj olarak işlenir.
+ * 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.
  *
- * Bu tool, risk gate approval flow'unu doğrudan MCP tool çağrısına taşır:
+ * This tool moves the risk gate approval flow directly into an MCP tool call:
  *
- * 1. Atabey yüksek riskli bir operasyonu bloklar
- * 2. Geliştiriciye: "approve_operation tool'unu çağır" der
- * 3. AI bu tool'u çağırır → operasyon onaylanır/reddedilir
+ * 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
  *
- * Geliştirici terminale geçmek zorunda kalmaz.
+ * Developer never has to switch to terminal.
  */
 export async function handleApproveOperation(_root, args) {
     const { action, traceId, reason } = args;
-    // LIST: Bekleyen approval'ları göster
+    // LIST: Show pending approvals
     if (action === "list") {
         const pending = getPendingApprovals();
         if (pending.length === 0) {
@@ -42,7 +42,7 @@ export async function handleApproveOperation(_root, args) {
             content: [{ type: "text", text: lines.join("\n") }],
         };
     }
-    // APPROVE or REJECT: traceId zorunlu
+    // APPROVE or REJECT: traceId is required
     if (!traceId) {
         return {
             isError: true,

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

@@ -3,16 +3,16 @@ import path from "path";
 /**
  * ─── ASK HUMAN — File Bridge ─────────────────────────────────────────
  *
- * AI CLI'lar (Claude Code, Gemini CLI) MCP server'ı stdio subprocess olarak
- * başlatır. Bu subprocess'te stdin isTTY=false olur (MCP JSON-RPC için kullanılır).
+ * 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).
  *
- * Çözüm: File-based Q&A bridge.
- * 1. Soru → .atabey/hitl/question.txt dosyasına yazılır
- * 2. Geliştirici `atabey hitl` komutuyla cevap girer
- * 3. Cevap → .atabey/hitl/answer.txt dosyasına yazılır
- * 4. Bu handler cevabı okur ve AI'ya döner
+ * 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: /api/approvals endpoint'i üzerinden web dashboard'dan da cevaplanabilir.
+ * Dashboard: Can also be answered via /api/approvals endpoint on the web dashboard.
  */
 export async function handleAskHuman(root, args) {
     const timeoutSeconds = args.timeoutSeconds ?? 120;

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

@@ -1,18 +1,32 @@
-import { execSync } from "child_process";
+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 {
-        // Using 'lsof -i -P -n' to list open files and network connections
-        // Note: may require permissions or behave differently on non-Unix systems
-        const command = process.platform === "win32"
-            ? `netstat -ano | findstr LISTENING ${filter ? `| findstr ${filter}` : ""}`
-            : `lsof -i -P -n | grep LISTEN ${filter ? `| grep ${filter}` : ""}`;
-        const output = execSync(command, { encoding: "utf8" });
+        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",

package/framework-mcp/dist/framework-mcp/src/tools/shell/run_command.js CHANGED Viewed

@@ -1,102 +1,129 @@
-import { exec } from "child_process";
+import { spawn } from "child_process";
 import { Metrics } from "../../utils/metrics.js";
+// Each entry defines the executable and its allowed args prefix
 const COMMAND_ALLOW_LIST = [
     // Package managers
-    "npm test",
-    "npm run",
-    "npm install",
-    "npm ci",
-    "npm audit",
-    "npx vitest",
-    "npx tsc",
-    "npx eslint",
-    "yarn test",
-    "yarn run",
-    "yarn install",
-    "pnpm test",
-    "pnpm run",
-    "pnpm install",
+    { cmd: "npm", args: ["test"] },
+    { cmd: "npm", args: ["run"] },
+    { cmd: "npm", args: ["install"] },
+    { cmd: "npm", args: ["ci"] },
+    { cmd: "npm", args: ["audit"] },
+    { cmd: "npx", args: ["vitest"] },
+    { cmd: "npx", args: ["tsc"] },
+    { cmd: "npx", args: ["eslint"] },
+    { cmd: "yarn", args: ["test"] },
+    { cmd: "yarn", args: ["run"] },
+    { cmd: "yarn", args: ["install"] },
+    { cmd: "pnpm", args: ["test"] },
+    { cmd: "pnpm", args: ["run"] },
+    { cmd: "pnpm", args: ["install"] },
     // Git
-    "git status",
-    "git diff",
-    "git log",
-    "git branch",
-    "git stash",
-    "git add",
-    "git commit",
-    "git push",
-    "git pull",
-    "git fetch",
-    "git merge",
-    "git rebase",
-    "git checkout",
-    "git reset",
+    { cmd: "git", args: ["status"] },
+    { cmd: "git", args: ["diff"] },
+    { cmd: "git", args: ["log"] },
+    { cmd: "git", args: ["branch"] },
+    { cmd: "git", args: ["stash"] },
+    { cmd: "git", args: ["add"] },
+    { cmd: "git", args: ["commit"] },
+    { cmd: "git", args: ["push"] },
+    { cmd: "git", args: ["pull"] },
+    { cmd: "git", args: ["fetch"] },
+    { cmd: "git", args: ["merge"] },
+    { cmd: "git", args: ["rebase"] },
+    { cmd: "git", args: ["checkout"] },
+    { cmd: "git", args: ["reset"] },
     // Build tools
-    "npm run build",
-    "npx tsc",
-    "npx vite build",
-    "npx webpack",
-    "npx rollup",
-    "npx esbuild",
-    "make",
-    "cmake",
-    "dotnet test",
-    "dotnet format",
-    "dotnet build",
-    "dotnet run",
-    "dotnet restore",
-    "go test",
-    "go fmt",
-    "go build",
-    "go run",
-    "go vet",
-    "go mod",
-    "pytest",
-    "ruff check",
-    "ruff format",
-    "mvn",
-    "./gradlew",
-    "cargo test",
-    "cargo build",
-    "cargo check",
-    "cargo fmt",
-    // File operations (safe) — NOTE: "rm -rf" and "rm -r" intentionally excluded.
-    // Only "rmdir" is allowed to prevent dangerous commands like "rm -rf /".
-    "mkdir",
-    "cp",
-    "mv",
-    "rmdir",
-    "cat",
-    "ls",
-    "touch",
-    "head",
-    "tail",
-    "wc",
-    "grep",
-    "find",
-    "sort",
-    "uniq",
-    "echo",
-    "pwd",
-    "which",
-    "file",
-    "du",
-    "df",
+    { cmd: "make" },
+    { cmd: "cmake" },
+    { cmd: "dotnet", args: ["test"] },
+    { cmd: "dotnet", args: ["format"] },
+    { cmd: "dotnet", args: ["build"] },
+    { cmd: "dotnet", args: ["run"] },
+    { cmd: "dotnet", args: ["restore"] },
+    { cmd: "go", args: ["test"] },
+    { cmd: "go", args: ["fmt"] },
+    { cmd: "go", args: ["build"] },
+    { cmd: "go", args: ["run"] },
+    { cmd: "go", args: ["vet"] },
+    { cmd: "go", args: ["mod"] },
+    { cmd: "pytest" },
+    { cmd: "ruff", args: ["check"] },
+    { cmd: "ruff", args: ["format"] },
+    { cmd: "mvn" },
+    { cmd: "./gradlew" },
+    { cmd: "cargo", args: ["test"] },
+    { cmd: "cargo", args: ["build"] },
+    { cmd: "cargo", args: ["check"] },
+    { cmd: "cargo", args: ["fmt"] },
+    // File operations (safe) — spawn prevents shell injection
+    { cmd: "mkdir" },
+    { cmd: "cp" },
+    { cmd: "mv" },
+    { cmd: "rmdir" },
+    { cmd: "cat" },
+    { cmd: "ls" },
+    { cmd: "touch" },
+    { cmd: "head" },
+    { cmd: "tail" },
+    { cmd: "wc" },
+    { cmd: "grep" },
+    { cmd: "find" },
+    { cmd: "sort" },
+    { cmd: "uniq" },
+    { cmd: "echo" },
+    { cmd: "pwd" },
+    { cmd: "which" },
+    { cmd: "file" },
+    { cmd: "du" },
+    { cmd: "df" },
 ];
 const TIMEOUT = 30000; // 30 seconds
+/**
+ * Parse a command string into executable + args array.
+ * Uses spawn for safety (no shell injection).
+ */
+function parseCommand(cmdString) {
+    const parts = cmdString.trim().split(/\s+/);
+    if (parts.length === 0)
+        return null;
+    return { cmd: parts[0], args: parts.slice(1) };
+}
+/**
+ * Check if a parsed command matches the allow list.
+ */
+function isAllowed(parsed) {
+    return COMMAND_ALLOW_LIST.some(entry => {
+        if (entry.cmd !== parsed.cmd)
+            return false;
+        if (!entry.args)
+            return true; // Any args allowed for this cmd
+        if (!parsed.args || parsed.args.length < entry.args.length)
+            return false;
+        // Check that args start with the allowed prefix
+        return entry.args.every((arg, i) => parsed.args[i] === arg);
+    });
+}
 export function handleRunCommand(projectRoot, args) {
     const command = args.command;
-    const isAllowed = COMMAND_ALLOW_LIST.some(allowedCmd => command.startsWith(allowedCmd));
-    if (!isAllowed) {
-        const errorMsg = `Command not allowed: "${command}". Only commands starting with the following are allowed: ${COMMAND_ALLOW_LIST.join(", ")}`;
+    // Parse command into executable + args
+    const parsed = parseCommand(command);
+    if (!parsed) {
+        return Promise.resolve({
+            content: [{ type: "text", text: "ERROR: Empty command." }],
+            isError: true,
+        });
+    }
+    if (!isAllowed(parsed)) {
+        const allowedList = COMMAND_ALLOW_LIST.map(e => e.args ? `${e.cmd} ${e.args.join(" ")}` : e.cmd);
+        const errorMsg = `Command not allowed: "${command}". Only the following are allowed: ${allowedList.join(", ")}`;
         Metrics.logError(projectRoot, "@mcp", `run_shell_command: ${command} (denied)`, errorMsg);
         return Promise.resolve({
             content: [{ type: "text", text: `ERROR: ${errorMsg}` }],
             isError: true,
         });
     }
-    // Harden to prevent shell command injection / chaining
-    const hasShellMetacharacters = /[;&|><$`\n\r]/.test(command);
+    // Reject any args containing shell metacharacters
+    const hasShellMetacharacters = parsed.args.some(a => /[;&|><$`\n\r]/.test(a));
     if (hasShellMetacharacters) {
         const errorMsg = "Command rejected: Shell metacharacters are forbidden to prevent command injection.";
         Metrics.logError(projectRoot, "@mcp", `run_shell_command: ${command} (denied: metacharacters)`, errorMsg);
@@ -106,12 +133,30 @@ export function handleRunCommand(projectRoot, args) {
         });
     }
     return new Promise((resolve) => {
-        exec(command, { cwd: projectRoot, timeout: TIMEOUT }, (error, stdout, stderr) => {
+        const child = spawn(parsed.cmd, parsed.args, {
+            cwd: projectRoot,
+            timeout: TIMEOUT,
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (data) => { stdout += data.toString(); });
+        child.stderr.on("data", (data) => { stderr += data.toString(); });
+        child.on("error", (err) => {
+            const errorMsg = `Failed to start command: ${err.message}`;
+            Metrics.logError(projectRoot, "@mcp", `run_shell_command: ${command}`, errorMsg);
+            resolve({
+                content: [{ type: "text", text: `ERROR: ${errorMsg}` }],
+                isError: true,
+            });
+        });
+        child.on("close", (code) => {
             const output = stdout + stderr;
             const tokens = Metrics.estimateTokens(output);
             Metrics.logUsage(projectRoot, "@mcp", `run_shell_command: ${command}`, tokens);
-            if (error) {
-                const errorMsg = `Command failed with exit code ${error.code}: ${error.message}.`;
+            if (code !== 0) {
+                const errorMsg = `Command failed with exit code ${code}.`;
                 Metrics.logError(projectRoot, "@mcp", `run_shell_command: ${command}`, errorMsg);
                 resolve({
                     content: [{ type: "text", text: `ERROR: ${errorMsg}. Output: ${output}` }],
@@ -121,11 +166,12 @@ export function handleRunCommand(projectRoot, args) {
             }
             // Truncate long outputs
             const MAX_OUTPUT_LENGTH = 5000;
-            let truncatedOutput = output;
-            if (output.length > MAX_OUTPUT_LENGTH) {
-                truncatedOutput = output.substring(0, MAX_OUTPUT_LENGTH) + "... [TRUNCATED] ..."; // Simplified
-            }
-            resolve({ content: [{ type: "text", text: truncatedOutput }] });
+            const truncatedOutput = output.length > MAX_OUTPUT_LENGTH
+                ? output.substring(0, MAX_OUTPUT_LENGTH) + "... [TRUNCATED] ..."
+                : output;
+            resolve({
+                content: [{ type: "text", text: truncatedOutput }],
+            });
         });
     });
 }

package/framework-mcp/dist/framework-mcp/src/utils/auth.js CHANGED Viewed

@@ -27,14 +27,14 @@ export function initAuth() {
         }).filter(u => u.token);
     }
     if (masterToken) {
-        console.error(`[AUTH] Master token configured (${masterToken.length} chars)`);
+        process.stderr.write(`[AUTH] Master token configured (${masterToken.length} chars)\n`);
     }
     if (authUsers.length > 0) {
-        console.error(`[AUTH] ${authUsers.length} user(s) configured: ${authUsers.map(u => u.name).join(", ")}`);
+        process.stderr.write(`[AUTH] ${authUsers.length} user(s) configured: ${authUsers.map(u => u.name).join(", ")}\n`);
     }
     if (!masterToken && authUsers.length === 0) {
-        console.error("[AUTH] No authentication configured - OPEN ACCESS");
-        console.error("[AUTH] Set MCP_AUTH_TOKEN=<key> or MCP_AUTH_USERS=user1:key1,user2:key2 to enable");
+        process.stderr.write("[AUTH] No authentication configured - OPEN ACCESS\n");
+        process.stderr.write("[AUTH] Set MCP_AUTH_TOKEN=<key> or MCP_AUTH_USERS=user1:key1,user2:key2 to enable\n");
     }
 }
 /**

package/framework-mcp/dist/framework-mcp/src/utils/discipline.js CHANGED Viewed

@@ -202,7 +202,7 @@ export function getDisciplineStats(agent) {
  */
 export function getAllDisciplineStats() {
     const stats = {};
-    for (const [agent, _discipline] of agentDiscipline) {
+    for (const [agent] of agentDiscipline) {
         stats[agent] = getDisciplineStats(agent);
     }
     return stats;

package/framework-mcp/dist/framework-mcp/src/utils/human-in-loop.js CHANGED Viewed

@@ -196,7 +196,7 @@ export function getPendingApprovals() {
     const now = Date.now();
     const pending = [];
     // Clean expired
-    for (const [traceId, request] of activeApprovals) {
+    for (const [, request] of activeApprovals) {
         if (request.status === "PENDING" && now > request.expiresAt) {
             request.status = "EXPIRED";
         }

package/framework-mcp/dist/framework-mcp/src/utils/loop-detector.js CHANGED Viewed

@@ -274,7 +274,7 @@ export function recordAndCheck(agent, toolName, args) {
 /**
  * Apply cooldown to an agent.
  */
-function applyCooldown(history, alert, agent) {
+function applyCooldown(history, alert, _agent) {
     history.inCooldown = true;
     history.cooldownUntil = alert.cooldownUntil || Date.now() + CONFIG.COOLDOWN_MS;
     history.cooldownCount++;
@@ -347,8 +347,8 @@ export function getLoopStats(agent) {
  */
 export function getAllLoopStats() {
     const stats = {};
-    for (const [agent] of agentHistories) {
-        stats[agent] = getLoopStats(agent);
+    for (const [agentName] of agentHistories) {
+        stats[agentName] = getLoopStats(agentName);
     }
     return stats;
 }

package/framework-mcp/dist/framework-mcp/src/utils/quality.js CHANGED Viewed

@@ -93,9 +93,10 @@ export function analyzePathQuality(projectRoot, targetPath) {
             }
             // Check nesting depth
             lines.forEach((line, idx) => {
-                const indentMatch = line.match(/^(?:\s{2}){5,}/);
-                if (indentMatch && !line.trim().startsWith("//") && !line.trim().startsWith("*")) {
-                    const depth = Math.floor(indentMatch[0].length / 2);
+                const leadingSpaces = line.match(/^(\s*)/)?.[0].length || 0;
+                if (leadingSpaces >= 10 && !line.trim().startsWith("//") && !line.trim().startsWith("*")) {
+                    const indentSize = (leadingSpaces % 4 === 0) ? 4 : 2;
+                    const depth = Math.floor(leadingSpaces / indentSize);
                     if (depth > 4) {
                         deepNesting++;
                         issues.push({