atabey 0.0.13 → 0.0.14

package/framework-mcp/dist/src/modules/engines/risk-engine.js

@@ -0,0 +1,105 @@
+/**
+ * [SECURITY] Risk Engine (The Guardian)
+ * Calculates the danger level of a proposed task or operation.
+ */
+export class RiskEngine {
+    static HIGH_RISK_KEYWORDS = [
+        { word: "delete", weight: 40 },
+        { word: "drop", weight: 50 },
+        { word: "truncate", weight: 50 },
+        { word: "rm -rf", weight: 60 },
+        { word: "purge", weight: 40 },
+        { word: "format", weight: 50 },
+        { word: "force", weight: 20 },
+    ];
+    static SENSITIVE_PATHS = [
+        { pattern: /\.env/i, weight: 50 },
+        { pattern: /config/i, weight: 20 },
+        { pattern: /database/i, weight: 30 },
+        { pattern: /auth/i, weight: 30 },
+        { pattern: /security/i, weight: 30 },
+        { pattern: /atabey/i, weight: 40 }, // Framework protection
+    ];
+    /**
+     * Assesses the risk of a natural language task or command string.
+     */
+    static assessTaskRisk(task) {
+        const factors = [];
+        let totalScore = 0;
+        // 1. Keyword Analysis
+        for (const { word, weight } of this.HIGH_RISK_KEYWORDS) {
+            if (new RegExp(`\\b${word}\\b`, "i").test(task)) {
+                factors.push({
+                    factor: `Keyword: ${word}`,
+                    score: weight,
+                    description: `Detected high-risk keyword '${word}' in task description.`
+                });
+                totalScore += weight;
+            }
+        }
+        // 2. Path Sensitivity (if paths are mentioned in the task)
+        for (const { pattern, weight } of this.SENSITIVE_PATHS) {
+            if (pattern.test(task)) {
+                factors.push({
+                    factor: `Sensitive Path: ${pattern.source}`,
+                    score: weight,
+                    description: `Task involves access to sensitive path or pattern: ${pattern.source}`
+                });
+                totalScore += weight;
+            }
+        }
+        // 3. Complexity Risk (Length of task as a proxy)
+        if (task.length > 300) {
+            const score = 10;
+            factors.push({
+                factor: "High Complexity",
+                score,
+                description: "Task description is unusually long, increasing the chance of misunderstanding."
+            });
+            totalScore += score;
+        }
+        return this.finalizeAssessment(totalScore, factors);
+    }
+    /**
+     * Assesses risk based on a proposed file change.
+     */
+    static assessChangeRisk(filePath, operation) {
+        const factors = [];
+        let totalScore = 0;
+        // 1. Operation Weight
+        const opWeights = { write: 30, replace: 5, patch: 10 };
+        totalScore += opWeights[operation];
+        factors.push({
+            factor: `Operation: ${operation}`,
+            score: opWeights[operation],
+            description: `A '${operation}' operation is inherently riskier than a surgical 'replace'.`
+        });
+        // 2. File Path Risk
+        for (const { pattern, weight } of this.SENSITIVE_PATHS) {
+            if (pattern.test(filePath)) {
+                factors.push({
+                    factor: `Sensitive File: ${filePath}`,
+                    score: weight,
+                    description: "Modifying a sensitive file is high risk."
+                });
+                totalScore += weight;
+            }
+        }
+        return this.finalizeAssessment(totalScore, factors);
+    }
+    static finalizeAssessment(totalScore, factors) {
+        let severity = "LOW";
+        if (totalScore >= 80)
+            severity = "CRITICAL";
+        else if (totalScore >= 50)
+            severity = "HIGH";
+        else if (totalScore >= 20)
+            severity = "MEDIUM";
+        return {
+            totalScore: Math.min(totalScore, 100),
+            severity,
+            factors,
+            requiresApproval: totalScore >= 60
+        };
+    }
+}

package/framework-mcp/dist/src/modules/engines/routing-engine.js

@@ -0,0 +1,408 @@
+import fs from "fs";
+import path from "path";
+import { getFrameworkDir } from "../../cli/utils/memory.js";
+import { logger } from "../../shared/logger.js";
+import { AtabeyStorage } from "../../shared/storage.js";
+import { asAgentID, asTraceID } from "../../shared/types.js";
+import { ALL_AGENTS } from "../agents/definitions.js";
+export class RoutingEngine {
+    /**
+     * Advanced Routing Engine — analyzes task descriptions,
+     * selects the most suitable agent, and determines subtasks.
+     *
+     * Uses real TF-IDF scoring: term frequency in the task weighted by
+     * inverse document frequency across the full agent candidate corpus.
+     */
+    static resolveAgent(taskDescription) {
+        return this.resolveWithDetails(taskDescription).agent;
+    }
+    /**
+     * Returns detailed routing result — score, confidence, reasoning, subTasks
+     */
+    static resolveWithDetails(taskDescription) {
+        const textLower = taskDescription.toLowerCase();
+        const tokens = this.tokenize(textLower);
+        const candidates = this.getCandidates();
+        let bestAgent = "@backend";
+        let bestScore = 0;
+        let bestReasoning = "";
+        let bestSubTasks = [];
+        for (const candidate of candidates) {
+            let score = 0;
+            const matches = [];
+            // 1. Specialty matching (weighted TF-IDF)
+            for (const [specialty, weight] of Object.entries(candidate.specialties)) {
+                const specTokens = this.tokenize(specialty.toLowerCase());
+                for (const token of tokens) {
+                    if (specTokens.some(st => token.includes(st) || st.includes(token))) {
+                        score += weight * this.calculateTfIdf(token, tokens, candidates);
+                        matches.push(specialty);
+                    }
+                }
+            }
+            // 2. Role matching
+            const roleTokens = this.tokenize(candidate.role.toLowerCase());
+            for (const token of tokens) {
+                if (roleTokens.some(rt => token.includes(rt) || rt.includes(token))) {
+                    score += 3; // Role match bonus
+                    matches.push(`role:${candidate.role}`);
+                }
+            }
+            // 3. DisplayName matching
+            const nameTokens = this.tokenize(candidate.displayName.toLowerCase());
+            for (const token of tokens) {
+                if (nameTokens.some(nt => token.includes(nt) || nt.includes(token))) {
+                    score += 2;
+                    matches.push(`name:${candidate.displayName}`);
+                }
+            }
+            // Capability bonus (more capable agents get priority)
+            score += (candidate.capability - 5) * 0.5;
+            if (score > bestScore) {
+                bestScore = score;
+                bestAgent = candidate.agent;
+                bestReasoning = matches.length > 0
+                    ? `Matching fields: ${[...new Set(matches)].join(", ")}`
+                    : "Selected based on general capability";
+                bestSubTasks = this.generateSubTasks(candidate.agent, taskDescription);
+            }
+        }
+        // Static fallback (if nothing matches)
+        if (bestScore === 0) {
+            const fallback = this.fallbackRouting(tokens);
+            bestAgent = fallback.agent;
+            bestReasoning = fallback.reasoning;
+            bestSubTasks = fallback.subTasks;
+        }
+        const confidence = bestScore > 15 ? "high"
+            : bestScore > 7 ? "medium"
+                : "low";
+        return {
+            agent: bestAgent,
+            score: Math.round(bestScore * 10) / 10,
+            confidence,
+            reasoning: bestReasoning,
+            subTasks: bestSubTasks,
+        };
+    }
+    /**
+     * Automatically splits the task into subtasks
+     */
+    static planTask(taskDescription) {
+        const result = this.resolveWithDetails(taskDescription);
+        const plan = [
+            `>> Task: ${taskDescription}`,
+            `>> Assigned to: ${result.agent}`,
+            `>> Confidence: ${result.confidence.toUpperCase()} (Score: ${result.score})`,
+            `>> Reason: ${result.reasoning}`,
+            "",
+            ">> Subtasks:",
+            ...result.subTasks.map((t, i) => `  ${i + 1}. ${t}`),
+            "",
+            ">> Quality Check:",
+            `  - When ${result.agent} completes, @quality will review`,
+            `  - If @quality rejects, the task returns to ${result.agent}`,
+        ];
+        return plan;
+    }
+    // ─── Private Helpers ────────────────────────────────────────────────
+    static tokenize(text) {
+        return text
+            .replace(/[^a-z0-9çşıöğü ]/g, " ")
+            .split(/\s+/)
+            .filter(t => t.length > 1);
+    }
+    /**
+     * Real TF-IDF calculation: term frequency × inverse document frequency.
+     * IDF = log(N / (df + 1) + 1) where N = total candidates, df = candidates containing the term.
+     */
+    static calculateTfIdf(term, tokens, allCandidates) {
+        // TF: normalized term frequency in the task
+        const tf = tokens.filter(t => t === term).length / Math.max(tokens.length, 1);
+        // IDF: log(N / df + 1) where N = total candidates, df = candidates containing the term
+        const N = allCandidates.length;
+        const df = allCandidates.filter(c => Object.keys(c.specialties).some(s => s.toLowerCase().includes(term))).length;
+        const idf = Math.log(N / (df + 1) + 1);
+        return (1 + tf) * idf;
+    }
+    static fallbackRouting(tokens) {
+        const text = tokens.join(" ");
+        if (tokens.some(t => ["frontend", "ui", "page", "css", "html", "react", "component", "button", "form", "modal", "table", "interface"].includes(t))) {
+            return {
+                agent: "@frontend",
+                reasoning: "Frontend/UI keywords detected",
+                subTasks: this.generateSubTasks("@frontend", text),
+            };
+        }
+        if (tokens.some(t => ["security", "auth", "token", "encrypt", "login"].includes(t))) {
+            return {
+                agent: "@security",
+                reasoning: "Security keywords detected",
+                subTasks: this.generateSubTasks("@security", text),
+            };
+        }
+        if (tokens.some(t => ["database", "migration", "sql", "schema", "table", "index", "query"].includes(t))) {
+            return {
+                agent: "@database",
+                reasoning: "Database keywords detected",
+                subTasks: this.generateSubTasks("@database", text),
+            };
+        }
+        if (tokens.some(t => ["docker", "ci", "cd", "deploy", "devops", "infra", "server", "nginx"].includes(t))) {
+            return {
+                agent: "@devops",
+                reasoning: "DevOps/Infra keywords detected",
+                subTasks: this.generateSubTasks("@devops", text),
+            };
+        }
+        if (tokens.some(t => ["mobile", "react native", "expo", "ios", "android"].includes(t))) {
+            return {
+                agent: "@mobile",
+                reasoning: "Mobile keywords detected",
+                subTasks: this.generateSubTasks("@mobile", text),
+            };
+        }
+        if (tokens.some(t => ["architect", "design", "architecture", "contract", "structure"].includes(t))) {
+            return {
+                agent: "@architect",
+                reasoning: "Architecture/design keywords detected",
+                subTasks: this.generateSubTasks("@architect", text),
+            };
+        }
+        if (tokens.some(t => ["analysis", "analyst", "requirement", "contract", "validate"].includes(t))) {
+            return {
+                agent: "@analyst",
+                reasoning: "Analysis/requirement keywords detected",
+                subTasks: this.generateSubTasks("@analyst", text),
+            };
+        }
+        return {
+            agent: "@backend",
+            reasoning: "Default routing to backend (most general capability)",
+            subTasks: this.generateSubTasks("@backend", text),
+        };
+    }
+    static generateSubTasks(agent, taskDescription) {
+        const base = [
+            `[*] ${agent}: Analyze and plan the task`,
+            `[>] ${taskDescription}`,
+            "[*] Write and run tests",
+            "[*] Notify @quality for QA review",
+        ];
+        const agentSpecific = {
+            "@manager": [
+                "[*] Analyze task and break into subtasks",
+                "[*] Identify suitable agents and distribute tasks",
+                "[*] Monitor progress and manage quality gate",
+            ],
+            "@backend": [
+                "[*] Create Controller-Service-Repository layers",
+                "[*] Update API contracts",
+                "[*] Integrate database operations",
+            ],
+            "@frontend": [
+                "[*] Create UI components in atomic structure",
+                "[*] Apply responsive design",
+                "[*] Integrate with API",
+            ],
+            "@quality": [
+                "[*] Run compliance check (check_compliance)",
+                "[*] Run lint check",
+                "[*] Verify test coverage",
+                "[*] Report approval/rejection to @manager",
+            ],
+            "@database": [
+                "[*] Prepare migration file",
+                "[*] Optimize queries",
+                "[*] Define index strategy",
+            ],
+            "@security": [
+                "[*] Run security vulnerability scan",
+                "[*] Verify auth/encryption controls",
+                "[*] Check secret management",
+            ],
+            "@devops": [
+                "[*] Prepare Docker configuration",
+                "[*] Update CI/CD pipeline",
+                "[*] Check environment variables",
+            ],
+            "@mobile": [
+                "[*] Create React Native components",
+                "[*] Apply offline-first architecture",
+                "[*] Implement SafeArea and responsive controls",
+            ],
+            "@explorer": [
+                "[*] Explore and map the codebase",
+                "[*] Analyze dependencies",
+                "[*] Send report to @manager",
+            ],
+            "@git": [
+                "[*] Define branch strategy",
+                "[*] Prepare commit messages with Trace ID",
+                "[*] Perform rebase/merge operations if needed",
+            ],
+        };
+        const specific = agentSpecific[agent] || [];
+        return [...specific, ...base];
+    }
+    /**
+     * Quality feedback loop — retries if @quality rejects
+     * Uses real MCP calls, not simulations.
+     */
+    static async qualityLoop(agent, taskDescription, maxRetries = 3) {
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            logger.info(`[RETRY] Attempt ${attempt}/${maxRetries}: ${agent} running...`, {
+                agent,
+                attempt,
+                maxRetries,
+                task: taskDescription.substring(0, 100),
+            });
+            // Agent runs via MCP call
+            const result = await this.runAgent(agent, taskDescription);
+            // Quality check via MCP
+            const qualityResult = await this.runQualityCheck(result);
+            if (qualityResult.passed) {
+                logger.info(`[OK] Quality check PASSED (attempt ${attempt})`, { agent, attempt });
+                return { success: true, attempts: attempt };
+            }
+            logger.warn(`[FAIL] Quality check FAILED: ${qualityResult.reason}`, {
+                agent,
+                attempt,
+                reason: qualityResult.reason,
+            });
+            logger.info(`[RETRY] ${agent} fixing errors...`, { agent, attempt });
+        }
+        logger.error(`[FAIL] ${maxRetries} attempts exhausted. Human intervention required.`, {
+            agent,
+            maxRetries,
+            task: taskDescription.substring(0, 100),
+        });
+        return { success: false, attempts: maxRetries };
+    }
+    /**
+     * Runs the agent through the Hermes messaging system.
+     *
+     * Flow:
+     * 1. Write DELEGATION message to agent's queue (Storage.saveMessage)
+     * 2. Wait for agent response (polling, max 30 seconds)
+     * 3. Parse response and return as output
+     */
+    static async runAgent(agent, task) {
+        const agentName = agent.replace("@", "");
+        const traceId = `T-${Date.now()}-${Math.random().toString(36).substring(2, 8)}`;
+        const messagePayload = JSON.stringify({
+            type: "DELEGATION",
+            task,
+            traceId,
+            from: "@manager",
+        });
+        AtabeyStorage.saveMessage({
+            from: asAgentID("@manager"),
+            to: asAgentID(agent),
+            category: "DELEGATION",
+            content: messagePayload,
+            traceId: asTraceID(traceId),
+            timestamp: new Date().toISOString(),
+            status: "PENDING",
+            priority: "HIGH",
+            requiresApproval: false,
+        });
+        logger.info(`[HERMES] Delegation sent to ${agent} (trace: ${traceId})`);
+        // Poll for response (max 30 seconds)
+        const maxAttempts = 60;
+        const pollInterval = 500;
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+            const messages = AtabeyStorage.getPendingMessages();
+            const response = messages.find(m => m.from.replace("@", "") === agentName
+                && m.category === "RESPONSE"
+                && m.traceId === traceId
+                && m.status === "PENDING");
+            if (response) {
+                if (response.id !== undefined) {
+                    AtabeyStorage.updateMessageStatus(response.id, "PROCESSED");
+                }
+                logger.info(`[HERMES] Response received from ${agent} (trace: ${traceId})`);
+                return response.content;
+            }
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+        }
+        const timeoutMsg = `[TIMEOUT] ${agent} did not respond within 30s`;
+        logger.warn(`[HERMES] ${timeoutMsg} (trace: ${traceId})`);
+        return timeoutMsg;
+    }
+    /**
+     * Runs quality control through the real QualityGate.
+     *
+     * Flow:
+     * 1. QualityGate.check() for compliance + lint + test + content validation
+     * 2. Aggregate results
+     */
+    static async runQualityCheck(result) {
+        const { QualityGate } = await import("./quality-gate.js");
+        const qualityResult = await QualityGate.check("@quality", result, "Quality check via routing engine");
+        return {
+            passed: qualityResult.passed,
+            reason: qualityResult.reason,
+        };
+    }
+    static getCandidates() {
+        const frameworkDir = getFrameworkDir();
+        const registryDir = path.join(frameworkDir, "registry");
+        let candidates = [];
+        // 1. Control Plane Registry (actively registered agents)
+        if (fs.existsSync(registryDir)) {
+            const registryFiles = fs.readdirSync(registryDir).filter(f => f.endsWith("_active.json"));
+            for (const file of registryFiles) {
+                try {
+                    const data = JSON.parse(fs.readFileSync(path.join(registryDir, file), "utf8"));
+                    if (data.agent && data.specialties) {
+                        candidates.push({
+                            agent: data.agent,
+                            specialties: data.specialties,
+                            displayName: data.displayName || data.agent,
+                            role: data.role || "",
+                            capability: data.capability || 8,
+                            tier: data.tier || "core",
+                        });
+                    }
+                }
+                catch (err) {
+                    logger.debug(`Failed to parse registry file: ${file}`, err);
+                }
+            }
+        }
+        // 2. Built-in agent definitions
+        if (candidates.length === 0) {
+            candidates = ALL_AGENTS.map(ag => ({
+                agent: ag.name.startsWith("@") ? ag.name : `@${ag.name}`,
+                specialties: ag.specialties ?? this.defaultSpecialties(ag.name),
+                displayName: ag.displayName,
+                role: ag.role,
+                capability: ag.capability,
+                tier: ag.tier,
+            }));
+        }
+        return candidates;
+    }
+    /**
+     * Default values for agents without a specialties field
+     */
+    static defaultSpecialties(name) {
+        const defaults = {
+            manager: { orchestration: 10, governance: 10, delegation: 10, audit: 8, planning: 9 },
+            architect: { design: 10, contract: 9, architecture: 10, types: 9, planning: 8 },
+            backend: { backend: 10, api: 9, logic: 9, service: 8, database: 7, test: 8 },
+            frontend: { frontend: 10, ui: 10, css: 9, html: 9, react: 9, responsive: 8 },
+            mobile: { mobile: 10, "react native": 9, expo: 8, offline: 8, accessibility: 7 },
+            quality: { audit: 10, compliance: 10, lint: 9, test: 9, coverage: 8 },
+            database: { database: 10, migration: 9, sql: 9, schema: 8, index: 8 },
+            security: { security: 10, auth: 9, encryption: 8, audit: 9, token: 8 },
+            devops: { devops: 10, docker: 9, ci: 9, deploy: 9, infra: 8 },
+            analyst: { analysis: 10, contract: 9, requirement: 9, validation: 8, documentation: 7 },
+            native: { native: 9, desktop: 8, "os-level": 8, security: 8 },
+            explorer: { discovery: 10, mapping: 9, dependency: 8, recon: 8 },
+            git: { git: 10, version: 9, commit: 8, branching: 8, traceability: 8 },
+        };
+        return defaults[name] || { general: 5 };
+    }
+}

package/framework-mcp/dist/src/modules/engines/types.js

@@ -0,0 +1 @@
+export {};

package/framework-mcp/dist/src/modules/providers/definitions.js

@@ -0,0 +1,140 @@
+import path from "path";
+import { addMcpServerToClaude, findClaudeConfigPath } from "../../cli/utils/claude.js";
+import { writeJsonFile } from "../../shared/fs.js";
+import { registerGlobalAntigravityPlugins } from "./shared.js";
+import { registry } from "./registry.js";
+import { UI } from "../../cli/utils/ui.js";
+// ─── Register Core Adapters ──────────────────────────────────────────────────
+// [GEMINI] Gemini
+registry.register({
+    id: "gemini",
+    frameworkDir: ".gemini",
+    shimFile: "GEMINI.md",
+    shimTemplate: "src/cli/shims/gemini.md",
+    role: "commander",
+    templateDir: ".atabey",
+    nestedDirs: ["agents", "rules"],
+    agentsDir: ".gemini/agents",
+    agentsExt: ".md"
+}, (projectRoot, mcpBlock) => {
+    const frameworkDir = ".gemini";
+    writeJsonFile(path.join(projectRoot, frameworkDir, "mcp.json"), mcpBlock);
+    UI.success(`Gemini MCP registered → ${frameworkDir}/mcp.json`);
+    registerGlobalAntigravityPlugins(mcpBlock);
+});
+// [START] Claude
+registry.register({
+    id: "claude",
+    frameworkDir: ".claude",
+    shimFile: "CLAUDE.md",
+    shimTemplate: "src/cli/shims/claude.md",
+    role: "architect",
+    templateDir: ".atabey",
+    nestedDirs: ["agents", "rules"],
+    agentsDir: ".claude/agents",
+    agentsExt: ".md"
+}, (projectRoot, mcpBlock) => {
+    const configPath = findClaudeConfigPath();
+    if (configPath) {
+        const block = mcpBlock;
+        const mcpEntry = block.mcpServers["atabey"];
+        const ok = addMcpServerToClaude(configPath, "atabey", mcpEntry);
+        if (ok)
+            UI.success(`Claude MCP registered → ${configPath}`);
+    }
+    const frameworkDir = ".claude";
+    writeJsonFile(path.join(projectRoot, frameworkDir, "mcp_config.json"), mcpBlock);
+    writeJsonFile(path.join(projectRoot, ".mcp.json"), mcpBlock);
+    UI.success("Claude Code Project MCP → .mcp.json");
+});
+// [AI] Grok
+registry.register({
+    id: "grok",
+    frameworkDir: ".grok",
+    shimFile: "GROK.md",
+    shimTemplate: "src/cli/shims/grok.md",
+    role: "researcher",
+    templateDir: ".atabey",
+    nestedDirs: ["agents", "rules"],
+    agentsDir: ".grok/agents",
+    agentsExt: ".md"
+}, (projectRoot, mcpBlock) => {
+    const frameworkDir = ".grok";
+    writeJsonFile(path.join(projectRoot, frameworkDir, "mcp_config.json"), mcpBlock);
+    UI.success(`Grok MCP → ${frameworkDir}/mcp_config.json`);
+});
+// [CURSOR] Cursor
+registry.register({
+    id: "cursor",
+    frameworkDir: ".cursor",
+    shimFile: "CURSOR.md",
+    shimTemplate: "src/cli/shims/cursor.mdc",
+    role: "implementer",
+    templateDir: ".atabey",
+    nestedDirs: ["rules"],
+    agentsDir: ".cursor/rules",
+    agentsExt: ".mdc"
+}, (projectRoot, mcpBlock) => {
+    const frameworkDir = ".cursor";
+    writeJsonFile(path.join(projectRoot, frameworkDir, "mcp.json"), mcpBlock);
+    UI.success(`Cursor IDE Project MCP → ${frameworkDir}/mcp.json`);
+});
+// [TIP] Codex (Copilot)
+registry.register({
+    id: "codex",
+    frameworkDir: ".agents",
+    shimFile: "copilot-instructions.md",
+    shimTemplate: "src/cli/shims/codex.md",
+    role: "implementer",
+    templateDir: ".atabey",
+    nestedDirs: ["skills", "rules", "instructions"],
+    agentsDir: ".agents/instructions",
+    agentsExt: ".md"
+}, (projectRoot, mcpBlock) => {
+    const frameworkDir = ".agents";
+    writeJsonFile(path.join(projectRoot, frameworkDir, "mcp_config.json"), mcpBlock);
+    writeJsonFile(path.join(projectRoot, ".vscode/mcp.json"), mcpBlock);
+    writeJsonFile(path.join(projectRoot, ".mcp.json"), mcpBlock);
+    UI.success("GitHub Copilot Project MCP → .vscode/mcp.json & .mcp.json");
+});
+// [LOCAL] Local LLM (Ollama / Private AI)
+registry.register({
+    id: "local",
+    frameworkDir: ".atabey",
+    shimFile: "LOCAL_AI.md",
+    shimTemplate: "src/cli/shims/local.md",
+    role: "commander",
+    templateDir: ".atabey",
+    nestedDirs: ["agents", "rules"],
+    agentsDir: ".atabey/agents",
+    agentsExt: ".md"
+}, (projectRoot, mcpBlock) => {
+    const frameworkDir = ".atabey";
+    writeJsonFile(path.join(projectRoot, frameworkDir, "mcp_config.json"), mcpBlock);
+    UI.success(`Local LLM MCP (Ollama/Private AI) registered → ${frameworkDir}/mcp_config.json`);
+});
+// [ANTIGRAVITY] Antigravity
+registry.register({
+    id: "antigravity-cli",
+    frameworkDir: ".agents",
+    shimFile: "AGENTS.md",
+    shimTemplate: "src/cli/shims/antigravity-cli.md",
+    role: "general",
+    templateDir: ".atabey",
+    nestedDirs: ["agents", "plugins", "rules"],
+    agentsDir: ".agents/agents",
+    agentsExt: ".md"
+}, (projectRoot, mcpBlock) => {
+    const frameworkDir = ".agents";
+    writeJsonFile(path.join(projectRoot, frameworkDir, "mcp_config.json"), mcpBlock);
+    UI.success(`Antigravity CLI MCP → ${frameworkDir}/mcp_config.json`);
+    registerGlobalAntigravityPlugins(mcpBlock);
+});
+/**
+ * Mapped Adapter Configurations
+ */
+export const ADAPTER_CONFIGS = registry.getConfigs();
+/**
+ * Post-Initialization Handlers for specific adapters
+ */
+export const POST_INIT_HANDLERS = registry.getHandlers();

package/framework-mcp/dist/src/modules/providers/registry.js

@@ -0,0 +1,18 @@
+class AdapterRegistry {
+    configs = new Map();
+    handlers = new Map();
+    register(config, handler) {
+        this.configs.set(config.id, config);
+        this.handlers.set(config.id, handler);
+    }
+    getConfigs() {
+        return Object.fromEntries(this.configs);
+    }
+    getHandlers() {
+        return Object.fromEntries(this.handlers);
+    }
+    getIds() {
+        return Array.from(this.configs.keys());
+    }
+}
+export const registry = new AdapterRegistry();