atabey 0.0.11 → 0.0.13

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

@@ -0,0 +1,28 @@
+import { Storage } from "../../../../src/shared/storage.js";
+export async function handleDeleteKnowledge(root, args) {
+    try {
+        const db = Storage.getDB();
+        if (args.id) {
+            const info = db.prepare("DELETE FROM vector_memory WHERE id = ?").run(args.id);
+            if (info.changes > 0) {
+                return { content: [{ type: "text", text: `[SUCCESS] Knowledge entry '${args.id}' deleted from Core Memory.` }] };
+            }
+            return { content: [{ type: "text", text: `[INFO] No entry found with ID '${args.id}'.` }] };
+        }
+        if (args.category) {
+            const info = db.prepare("DELETE FROM vector_memory WHERE category = ?").run(args.category);
+            return { content: [{ type: "text", text: `[SUCCESS] Purged ${info.changes} entries from category '${args.category}'.` }] };
+        }
+        return {
+            isError: true,
+            content: [{ type: "text", text: "[ERROR] You must provide either an 'id' or a 'category' to delete knowledge." }]
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            isError: true,
+            content: [{ type: "text", text: `[ERROR] Failed to delete knowledge: ${message}` }]
+        };
+    }
+}

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

@@ -0,0 +1,22 @@
+import { Storage } from "../../utils/storage.js";
+/**
+ * Extracts key insights from the SQLite database to minimize token usage.
+ * Returns only the active phase, trace, and the last 5 decisions/tasks.
+ */
+export function handleGetMemoryInsights(_projectRoot, _args) {
+    try {
+        const activePhase = Storage.getMetadata("phase") || "PHASE_0";
+        const activeTrace = Storage.getMetadata("traceId") || "None";
+        // Get the last 5 logs from SQLite
+        const recentLogs = Storage.getLogs().slice(0, 5);
+        let recentHistory = "No history found.";
+        if (recentLogs.length > 0) {
+            recentHistory = recentLogs.map(log => `- [${log.agent}] ${log.action}: ${log.summary}`).join("\n");
+        }
+        const insights = `[MEMORY] **Memory Insights**\n- **Phase:** ${activePhase}\n- **Trace:** ${activeTrace}\n\n**Recent Actions:**\n${recentHistory}`;
+        return { content: [{ type: "text", text: insights }] };
+    }
+    catch (e) {
+        return { isError: true, content: [{ type: "text", text: `Failed to extract insights: ${String(e)}` }] };
+    }
+}

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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,30 @@
+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/ask_human.js

@@ -0,0 +1,30 @@
+import chalk from "chalk";
+export async function handleAskHuman(root, args) {
+    if (process.env.ATABEY_TEST_DIR || !process.stdin.isTTY) {
+        return { content: [{ type: "text", text: "[SKIPPED] Non-interactive environment. Cannot ask human." }] };
+    }
+    try {
+        const readline = await import("readline");
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        return new Promise((resolve) => {
+            process.stdout.write("\n" + chalk.bgMagenta.white.bold(" [HUMAN-IN-THE-LOOP REQUIRED] ") + "\n");
+            process.stdout.write(chalk.magenta("An agent has paused execution to ask you a question:\n"));
+            rl.question(`\n${chalk.bold(args.question)}\n${chalk.gray("> ")}`, (answer) => {
+                rl.close();
+                resolve({
+                    content: [{ type: "text", text: `[HUMAN RESPONSE] ${answer}` }]
+                });
+            });
+        });
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            isError: true,
+            content: [{ type: "text", text: `[ERROR] Failed to ask human: ${message}` }]
+        };
+    }
+}

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

@@ -0,0 +1,22 @@
+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

@@ -0,0 +1,94 @@
+import fs from "fs";
+import path from "path";
+import { resolveFrameworkDir } from "../../utils/security.js";
+import { Metrics } from "../../utils/metrics.js";
+export async function handleSendAgentMessage(projectRoot, args) {
+    const { to, category, content, traceId, parentId, requiresApproval } = args;
+    const from = 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}` }] };
+    }
+    const frameworkDir = resolveFrameworkDir(projectRoot);
+    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 > 10000) {
+                        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

@@ -0,0 +1,26 @@
+import { execSync } from "child_process";
+/**
+ * Checks for active network ports and their status.
+ */
+export function handleCheckPorts(projectRoot, args) {
+    const filter = args.filter || ""; // Optional filter (e.g., ":3000")
+    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" });
+        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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,165 @@
+import { execSync } from "child_process";
+import fs from "fs";
+import path from "path";
+/**
+ * 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) {
+    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 complexityIssues = [];
+        function scanDirectory(dir) {
+            if (!fs.existsSync(dir))
+                return;
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                if (entry.isDirectory() && !entry.name.startsWith("node_modules") && !entry.name.startsWith(".")) {
+                    scanDirectory(fullPath);
+                }
+                else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx"))) {
+                    try {
+                        const content = fs.readFileSync(fullPath, "utf8");
+                        const lines = content.split("\n");
+                        // Check for long functions (>50 lines)
+                        let inFunction = false;
+                        let funcLines = 0;
+                        let funcName = "";
+                        const relativePath = path.relative(projectRoot, fullPath);
+                        for (let i = 0; i < lines.length; i++) {
+                            const line = lines[i];
+                            // Detect function start
+                            const funcMatch = line.match(/(?:public|private|protected|static\s+)?(?:async\s+)?(?:function\s+)?(\w+)\s*\([^)]*\)\s*{/);
+                            if (funcMatch) {
+                                inFunction = true;
+                                funcLines = 1;
+                                funcName = funcMatch[1];
+                                continue;
+                            }
+                            // Detect method in class
+                            const methodMatch = line.match(/^\s*(?:public|private|protected|static\s+)?(\w+)\s*\([^)]*\)\s*{/);
+                            if (methodMatch && !line.includes("function")) {
+                                inFunction = true;
+                                funcLines = 1;
+                                funcName = methodMatch[1];
+                                continue;
+                            }
+                            if (inFunction) {
+                                if (line.includes("}")) {
+                                    if (funcLines > 50) {
+                                        complexityIssues.push(`- ${relativePath}:${i + 1} — Function \`${funcName}\` is ${funcLines} lines long (max: 50)`);
+                                    }
+                                    inFunction = false;
+                                }
+                                funcLines++;
+                            }
+                            // Check nesting depth (>4 levels)
+                            const indentMatch = line.match(/^(?:\s{2}){5,}/);
+                            if (indentMatch && !line.trim().startsWith("//") && !line.trim().startsWith("*")) {
+                                const depth = Math.floor(indentMatch[0].length / 2);
+                                if (depth > 4) {
+                                    complexityIssues.push(`- ${relativePath}:${i + 1} — Nesting depth ${depth} (max: 4)`);
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        // Skip files that can't be read
+                    }
+                }
+            }
+        }
+        scanDirectory(targetPath);
+        if (complexityIssues.length > 0) {
+            hasErrors = true;
+            results.push(`## ⚠️ Code Complexity Issues (${complexityIssues.length})`);
+            results.push(...complexityIssues);
+        }
+        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
+    };
+}

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

@@ -0,0 +1,134 @@
+import fs from "fs";
+import path from "path";
+/**
+ * [TOOL] check_architecture_compliance
+ *
+ * Checks architectural compliance for code at the specified path:
+ * - Controller/Service/Repository layer separation
+ * - Import rules (controller → service → repository)
+ * - Circular dependencies
+ */
+export function handleCheckArchitectureCompliance(projectRoot, args) {
+    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 = [
+        "# Architecture Compliance Report",
+        "",
+        `**Target:** ${args.path}`,
+        `**Timestamp:** ${new Date().toISOString()}`,
+        ""
+    ];
+    const violations = [];
+    const allFiles = [];
+    // Collect all relevant files
+    function collectFiles(dir) {
+        if (!fs.existsSync(dir))
+            return;
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory() && !entry.name.startsWith("node_modules") && !entry.name.startsWith(".")) {
+                collectFiles(fullPath);
+            }
+            else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx"))) {
+                allFiles.push(fullPath);
+            }
+        }
+    }
+    collectFiles(targetPath);
+    // Analyze each file for architectural violations
+    for (const file of allFiles) {
+        const relativePath = path.relative(projectRoot, file);
+        const content = fs.readFileSync(file, "utf8");
+        const lines = content.split("\n");
+        const fileName = path.basename(file, path.extname(file));
+        const fileDir = path.dirname(file);
+        // 1. Layer naming convention check
+        const isController = fileName.endsWith(".controller") || fileName.endsWith("Controller");
+        const isService = fileName.endsWith(".service") || fileName.endsWith("Service");
+        const isRepository = fileName.endsWith(".repository") || fileName.endsWith("Repository");
+        const isModel = fileName.endsWith(".model") || fileName.endsWith("Model");
+        // 2. Controller → Service → Repository dependency direction
+        for (const line of lines) {
+            const importMatch = line.match(/import\s+.*\s+from\s+['"](.+)['"]/);
+            if (!importMatch)
+                continue;
+            const importPath = importMatch[1];
+            const importedFileName = path.basename(importPath, path.extname(importPath));
+            // Controller importing Repository directly (should go through Service)
+            if (isController && (importedFileName.endsWith(".repository") || importedFileName.endsWith("Repository"))) {
+                violations.push(`- ${relativePath}: Controller \`${fileName}\` directly imports Repository \`${importedFileName}\`. ` +
+                    "Use Service layer instead.");
+            }
+            // Repository importing Controller
+            if (isRepository && (importedFileName.endsWith(".controller") || importedFileName.endsWith("Controller"))) {
+                violations.push(`- ${relativePath}: Repository \`${fileName}\` imports Controller \`${importedFileName}\`. ` +
+                    "Reverse dependency detected.");
+            }
+            // Service importing Controller
+            if (isService && (importedFileName.endsWith(".controller") || importedFileName.endsWith("Controller"))) {
+                violations.push(`- ${relativePath}: Service \`${fileName}\` imports Controller \`${importedFileName}\`. ` +
+                    "Service should not depend on Controller.");
+            }
+            // Model importing Controller/Service/Repository
+            if (isModel && (importedFileName.endsWith("Controller") || importedFileName.endsWith("Service") || importedFileName.endsWith("Repository"))) {
+                violations.push(`- ${relativePath}: Model \`${fileName}\` imports \`${importedFileName}\`. ` +
+                    "Models should not depend on other layers.");
+            }
+        }
+        // 3. Check for barrel index imports that might cause circular dependencies
+        if (fileName === "index" && fileDir.includes("modules")) {
+            const indexContent = fs.readFileSync(file, "utf8");
+            const exports = indexContent.match(/export\s+\*?\s*from\s+['"].+['"]/g) || [];
+            if (exports.length > 10) {
+                violations.push(`- ${relativePath}: Barrel file exports ${exports.length} modules. ` +
+                    "Consider splitting into smaller barrels to prevent circular dependencies.");
+            }
+        }
+    }
+    // 4. Strict mode check
+    let hasStrictMode = false;
+    const tsConfigPath = path.join(projectRoot, "tsconfig.json");
+    if (fs.existsSync(tsConfigPath)) {
+        try {
+            const tsConfig = JSON.parse(fs.readFileSync(tsConfigPath, "utf8"));
+            if (tsConfig.compilerOptions?.strict) {
+                hasStrictMode = true;
+            }
+        }
+        catch {
+            // Ignore parse errors
+        }
+    }
+    if (!hasStrictMode) {
+        violations.push("- tsconfig.json: `strict` mode is not enabled. Atabey requires strict type checking.");
+    }
+    // Report
+    if (violations.length > 0) {
+        results.push(`## ❌ Architecture Violations (${violations.length})`);
+        results.push("");
+        results.push(...violations);
+        results.push("");
+        results.push("---");
+        results.push(`**Status:** ❌ FAILED — ${violations.length} architectural violations found.`);
+    }
+    else {
+        results.push("## ✅ Architecture Compliance: PASSED");
+        results.push("");
+        results.push("- All layer dependencies are correctly oriented.");
+        results.push("- No circular dependencies detected.");
+        results.push("- Strict mode is enabled.");
+        results.push("");
+        results.push("---");
+        results.push("**Status:** ✅ All architecture checks passed.");
+    }
+    return {
+        content: [{ type: "text", text: results.join("\n") }],
+        isError: violations.length > 0
+    };
+}