atabey 0.0.1

package/src/modules/adapters/definitions.ts

@@ -0,0 +1,171 @@
+import path from "path";
+import type { AdapterConfig, AdapterId } from "./types.js";
+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
+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);
+    }
+);
+
+// 🚀 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 as { mcpServers: Record<string, unknown> };
+            const mcpEntry = block.mcpServers["atabey"] as Record<string, unknown>;
+            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");
+    }
+);
+
+// 🤖 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
+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`);
+    }
+);
+
+// 💡 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 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
+registry.register(
+    {
+        id: "antigravity-cli",
+        frameworkDir: ".antigravity",
+        shimFile: "AGENTS.md",
+        shimTemplate: "src/cli/shims/antigravity-cli.md",
+        role: "general",
+        templateDir: ".atabey",
+        nestedDirs: ["agents", "plugins", "rules"],
+        agentsDir: ".antigravity/agents",
+        agentsExt: ".md"
+    },
+    (projectRoot, mcpBlock) => {
+        const frameworkDir = ".antigravity";
+        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: Record<AdapterId, AdapterConfig> = registry.getConfigs();
+
+/**
+ * Post-Initialization Handlers for specific adapters
+ */
+export const POST_INIT_HANDLERS: Record<AdapterId, (projectRoot: string, mcpBlock: unknown) => void> = registry.getHandlers();

package/src/modules/adapters/registry.ts

@@ -0,0 +1,27 @@
+import { AdapterId, AdapterConfig } from "./types.js";
+
+type PostInitHandler = (projectRoot: string, mcpBlock: unknown) => void;
+
+class AdapterRegistry {
+    private configs: Map<string, AdapterConfig> = new Map();
+    private handlers: Map<string, PostInitHandler> = new Map();
+
+    register(config: AdapterConfig, handler: PostInitHandler) {
+        this.configs.set(config.id, config);
+        this.handlers.set(config.id, handler);
+    }
+
+    getConfigs(): Record<string, AdapterConfig> {
+        return Object.fromEntries(this.configs);
+    }
+
+    getHandlers(): Record<string, PostInitHandler> {
+        return Object.fromEntries(this.handlers);
+    }
+
+    getIds(): AdapterId[] {
+        return Array.from(this.configs.keys()) as AdapterId[];
+    }
+}
+
+export const registry = new AdapterRegistry();

package/src/modules/adapters/shared.ts

@@ -0,0 +1,120 @@
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { execSync } from "child_process";
+import { writeJsonFile, writeTextFile } from "../../shared/fs.js";
+import { ALL_AGENTS, toAntigravityJson } from "../agents/definitions.js";
+import { CORE_SKILLS } from "../skills/definitions.js";
+import { getPackageRoot } from "../../cli/utils/pkg.js";
+import { logger } from "../../shared/logger.js";
+
+export function registerGlobalAntigravityPlugins(mcpBlock: unknown): void {
+    // Allow overriding via env var for different OS/Gemini CLI versions
+    const defaultGlobalDir = path.join(os.homedir(), ".gemini/antigravity-cli");
+    const customDir = process.env["ANTIGRAVITY_GLOBAL_DIR"];
+    const targets = [customDir ?? defaultGlobalDir];
+    const baseKnowledgeDir = path.join(getPackageRoot(), "templates/standards");
+
+    for (const globalDir of targets) {
+        try {
+            // Write directly under directory
+            fs.mkdirSync(globalDir, { recursive: true });
+            writeJsonFile(path.join(globalDir, "mcp.json"), mcpBlock);
+            writeJsonFile(path.join(globalDir, "mcp_config.json"), mcpBlock);
+            logger.info(`Antigravity MCP registered → ${globalDir}/`);
+
+            // Global Plugin configuration under plugins/atabey/
+            const globalPluginDir = path.join(globalDir, "plugins/atabey");
+            fs.mkdirSync(globalPluginDir, { recursive: true });
+
+            // plugin.json marker
+            writeJsonFile(path.join(globalPluginDir, "plugin.json"), {
+                name: "atabey",
+                version: "1.0.0",
+                description: "Agent Atabey AI Orchestration framework"
+            });
+
+            // MCP Server configs inside the plugin
+            writeJsonFile(path.join(globalPluginDir, "mcp.json"), mcpBlock);
+            writeJsonFile(path.join(globalPluginDir, "mcp_config.json"), mcpBlock);
+
+            // Scaffold 13 agents
+            const agentsBaseDir = path.join(globalPluginDir, "agents");
+            fs.mkdirSync(agentsBaseDir, { recursive: true });
+
+            // Also write directly to ~/.gemini/antigravity-cli/agents/ so the CLI's
+            // workspace/global agent discovery finds them without the plugins/ prefix.
+            const globalAgentsDir = path.join(globalDir, "agents");
+            fs.mkdirSync(globalAgentsDir, { recursive: true });
+
+            for (const ag of ALL_AGENTS) {
+                const agentJson = toAntigravityJson(ag, baseKnowledgeDir);
+
+                // 1. Nested format inside plugin: plugins/atabey/agents/{name}/agent.json
+                const nestedAgentDir = path.join(agentsBaseDir, ag.name);
+                fs.mkdirSync(nestedAgentDir, { recursive: true });
+                writeTextFile(path.join(nestedAgentDir, "agent.json"), agentJson);
+
+                // 2. Flat format inside plugin: plugins/atabey/agents/{name}.json
+                writeTextFile(path.join(agentsBaseDir, `${ag.name}.json`), agentJson);
+
+                // 3. Direct global agents root — THIS is what Antigravity CLI reads:
+                //    ~/.gemini/antigravity-cli/agents/{name}/agent.json
+                const globalNestedDir = path.join(globalAgentsDir, ag.name);
+                fs.mkdirSync(globalNestedDir, { recursive: true });
+                writeTextFile(path.join(globalNestedDir, "agent.json"), agentJson);
+
+                // 4. Flat global format as fallback
+                writeTextFile(path.join(globalAgentsDir, `${ag.name}.json`), agentJson);
+            }
+
+            // Scaffold skills
+            const skillsDir = path.join(globalPluginDir, "skills");
+            fs.mkdirSync(skillsDir, { recursive: true });
+            for (const [key, skill] of Object.entries(CORE_SKILLS)) {
+                const skillContent = `# 🛠️ Skill — ${skill.name}\n\n${skill.mandates.join("\n")}\n`;
+                writeTextFile(path.join(skillsDir, `${key.toLowerCase()}.md`), skillContent);
+            }
+
+            // Scaffold rules
+            const rulesDir = path.join(globalPluginDir, "rules");
+            fs.mkdirSync(rulesDir, { recursive: true });
+            for (const ag of ALL_AGENTS) {
+                const ruleContent = `# 🎖️ Agent Atabey — @${ag.name} (${ag.displayName})
+
+You are the **${ag.displayName}** of the Agent Atabey Army.
+
+## 🤖 Specialist Directive (Role: @${ag.name})
+${ag.instructions.identity}
+
+### 🎯 Mission
+${ag.instructions.mission}
+
+### 📜 Discipline Rules
+${ag.instructions.rules.map(r => `- ${r}`).join("\n")}
+
+## 🛡️ Core Mandates
+- **Surgical Precision:** Enforce replace_text / replace_file_content for all code modifications.
+- **Traceability:** Inherit and pass the active Trace ID across all delegations.
+- **Approval Signature:** High-risk actions require manager approval signature.
+`;
+                writeTextFile(path.join(rulesDir, `${ag.name}.md`), ruleContent);
+            }
+
+            // Scaffold optional empty hooks.json
+            writeJsonFile(path.join(globalPluginDir, "hooks.json"), {});
+
+            logger.info(`Antigravity Plugin registered → ${globalPluginDir}/`);
+
+            try {
+                execSync(`agy plugin install "${globalPluginDir}"`, { stdio: "ignore" });
+                logger.info("Antigravity Plugin installed in CLI.");
+            } catch {
+                // Ignore if agy is not in PATH or fails
+            }
+
+        } catch (e) {
+            logger.warn(`Failed to register plugin/MCP in ${globalDir}`, e);
+        }
+    }
+}

package/src/modules/adapters/types.ts

@@ -0,0 +1,16 @@
+export const ADAPTER_IDS = ["gemini", "claude", "grok", "cursor", "codex", "local", "antigravity-cli"] as const;
+export type AdapterId = (typeof ADAPTER_IDS)[number];
+
+export type AdapterRole = "commander" | "architect" | "researcher" | "implementer" | "general";
+
+export interface AdapterConfig {
+  id: AdapterId;
+  frameworkDir: string;
+  shimFile: string;
+  shimTemplate: string;
+  role: AdapterRole;
+  templateDir: ".atabey";
+  nestedDirs?: string[];
+  agentsDir?: string; // Directory to write individual agents/rules, relative to projectRoot
+  agentsExt?: string; // Extensions for agent files (.md or .mdc)
+}