atabey 0.0.1

package/framework-mcp/tests/tools/messaging/send_message.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import { handleSendAgentMessage } from "../../../src/tools/messaging/send_message.js";
+import { ToolArgs } from "../../../src/tools/types.js";
+
+const TEST_DIR = path.resolve(__dirname, "../../_temp_messaging_tests");
+const MESSAGES_DIR = path.join(TEST_DIR, ".gemini/messages");
+const BACKEND_LOCK_FILE = path.join(MESSAGES_DIR, "backend.lock");
+
+beforeEach(() => {
+    fs.mkdirSync(TEST_DIR, { recursive: true });
+    // Write a dummy package.json to test directory to lock frameworkDir as .gemini
+    const dummyPkg = {
+        name: "test-pkg",
+        atabey: {
+            frameworkDir: ".gemini"
+        }
+    };
+    fs.writeFileSync(path.join(TEST_DIR, "package.json"), JSON.stringify(dummyPkg, null, 2), "utf8");
+});
+
+afterEach(() => {
+    fs.rmSync(TEST_DIR, { recursive: true, force: true });
+});
+
+describe("Hermes Lock Protocol & Message sending", () => {
+    it("should successfully send message when lock is not present", async () => {
+        const args: ToolArgs = {
+            to: "@backend",
+            from: "@manager",
+            category: "ACTION",
+            content: "Build database models",
+            traceId: "T-123",
+            priority: "HIGH"
+        };
+
+        const result = await handleSendAgentMessage(TEST_DIR, args);
+        expect(result.content[0].text).toContain("✅ Message sent to @backend");
+
+        // Verify the message file contains the sent message
+        const messageFilePath = path.join(MESSAGES_DIR, "backend.json");
+        expect(fs.existsSync(messageFilePath)).toBe(true);
+
+        const content = fs.readFileSync(messageFilePath, "utf8");
+        const msg = JSON.parse(content.trim());
+        expect(msg.from).toBe("@manager");
+        expect(msg.to).toBe("@backend");
+        expect(msg.category).toBe("ACTION");
+        expect(msg.content).toBe("Build database models");
+        expect(msg.traceId).toBe("T-123");
+        expect(msg.priority).toBe("HIGH");
+        expect(msg.status).toBe("PENDING");
+    });
+
+    it("should retry and fail to send message if lock is kept busy", async () => {
+        // Prepare a busy lock file
+        fs.mkdirSync(MESSAGES_DIR, { recursive: true });
+        fs.writeFileSync(BACKEND_LOCK_FILE, "Locked by @test at " + new Date().toISOString(), "utf8");
+
+        const args: ToolArgs = {
+            to: "@backend",
+            from: "@manager",
+            category: "ACTION",
+            content: "Build database models",
+            traceId: "T-123"
+        };
+
+        const startTime = Date.now();
+        const result = await handleSendAgentMessage(TEST_DIR, args);
+        const duration = Date.now() - startTime;
+
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("❌ Could not send message to @backend: Hermes lock is busy.");
+        // Retries takes 20 attempts with 500ms delay -> duration should be at least ~9000ms
+        expect(duration).toBeGreaterThanOrEqual(9000);
+    }, 15000);
+
+    it("should bypass and acquire lock if existing lock is stale (older than 10s)", async () => {
+        fs.mkdirSync(MESSAGES_DIR, { recursive: true });
+        // Set lock file mtime to 15 seconds ago
+        fs.writeFileSync(BACKEND_LOCK_FILE, "Locked by @test at " + new Date().toISOString(), "utf8");
+        const fifteenSecondsAgo = new Date(Date.now() - 15000);
+        fs.utimesSync(BACKEND_LOCK_FILE, fifteenSecondsAgo, fifteenSecondsAgo);
+
+        const args: ToolArgs = {
+            to: "@backend",
+            from: "@manager",
+            category: "ACTION",
+            content: "Build database models",
+            traceId: "T-123"
+        };
+
+        const result = await handleSendAgentMessage(TEST_DIR, args);
+        expect(result.content[0].text).toContain("✅ Message sent to @backend");
+        expect(fs.existsSync(BACKEND_LOCK_FILE)).toBe(false); // Lock should have been unlinked in finally
+    });
+
+    it("should safely resolve concurrent messages and execute them in sequence", async () => {
+        const send1Promise = handleSendAgentMessage(TEST_DIR, {
+            to: "@backend",
+            from: "@manager",
+            category: "ACTION",
+            content: "Job 1",
+            traceId: "T-123"
+        });
+
+        // Delay starting the second call slightly to make sure lock is acquired by Job 1 first
+        await new Promise((resolve) => setTimeout(resolve, 50));
+
+        const send2Promise = handleSendAgentMessage(TEST_DIR, {
+            to: "@backend",
+            from: "@frontend",
+            category: "ACTION",
+            content: "Job 2",
+            traceId: "T-123"
+        });
+
+        const [res1, res2] = await Promise.all([send1Promise, send2Promise]);
+
+        expect(res1.isError).toBeFalsy();
+        expect(res2.isError).toBeFalsy();
+        expect(res1.content[0].text).toContain("✅ Message sent to @backend");
+        expect(res2.content[0].text).toContain("✅ Message sent to @backend");
+
+        // Verify both messages exist in order in the message log file
+        const messageFilePath = path.join(MESSAGES_DIR, "backend.json");
+        const lines = fs.readFileSync(messageFilePath, "utf8").trim().split("\n");
+        expect(lines.length).toBe(2);
+
+        const msg1 = JSON.parse(lines[0]);
+        const msg2 = JSON.parse(lines[1]);
+        expect(msg1.content).toBe("Job 1");
+        expect(msg2.content).toBe("Job 2");
+    });
+});

package/framework-mcp/tests/tools/quality/check_lint.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { handleCheckLint } from "../../../src/tools/quality/check_lint.js";
+import { exec } from "child_process";
+
+vi.mock("child_process");
+
+describe("handleCheckLint", () => {
+    const projectRoot = "/fake/project";
+
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it("should execute the lint command and return output on success", async () => {
+        const args = {};
+        
+        vi.mocked(exec).mockImplementation((_cmd, _opts, callback) => {
+            // @ts-expect-error: Mock implementation callback type is complex
+            callback(null, "All good!", "");
+            return {} as any;
+        });
+
+        const result = await handleCheckLint(projectRoot, args);
+        
+        expect(exec).toHaveBeenCalledWith("npm run lint", { cwd: projectRoot, timeout: 60000 }, expect.any(Function));
+        expect(result.isError).toBeUndefined();
+        expect(result.content[0].text).toContain("All good!");
+    });
+
+    it("should execute the lint command and return output on failure (lint issues found)", async () => {
+        const args = {};
+        const lintErrorOutput = "Error: 2 problems (2 errors, 0 warnings)";
+        
+        vi.mocked(exec).mockImplementation((_cmd, _opts, callback) => {
+            // @ts-expect-error: Mock implementation callback type is complex
+            callback({ code: 1, message: "Lint errors found" }, lintErrorOutput, "");
+            return {} as any;
+        });
+
+        const result = await handleCheckLint(projectRoot, args);
+        
+        expect(exec).toHaveBeenCalledWith("npm run lint", { cwd: projectRoot, timeout: 60000 }, expect.any(Function));
+        expect(result.isError).toBe(true); // Implementation returns isError: true on failure
+        expect(result.content[0].text).toContain(lintErrorOutput);
+    });
+});

package/framework-mcp/tests/tools/shell/run_command.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, afterEach } from "vitest";
+import { handleRunCommand } from "../../../src/tools/shell/run_command.js";
+import { exec } from "child_process";
+
+vi.mock("child_process");
+
+describe("handleRunCommand", () => {
+    const projectRoot = "/fake/project";
+
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+
+    it("should execute an allowed command", async () => {
+        const args = { command: "git status" };
+        
+        vi.mocked(exec).mockImplementation((_cmd, _opts, callback) => {
+            // @ts-expect-error: Mock implementation callback type is complex
+            callback(null, "On branch main", "");
+            return {} as any;
+        });
+
+        const result = await handleRunCommand(projectRoot, args);
+        
+        expect(exec).toHaveBeenCalledWith("git status", { cwd: projectRoot, timeout: 30000 }, expect.any(Function));
+        expect(result.isError).toBeUndefined();
+        expect(result.content[0].text).toContain("On branch main");
+    });
+
+    it("should reject a disallowed command", async () => {
+        const args = { command: "rm -rf /" };
+        const result = await handleRunCommand(projectRoot, args);
+        
+        expect(exec).not.toHaveBeenCalled();
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Command not allowed");
+    });
+
+    it("should handle command failure", async () => {
+        const args = { command: "npm run build" };
+
+        vi.mocked(exec).mockImplementation((_cmd, _opts, callback) => {
+            // @ts-expect-error: Mock implementation callback type is complex
+            callback({ code: 1, message: "Build failed" }, "", "Error details");
+            return {} as any;
+        });
+
+        const result = await handleRunCommand(projectRoot, args);
+
+        expect(exec).toHaveBeenCalledWith("npm run build", { cwd: projectRoot, timeout: 30000 }, expect.any(Function));
+        expect(result.isError).toBe(true);
+        expect(result.content[0].text).toContain("Command failed with exit code 1");
+        expect(result.content[0].text).toContain("Error details");
+    });
+});

package/framework-mcp/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "rootDir": "src",
+    "outDir": "./dist",
+    "strict": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/mcp.json

@@ -0,0 +1,13 @@
+{
+  "mcpServers": {
+    "atabey": {
+      "command": "node",
+      "args": [
+        "framework-mcp/dist/index.js"
+      ],
+      "env": {
+        "ATABEY_PROJECT_ROOT": "."
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "atabey",
+  "version": "0.0.1",
+  "description": "The Supreme AI Governance & Autonomous Orchestration Framework for Enterprise Development. Acts as a Corporate AI Management Assistant.",
+  "author": "Yusuf BEKAR",
+  "license": "MIT",
+  "readme": "README.md",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ysf-bkr/atabey.git"
+  },
+  "homepage": "https://github.com/ysf-bkr/atabey#readme",
+  "bugs": {
+    "url": "https://github.com/ysf-bkr/atabey/issues"
+  },
+  "keywords": [
+    "ai",
+    "governance",
+    "orchestration",
+    "agents",
+    "mcp",
+    "typescript",
+    "framework"
+  ],
+  "workspaces": [
+    "framework-mcp",
+    "apps/*"
+  ],
+  "bin": {
+    "atabey": "bin/cli.js"
+  },
+  "main": "dist/src/cli/index.js",
+  "files": [
+    "bin",
+    "dist",
+    "src",
+    "templates",
+    "framework-mcp",
+    "README.md",
+    "LICENSE",
+    "mcp.json",
+    "ATABEY.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsc && npm run build --prefix framework-mcp",
+    "atabey:build": "npm run build --prefix framework-mcp",
+    "atabey:test": "vitest run",
+    "atabey:test:watch": "vitest",
+    "atabey:status": "atabey status",
+    "atabey:trace": "atabey trace:new",
+    "atabey:verify": "atabey verify-contract",
+    "atabey:update-contract": "atabey update-contract",
+    "atabey:check": "atabey check",
+    "test:init": "node dist/src/cli/index.js init",
+    "atabey:lint": "eslint .",
+    "lint": "eslint .",
+    "prepublishOnly": "npm run build",
+    "clean": "rm -rf dist node_modules framework-mcp/node_modules framework-mcp/dist"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@pandacss/dev": "^1.11.1",
+    "@types/node": "^25.9.1",
+    "eslint": "^10.4.0",
+    "globals": "^17.6.0",
+    "tsx": "^4.22.3",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.0.0",
+    "vitest": "^3.0.0"
+  },
+  "atabey": {
+    "version": "0.0.1",
+    "initializedAt": "2026-06-14T10:45:00.000Z",
+    "frameworkDir": ".atabey"
+  },
+  "dependencies": {
+    "chalk": "^5.6.2",
+    "js-yaml": "^4.2.0",
+    "zod": "^3.24.2"
+  }
+}

package/src/cli/adapters/core.ts

@@ -0,0 +1,67 @@
+import fs from "fs";
+import path from "path";
+import { writeJsonFile } from "../utils/fs.js";
+import { getPackageRoot } from "../utils/pkg.js";
+
+import { ADAPTER_CONFIGS, POST_INIT_HANDLERS } from "../../modules/adapters/definitions.js";
+import type { AdapterConfig, AdapterId } from "../../modules/adapters/types.js";
+
+export const ADAPTERS: Record<AdapterId, AdapterConfig> = ADAPTER_CONFIGS;
+
+export const SHIM_FILES = (Object.keys(ADAPTERS) as AdapterId[]).map((id) => ADAPTERS[id].shimFile);
+
+export const FRAMEWORK_DIR_CANDIDATES = [
+    ".atabey",
+    ".cursor",
+    ".claude",
+    ".github",
+    ".grok",
+    ".antigravity",
+    ".agent",
+    ".gemini/antigravity-cli",
+    ".gemini",
+    ".agents",
+    "antigravity-cli"
+] as const;
+
+export function buildMcpServerEntry(projectRoot: string) {
+    const packageRoot = getPackageRoot();
+    
+    // Check both local development workspace path and installed node_modules path
+    let mcpServerPath = path.join(packageRoot, "framework-mcp/dist/index.js");
+    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("⚠️  MCP Server not found. Did you run 'npm run build' inside @atabey/mcp?");
+    }
+
+    const relativePath = path.relative(projectRoot, mcpServerPath) || mcpServerPath;
+
+    return {
+        command: "node",
+        args: [relativePath],
+        env: {
+            ATABEY_PROJECT_ROOT: projectRoot,
+        },
+    };
+}
+
+export function runAdapterPostInit(adapter: AdapterConfig, projectRoot: string): void {
+    const mcpEntry = buildMcpServerEntry(projectRoot);
+    const mcpBlock = { mcpServers: { "atabey": mcpEntry } };
+
+    const postInitFn = POST_INIT_HANDLERS[adapter.id];
+    if (postInitFn) {
+        postInitFn(projectRoot, mcpBlock);
+    }
+
+    const rootMcpPath = path.join(projectRoot, "mcp.json");
+    if (!fs.existsSync(rootMcpPath)) {
+        writeJsonFile(rootMcpPath, mcpBlock);
+    }
+}

package/src/cli/adapters/index.ts

@@ -0,0 +1,5 @@
+export { ADAPTER_IDS, type AdapterConfig, type AdapterId, type AdapterRole } 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/src/cli/adapters/paths.ts

@@ -0,0 +1,135 @@
+import fs from "fs";
+import path from "path";
+import type { AdapterId } from "../../modules/adapters/types.js";
+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 interface AgentsDestination {
+    agentsDir: string;
+    agentsExt: string;
+    nestedAntigravity: boolean;
+}
+
+export function unifiedAdapterRoot(aiToolDir: string, adapterId: AdapterId): string {
+    return pathJoin(aiToolDir, UNIFIED_ADAPTER_SLUG[adapterId]);
+}
+
+export function resolveAgentsDir(
+    adapterId: AdapterId,
+    isUnified: boolean,
+    aiToolDir: string = UNIFIED_HUB_DIR,
+): AgentsDestination {
+    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: string = UNIFIED_HUB_DIR): string[] {
+    return ADAPTER_IDS.map((id) => resolveAgentsDir(id, true, aiToolDir).agentsDir);
+}
+
+const AGENT_INSTRUCTION_CANDIDATES: Array<(name: string) => string[]> = [
+    (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: string, agentName: string): string | null {
+    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: string): string[] {
+    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: string, dest: string): void {
+    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: string, adapterId: AdapterId): void {
+    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: string): string[] {
+    return [
+        path.join(projectRoot, ADAPTERS.cursor.frameworkDir, "rules", "global.mdc"),
+        path.join(projectRoot, unifiedAdapterPath(UNIFIED_ADAPTER_SLUG.cursor, "rules", "global.mdc")),
+    ];
+}

package/src/cli/adapters/scaffold.ts

@@ -0,0 +1,93 @@
+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 type { AdapterId } from "../../modules/adapters/types.js";
+import { ADAPTERS } from "./core.js";
+
+export function scaffoldAgents(
+    projectRoot: string, 
+    adapterId: AdapterId, 
+    dryRun: boolean, 
+    agentsToScaffold?: string[],
+    explicitDestDir?: string,
+    explicitExt?: string,
+    paths?: Record<string, string>
+): void {
+    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: string | null = null;
+            let secondaryFileName: string | null = null;
+
+            switch (adapterId) {
+                case "gemini":
+                    content = toGeminiCliMd(agent, baseKnowledgeDir, paths);
+                    break;
+                case "grok":
+                    // Grok uses same Gemini-compatible YAML format
+                    content = toGeminiCliMd(agent, baseKnowledgeDir, paths);
+                    break;
+                case "claude":
+                    content = toClaudeCodeMd(agent, baseKnowledgeDir, paths);
+                    break;
+                case "cursor":
+                    content = toCursorMdc(agent, baseKnowledgeDir, paths);
+                    break;
+                case "codex":
+                    content = toCodexMd(agent, baseKnowledgeDir, paths);
+                    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);
+                    fileName = path.join(agent.name, "agent.json");
+                    
+                    secondaryContent = `# 🎖️ 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);
+                    break;
+            }
+
+            if (!dryRun) {
+                writeTextFile(path.join(destAgentsDir, fileName), content, dryRun);
+                if (secondaryContent && secondaryFileName) {
+                    writeTextFile(path.join(destAgentsDir, secondaryFileName), secondaryContent, dryRun);
+                }
+            }
+        }
+    } catch (e) {
+        console.warn(`⚠️  Failed to scaffold agents for ${adapterId}: ${e}`);
+    }
+}