atabey 0.0.7 → 0.0.8

package/framework-mcp/dist/resources/index.js

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

package/framework-mcp/dist/src/cli/adapters/core.js

@@ -0,0 +1,71 @@
+import fs from "fs";
+import path from "path";
+import { writeJsonFile } from "../utils/fs.js";
+import { getPackageRoot } from "../utils/pkg.js";
+import { MCP } from "../../shared/constants.js";
+import { ADAPTER_CONFIGS, POST_INIT_HANDLERS } from "../../modules/adapters/definitions.js";
+export const ADAPTERS = ADAPTER_CONFIGS;
+export const SHIM_FILES = Object.keys(ADAPTERS).map((id) => ADAPTERS[id].shimFile);
+export const FRAMEWORK_DIR_CANDIDATES = [
+    ".atabey",
+    ".cursor",
+    ".claude",
+    ".github",
+    ".grok",
+    ".antigravity",
+    ".agent",
+    ".gemini/antigravity-cli",
+    ".gemini",
+    ".agents",
+    "antigravity-cli"
+];
+export function buildMcpServerEntry(projectRoot) {
+    const packageRoot = getPackageRoot();
+    // Check if we are running in the framework local development repository itself
+    const isLocalFrameworkDev = path.resolve(packageRoot) === path.resolve(projectRoot);
+    let relativePath;
+    if (isLocalFrameworkDev) {
+        // In local framework dev, always use the build path directly relative to project root
+        let mcpServerPath = path.join(packageRoot, MCP.SERVER_DIST_PATH);
+        if (!fs.existsSync(mcpServerPath)) {
+            mcpServerPath = path.join(packageRoot, "../atabey-mcp/dist/index.js");
+        }
+        if (!fs.existsSync(mcpServerPath)) {
+            mcpServerPath = path.join(projectRoot, "node_modules/atabey-mcp/dist/index.js");
+        }
+        if (!fs.existsSync(mcpServerPath)) {
+            console.warn("[WARN]  MCP Server not found. Did you run 'npm run build' inside atabey-mcp?");
+        }
+        relativePath = path.relative(projectRoot, mcpServerPath) || mcpServerPath;
+    }
+    else {
+        // If we are initializing in a user's project:
+        // We target the atabey-mcp package which is a dependency of atabey.
+        // This ensures a stable path across different npm/pnpm/yarn setups.
+        relativePath = "node_modules/atabey-mcp/dist/index.js";
+        // Fallback check if it actually exists in a different location during init
+        const localAtabeyPath = path.join(projectRoot, "node_modules/atabey", MCP.SERVER_DIST_PATH);
+        if (!fs.existsSync(path.join(projectRoot, relativePath)) && fs.existsSync(localAtabeyPath)) {
+            relativePath = path.join("node_modules/atabey", MCP.SERVER_DIST_PATH);
+        }
+    }
+    return {
+        command: "node",
+        args: [relativePath],
+        env: {
+            [MCP.PROJECT_ROOT_ENV]: projectRoot,
+        },
+    };
+}
+export function runAdapterPostInit(adapter, projectRoot) {
+    const mcpEntry = buildMcpServerEntry(projectRoot);
+    const mcpBlock = { mcpServers: { [MCP.SERVER_NAME]: mcpEntry } };
+    const postInitFn = POST_INIT_HANDLERS[adapter.id];
+    if (postInitFn) {
+        postInitFn(projectRoot, mcpBlock);
+    }
+    const rootMcpPath = path.join(projectRoot, MCP.ROOT_CONFIG_FILE);
+    if (!fs.existsSync(rootMcpPath)) {
+        writeJsonFile(rootMcpPath, mcpBlock);
+    }
+}

package/framework-mcp/dist/src/cli/adapters/index.js

@@ -0,0 +1,5 @@
+export { ADAPTER_IDS } from "../../modules/adapters/types.js";
+export { ADAPTERS, FRAMEWORK_DIR_CANDIDATES, runAdapterPostInit, buildMcpServerEntry } from "./core.js";
+export { resolveAdapter, isAdapterShimFile, remapFrameworkContent } from "./utils.js";
+export { scaffoldAgents } from "./scaffold.js";
+export { resolveAgentsDir, mirrorUnifiedAgentsToNative } from "./paths.js";

package/framework-mcp/dist/src/cli/adapters/paths.js

@@ -0,0 +1,101 @@
+import fs from "fs";
+import path from "path";
+import { ADAPTER_IDS } from "../../modules/adapters/types.js";
+import { LEGACY_AGENT_LAYOUT_BASES, UNIFIED_ADAPTER_SLUG, UNIFIED_HUB_DIR, pathJoin, unifiedAdapterPath, } from "../../shared/constants.js";
+import { ADAPTERS } from "./core.js";
+export { CORE_FRAMEWORK_DIR, UNIFIED_HUB_DIR, UNIFIED_ADAPTER_SLUG, } from "../../shared/constants.js";
+export function unifiedAdapterRoot(aiToolDir, adapterId) {
+    return pathJoin(aiToolDir, UNIFIED_ADAPTER_SLUG[adapterId]);
+}
+export function resolveAgentsDir(adapterId, isUnified, aiToolDir = UNIFIED_HUB_DIR) {
+    const adapter = ADAPTERS[adapterId];
+    if (!isUnified) {
+        return {
+            agentsDir: adapter.agentsDir ?? pathJoin(adapter.frameworkDir, "agents"),
+            agentsExt: adapter.agentsExt ?? ".md",
+            nestedAntigravity: adapterId === "antigravity-cli",
+        };
+    }
+    const base = unifiedAdapterRoot(aiToolDir, adapterId);
+    switch (adapterId) {
+        case "cursor":
+            return { agentsDir: pathJoin(base, "rules"), agentsExt: ".mdc", nestedAntigravity: false };
+        case "codex":
+            return { agentsDir: pathJoin(base, "instructions"), agentsExt: ".md", nestedAntigravity: false };
+        case "antigravity-cli":
+            // Antigravity CLI expects workspace agents at .agents/agents/{agent_name}/agent.json
+            return { agentsDir: pathJoin(aiToolDir, "agents"), agentsExt: ".json", nestedAntigravity: true };
+        default:
+            return { agentsDir: pathJoin(base, "agents"), agentsExt: ".md", nestedAntigravity: false };
+    }
+}
+export function getUnifiedAgentLayoutBases(aiToolDir = UNIFIED_HUB_DIR) {
+    return ADAPTER_IDS.map((id) => resolveAgentsDir(id, true, aiToolDir).agentsDir);
+}
+const AGENT_INSTRUCTION_CANDIDATES = [
+    (n) => ADAPTER_IDS.flatMap((id) => {
+        const { agentsDir, nestedAntigravity, agentsExt } = resolveAgentsDir(id, true);
+        if (nestedAntigravity) {
+            return [pathJoin(agentsDir, n, "agent.json"), pathJoin(agentsDir, n, "agent.md")];
+        }
+        return [pathJoin(agentsDir, `${n}${agentsExt}`)];
+    }),
+    (n) => LEGACY_AGENT_LAYOUT_BASES.flatMap((base) => {
+        if (base.includes("antigravity")) {
+            return [pathJoin(base, n, "agent.json"), pathJoin(base, n, "agent.md")];
+        }
+        const ext = base.includes("rules") ? ".mdc" : ".md";
+        return [pathJoin(base, `${n}${ext}`)];
+    }),
+];
+export function findAgentInstruction(projectRoot, agentName) {
+    for (const buildPaths of AGENT_INSTRUCTION_CANDIDATES) {
+        for (const rel of buildPaths(agentName)) {
+            const full = path.join(projectRoot, rel);
+            if (fs.existsSync(full))
+                return rel;
+        }
+    }
+    return null;
+}
+export function detectActiveAgentLayouts(projectRoot) {
+    const unified = getUnifiedAgentLayoutBases()
+        .filter((b) => fs.existsSync(path.join(projectRoot, b)));
+    const legacy = LEGACY_AGENT_LAYOUT_BASES
+        .filter((b) => fs.existsSync(path.join(projectRoot, b)));
+    return [...new Set([...unified, ...legacy])];
+}
+function copyDirectoryRecursive(src, dest) {
+    fs.mkdirSync(dest, { recursive: true });
+    for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirectoryRecursive(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+export function mirrorUnifiedAgentsToNative(projectRoot, adapterId) {
+    const { agentsDir: unifiedDir } = resolveAgentsDir(adapterId, true);
+    const nativeRel = ADAPTERS[adapterId].agentsDir;
+    if (!nativeRel)
+        return;
+    const src = path.join(projectRoot, unifiedDir);
+    const dest = path.join(projectRoot, nativeRel);
+    if (!fs.existsSync(src) || path.resolve(src) === path.resolve(dest))
+        return;
+    if (fs.existsSync(dest)) {
+        fs.rmSync(dest, { recursive: true, force: true });
+    }
+    copyDirectoryRecursive(src, dest);
+}
+/** Cursor global rule destinations (native + unified hub). */
+export function getCursorGlobalRulePaths(projectRoot) {
+    return [
+        path.join(projectRoot, ADAPTERS.cursor.frameworkDir, "rules", "global.mdc"),
+        path.join(projectRoot, unifiedAdapterPath(UNIFIED_ADAPTER_SLUG.cursor, "rules", "global.mdc")),
+    ];
+}

package/framework-mcp/dist/src/cli/adapters/scaffold.js

@@ -0,0 +1,71 @@
+import { writeTextFile } from "../utils/fs.js";
+import path from "path";
+import fs from "fs";
+import { getPackageRoot } from "../utils/pkg.js";
+import { ALL_AGENTS, toClaudeCodeMd, toGeminiCliMd, toCodexMd, toAntigravityJson, toCursorMdc } from "../../modules/agents/definitions.js";
+import { ADAPTERS } from "./core.js";
+export function scaffoldAgents(projectRoot, adapterId, dryRun, agentsToScaffold, explicitDestDir, explicitExt, paths, backendLanguage, _language) {
+    const adapter = ADAPTERS[adapterId];
+    if (!adapter)
+        return;
+    const allowedAgents = agentsToScaffold ? new Set(agentsToScaffold) : undefined;
+    const destAgentsDir = explicitDestDir ? path.join(projectRoot, explicitDestDir) : (adapter.agentsDir ? path.join(projectRoot, adapter.agentsDir) : null);
+    const extension = explicitExt || adapter.agentsExt || ".md";
+    if (!destAgentsDir)
+        return;
+    const baseKnowledgeDir = path.join(getPackageRoot(), "templates/standards");
+    try {
+        if (!dryRun)
+            fs.mkdirSync(destAgentsDir, { recursive: true });
+        for (const agent of ALL_AGENTS) {
+            if (allowedAgents && !allowedAgents.has(agent.name))
+                continue;
+            let content = "";
+            let fileName = `${agent.name}${extension}`;
+            let secondaryContent = null;
+            let secondaryFileName = null;
+            switch (adapterId) {
+                case "gemini":
+                    content = toGeminiCliMd(agent, baseKnowledgeDir, paths, backendLanguage);
+                    break;
+                case "grok":
+                    // Grok uses same Gemini-compatible YAML format
+                    content = toGeminiCliMd(agent, baseKnowledgeDir, paths, backendLanguage);
+                    break;
+                case "claude":
+                    content = toClaudeCodeMd(agent, baseKnowledgeDir, paths, backendLanguage);
+                    break;
+                case "cursor":
+                    content = toCursorMdc(agent, baseKnowledgeDir, paths, backendLanguage);
+                    break;
+                case "codex":
+                    content = toCodexMd(agent, baseKnowledgeDir, paths, backendLanguage);
+                    break;
+                case "antigravity-cli": {
+                    // Antigravity uses nested folders: agents/{name}/agent.json and agents/{name}/agent.md
+                    const agentDir = path.join(destAgentsDir, agent.name);
+                    if (!dryRun)
+                        fs.mkdirSync(agentDir, { recursive: true });
+                    content = toAntigravityJson(agent, baseKnowledgeDir, paths, backendLanguage);
+                    fileName = path.join(agent.name, "agent.json");
+                    secondaryContent = `# [ATABEY] Agent Atabey — @${agent.name}\n\n${agent.instructions.identity}\n\n${agent.instructions.mission}`;
+                    secondaryFileName = path.join(agent.name, "agent.md");
+                    break;
+                }
+                default:
+                    // Fallback to Gemini format
+                    content = toGeminiCliMd(agent, baseKnowledgeDir, paths, backendLanguage);
+                    break;
+            }
+            if (!dryRun) {
+                writeTextFile(path.join(destAgentsDir, fileName), content, dryRun);
+                if (secondaryContent && secondaryFileName) {
+                    writeTextFile(path.join(destAgentsDir, secondaryFileName), secondaryContent, dryRun);
+                }
+            }
+        }
+    }
+    catch (e) {
+        console.warn(`[WARN]  Failed to scaffold agents for ${adapterId}: ${e}`);
+    }
+}

package/framework-mcp/dist/src/cli/adapters/utils.js

@@ -0,0 +1,75 @@
+import fs from "fs";
+import path from "path";
+import { logger } from "../../shared/logger.js";
+import { UI } from "../utils/ui.js";
+import { ADAPTERS, SHIM_FILES } from "./core.js";
+export function resolveAdapter(input) {
+    let normalized = (input || "gemini").toLowerCase();
+    if (normalized === "antigravity") {
+        normalized = "antigravity-cli";
+    }
+    else if (normalized === "copilot" || normalized === "github") {
+        normalized = "codex";
+    }
+    let config;
+    if (normalized in ADAPTERS) {
+        config = { ...ADAPTERS[normalized] };
+    }
+    else {
+        UI.warning(`Unknown adapter "${input}". Falling back to gemini.`);
+        config = { ...ADAPTERS.gemini };
+    }
+    return config;
+}
+export function isAdapterShimFile(fileName) {
+    return SHIM_FILES.includes(fileName);
+}
+export function remapFrameworkContent(content, frameworkDir, adapterId) {
+    let result = content;
+    result = result.replace(/\{\{FRAMEWORK_DIR\}\}/g, frameworkDir);
+    result = result.replace(/\{\{ADAPTER\}\}/g, adapterId);
+    let agentFolder = "agents";
+    let knowledgeFolder = "knowledge";
+    if (frameworkDir !== ".atabey") {
+        if (adapterId === "antigravity-cli") {
+            agentFolder = "agents";
+            knowledgeFolder = "rules";
+        }
+        // Note: Grok uses the same directory structure as Gemini (".grok/agents").
+        // No override needed — default agentFolder = "agents" is correct.
+    }
+    const frameworkPattern = ".atabey/";
+    result = result.replace(new RegExp(frameworkPattern + "agents/", "g"), `${frameworkDir}/${agentFolder}/`);
+    result = result.replace(new RegExp(frameworkPattern + "knowledge/", "g"), `${frameworkDir}/${knowledgeFolder}/`);
+    result = result.replace(/\.atabey\//g, `${frameworkDir}/`);
+    result = result.replace(/`\.atabey`/g, `\`${frameworkDir}\``);
+    result = result.replace(/\.atabey(?![\w/-])/g, frameworkDir);
+    let backend = "apps/backend";
+    let frontend = "apps/web";
+    let docs = "docs";
+    let tests = "tests";
+    try {
+        const configPath = path.join(process.cwd(), frameworkDir, "config.json");
+        if (fs.existsSync(configPath)) {
+            const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
+            if (config.paths) {
+                if (config.paths.backend)
+                    backend = config.paths.backend;
+                if (config.paths.frontend)
+                    frontend = config.paths.frontend;
+                if (config.paths.docs)
+                    docs = config.paths.docs;
+                if (config.paths.tests)
+                    tests = config.paths.tests;
+            }
+        }
+    }
+    catch (err) {
+        logger.debug("Failed to read config.json in remapFrameworkContent", err);
+    }
+    result = result.replace(/\{\{BACKEND_DIR\}\}/g, backend);
+    result = result.replace(/\{\{FRONTEND_DIR\}\}/g, frontend);
+    result = result.replace(/\{\{DOCS_DIR\}\}/g, docs);
+    result = result.replace(/\{\{TESTS_DIR\}\}/g, tests);
+    return result;
+}

package/framework-mcp/dist/src/cli/commands/approve.js

@@ -0,0 +1,63 @@
+import fs from "fs";
+import path from "path";
+import { getFrameworkDir } from "../utils/memory.js";
+import { UI } from "../utils/ui.js";
+import { writeTextFile, appendFile } from "../utils/fs.js";
+import { ValidationError } from "../../shared/errors.js";
+import { HermesMessageSchema } from "./orchestrate.js";
+export async function approveCommand(traceId) {
+    const frameworkDir = getFrameworkDir();
+    const messagesDir = path.join(frameworkDir, "messages");
+    if (!fs.existsSync(messagesDir)) {
+        throw new ValidationError("No messages directory found.", null, "Ensure the framework is initialized and the Hermes orchestrator has been run at least once.");
+    }
+    const files = fs.readdirSync(messagesDir).filter((f) => f.endsWith(".json"));
+    let found = false;
+    for (const file of files) {
+        const filePath = path.join(messagesDir, file);
+        try {
+            const content = fs.readFileSync(filePath, "utf8").trim();
+            if (!content)
+                continue;
+            const lines = content.split("\n");
+            let updated = false;
+            const newLines = lines.map((line) => {
+                if (!line.trim())
+                    return line;
+                try {
+                    const parsed = JSON.parse(line);
+                    const msg = HermesMessageSchema.parse(parsed);
+                    if (msg.traceId === traceId && msg.status === "PENDING" && (msg.category === "ALERT" || msg.category === "ACTION")) {
+                        msg.status = "APPROVED";
+                        updated = true;
+                        found = true;
+                        UI.success(`Approved message from ${msg.from} to ${msg.to} (Action: ${msg.action || "None"})`);
+                    }
+                    return JSON.stringify(msg);
+                }
+                catch (e) {
+                    UI.error(`Skipping invalid Hermes message during approval: ${e.message}`);
+                    return line;
+                }
+            });
+            if (updated) {
+                writeTextFile(filePath, newLines.join("\n") + "\n");
+            }
+        }
+        catch (e) {
+            UI.error(`Error reading or updating message file ${file}: ${e.message}`);
+        }
+    }
+    if (found) {
+        // Log user approval to audit log
+        const auditPath = path.join(frameworkDir, "observability/audit_log.md");
+        if (fs.existsSync(auditPath)) {
+            const logEntry = "\n- **[" + new Date().toISOString() + "]** USER -> @manager | APPROVED | Trace: " + traceId;
+            appendFile(auditPath, logEntry);
+        }
+        UI.success("Successfully approved Trace: " + traceId);
+    }
+    else {
+        throw new ValidationError(`No pending approval request found for Trace ID: ${traceId}`, null, "Run 'npx atabey status' to see active traces and ensure the ID is correct and pending approval.");
+    }
+}

package/framework-mcp/dist/src/cli/commands/check.js

@@ -0,0 +1,181 @@
+import fs from "fs";
+import path from "path";
+import { execSync } from "child_process";
+import { getFrameworkDir, getMemoryPath, getConfiguredPaths, isFrameworkDevelopmentRepo, readState } from "../utils/memory.js";
+import { getPackageVersion, getValidatorPath } from "../utils/pkg.js";
+import { UI } from "../utils/ui.js";
+import { logger } from "../../shared/logger.js";
+import { scanProjectCompliance } from "../utils/compliance.js";
+import { ALL_AGENTS } from "../../modules/agents/definitions.js";
+import { detectActiveAgentLayouts, findAgentInstruction } from "../adapters/paths.js";
+import { verifyApiContractCommand } from "./contract.js";
+export async function checkCommand() {
+    UI.intent("Agent Atabey Health Check", `Checking system health and discipline rules (v${getPackageVersion()})...`);
+    let issues = 0;
+    const state = readState();
+    if (!state) {
+        UI.error("Memory state not found. Run 'init' first.");
+        return;
+    }
+    const frameworkDir = getFrameworkDir();
+    const memoryPath = getMemoryPath();
+    const pathsMap = getConfiguredPaths();
+    UI.success(`Using framework dir: ${frameworkDir}`);
+    // --- Contract Gate (Phase 2+ Discipline) ---
+    if (["PHASE_2", "PHASE_3", "PHASE_4"].includes(state.phase)) {
+        console.warn("\n📝 Validating API Contracts (Phase 2+ Required)...");
+        try {
+            const contractOk = await verifyApiContractCommand({ silent: true });
+            if (!contractOk) {
+                UI.error("Contract verification FAILED! You cannot be in Phase 2+ with unverified contracts.");
+                issues++;
+            }
+            else {
+                UI.success("API Contracts verified and sealed.");
+            }
+        }
+        catch {
+            UI.error("Error during contract verification.");
+            issues++;
+        }
+    }
+    let knowledgeDir = "knowledge";
+    if (frameworkDir === ".github")
+        knowledgeDir = "instructions";
+    const constitutionPath = fs.existsSync(path.join(process.cwd(), "ATABEY.md")) ? "ATABEY.md" : path.join(frameworkDir, "ATABEY.md");
+    const rootPandaPath = path.join(process.cwd(), "panda.config.ts");
+    const appPandaPath = path.join(pathsMap.frontend, "panda.config.ts");
+    if (fs.existsSync(rootPandaPath)) {
+        UI.error(`Panda CSS config must NOT be at the root directory! Move it to '${pathsMap.frontend}/panda.config.ts'.`);
+        issues++;
+    }
+    const isFrameworkDevelopment = isFrameworkDevelopmentRepo();
+    const checks = [
+        { name: "Constitution (ATABEY.md)", path: constitutionPath },
+        { name: "Memory (PROJECT_MEMORY.md)", path: path.relative(process.cwd(), memoryPath) },
+        { name: "Command Map (cli-commands.json)", path: path.join(frameworkDir, "cli-commands.json") },
+        { name: "Framework Config (config.json)", path: path.join(frameworkDir, "config.json") },
+        { name: "Agent Status (STATUS.md)", path: path.join(frameworkDir, "STATUS.md") },
+        { name: "MCP Config (mcp.json)", path: "mcp.json" },
+        { name: "ESLint Config (eslint.config.js)", path: "eslint.config.js", optional: !isFrameworkDevelopment },
+        { name: "ESLint Standards", path: path.join(frameworkDir, `${knowledgeDir}/eslint-standards.md`) },
+        { name: "CRUD Governance Standards", path: path.join(frameworkDir, `${knowledgeDir}/crud-governance.md`) },
+        { name: "Architecture Standards", path: path.join(frameworkDir, `${knowledgeDir}/architecture-standards.md`) },
+        { name: "Frontend Standards", path: path.join(frameworkDir, `${knowledgeDir}/frontend-standards.md`) },
+        { name: "Vite Standards", path: path.join(frameworkDir, `${knowledgeDir}/vite-standards.md`), optional: true },
+        { name: "Next.js Standards", path: path.join(frameworkDir, `${knowledgeDir}/nextjs-standards.md`), optional: true },
+        { name: "Tailwind Standards", path: path.join(frameworkDir, `${knowledgeDir}/tailwind-standards.md`), optional: true },
+        { name: "Mobile Standards", path: path.join(frameworkDir, `${knowledgeDir}/mobile-standards.md`) },
+        { name: "Security Standards", path: path.join(frameworkDir, `${knowledgeDir}/security-standards.md`) },
+        { name: "Quality & Discipline Standards", path: path.join(frameworkDir, `${knowledgeDir}/quality-standards.md`) },
+        { name: "Logging & Secrets Standards", path: path.join(frameworkDir, `${knowledgeDir}/logging-and-secrets.md`) },
+        { name: "Testing Standards", path: path.join(frameworkDir, `${knowledgeDir}/testing-standards.md`) },
+        { name: "i18n Standards", path: path.join(frameworkDir, `${knowledgeDir}/i18n-standards.md`) },
+        { name: ".env.example", path: ".env.example" },
+        ...(isFrameworkDevelopment ? [{ name: "MCP Server", path: "framework-mcp/package.json" }] : []),
+        { name: "Panda CSS Config", path: appPandaPath, optional: true },
+    ];
+    for (const check of checks) {
+        const fullPath = path.isAbsolute(check.path) ? check.path : path.join(process.cwd(), check.path);
+        if (fs.existsSync(fullPath)) {
+            UI.success(`${check.name} found.`);
+        }
+        else {
+            if (check.optional) {
+                UI.warning(`${check.name} MISSING! (${check.path}) [Optional]`);
+            }
+            else {
+                UI.error(`${check.name} MISSING! (${check.path})`);
+                issues++;
+            }
+        }
+    }
+    // Agent Army Check
+    console.warn("\n[SECURITY]  Running Agent Army Compliance...");
+    try {
+        const validatorScript = getValidatorPath();
+        execSync(`node "${validatorScript}"`, { stdio: "pipe" });
+        UI.success("Agent Army AL validation PASSED.");
+    }
+    catch (error) {
+        const err = error;
+        UI.error(`Agent Army AL validation FAILED: ${err.message}`);
+        if (err.stderr)
+            console.error(err.stderr.toString());
+        issues++;
+    }
+    // Agent Documentation Check (Live Integrity)
+    console.warn("\n📚 Checking Agent Integrity (Instructions)...");
+    const projectRoot = process.cwd();
+    const activeLayouts = detectActiveAgentLayouts(projectRoot);
+    if (activeLayouts.length > 0) {
+        UI.success(`Active agent layout(s): ${activeLayouts.join(", ")}`);
+        ALL_AGENTS.forEach((agent) => {
+            const found = findAgentInstruction(projectRoot, agent.name);
+            if (found) {
+                UI.success(`Instructions for @${agent.name} found at ${found}`);
+            }
+            else {
+                UI.error(`Instructions for @${agent.name} MISSING! Run 'atabey init' to scaffold.`);
+                issues++;
+            }
+        });
+    }
+    else {
+        UI.warning("No active agent instruction directory detected. Run 'atabey init [adapter]' first.");
+        issues++;
+    }
+    // Code Quality - Using the new Compliance Scanner
+    console.warn("\n⚖️  Checking Discipline (Code Quality)...");
+    const complianceIssues = scanProjectCompliance();
+    if (complianceIssues.length > 0) {
+        complianceIssues.forEach(issue => {
+            UI.error(`${issue.rule} in ${issue.file}:${issue.line}`);
+        });
+        issues += complianceIssues.length;
+    }
+    else {
+        UI.success("No compliance issues detected.");
+    }
+    const rootTestFiles = checkRootTestFiles();
+    if (rootTestFiles.length > 0) {
+        UI.warning(`Test files found in the root directory: ${rootTestFiles.join(", ")}. It is recommended to place all test files under the 'tests/' folder or application-specific directories.`);
+    }
+    try {
+        UI.intent("Type Check", "Running 'npx tsc --noEmit' (this may take a few seconds)...");
+        execSync("npx tsc --noEmit", { stdio: "pipe" });
+        UI.success("TypeScript type check PASSED.");
+    }
+    catch (err) {
+        UI.warning("TypeScript type check FAILED or 'tsc' not found. This is a non-blocking warning for lightweight checks.");
+        logger.debug("npx tsc --noEmit check failed", err);
+    }
+    if (issues === 0) {
+        UI.success("\n[START] All systems green! Agent Atabey is ready.");
+    }
+    else {
+        UI.error(`\n[WARN]  Found ${issues} issues. Please fix them.`);
+        process.exit(1);
+    }
+}
+function checkRootTestFiles() {
+    const rootDir = process.cwd();
+    if (!fs.existsSync(rootDir))
+        return [];
+    const files = fs.readdirSync(rootDir);
+    const testFiles = [];
+    for (const file of files) {
+        const fullPath = path.join(rootDir, file);
+        try {
+            if (fs.statSync(fullPath).isFile()) {
+                if (file.includes(".test.") || file.includes(".spec.")) {
+                    testFiles.push(file);
+                }
+            }
+        }
+        catch (err) {
+            logger.debug(`Failed to stat file ${fullPath} in checkRootTestFiles`, err);
+        }
+    }
+    return testFiles;
+}