atabey 0.0.5 → 0.0.7

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

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

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

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

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

package/src/cli/adapters/core.ts

@@ -1,91 +0,0 @@
-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 if we are running in the framework local development repository itself
-    const isLocalFrameworkDev = path.resolve(packageRoot) === path.resolve(projectRoot);
-
-    let relativePath: string;
-
-    if (isLocalFrameworkDev) {
-        // In local framework dev, always use the build path directly relative to project root
-        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?");
-        }
-        relativePath = path.relative(projectRoot, mcpServerPath) || mcpServerPath;
-    } else {
-        // If we are initializing in a user's project:
-        // We want to target the local node_modules of the user's project.
-        // Even if node_modules is not populated yet (e.g. running via npx before npm install),
-        // we should write the local node_modules path so that it will work once installed.
-        
-        const localAtabeyPath = path.join(projectRoot, "node_modules/atabey/framework-mcp/dist/index.js");
-        const localScopedPath = path.join(projectRoot, "node_modules/atabey-mcp/dist/index.js");
-
-        if (fs.existsSync(localScopedPath)) {
-            relativePath = path.relative(projectRoot, localScopedPath);
-        } else if (fs.existsSync(localAtabeyPath)) {
-            relativePath = path.relative(projectRoot, localAtabeyPath);
-        } else {
-            // Default to the standard relative local path in node_modules/atabey
-            // This is clean and portable across machines/developers.
-            relativePath = "node_modules/atabey/framework-mcp/dist/index.js";
-        }
-    }
-
-    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

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

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

@@ -1,95 +0,0 @@
-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>,
-    backendLanguage?: string,
-    _language?: 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, 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 = `# 🎖️ 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(`⚠️  Failed to scaffold agents for ${adapterId}: ${e}`);
-    }
-}

package/src/cli/adapters/utils.ts

@@ -1,87 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { logger } from "../../shared/logger.js";
-import { UI } from "../utils/ui.js";
-
-import type { AdapterConfig, AdapterId } from "../../modules/adapters/types.js";
-import { ADAPTERS, SHIM_FILES } from "./core.js";
-
-export function resolveAdapter(input?: string): AdapterConfig {
-    let normalized = (input || "gemini").toLowerCase();
-    if (normalized === "antigravity") {
-        normalized = "antigravity-cli";
-    } else if (normalized === "copilot" || normalized === "github") {
-        normalized = "codex";
-    }
-
-    let config: AdapterConfig;
-    if (normalized in ADAPTERS) {
-        config = { ...ADAPTERS[normalized as AdapterId] };
-    } else {
-        UI.warning(`Unknown adapter "${input}". Falling back to gemini.`);
-        config = { ...ADAPTERS.gemini };
-    }
-
-    return config;
-}
-
-export function isAdapterShimFile(fileName: string): boolean {
-    return SHIM_FILES.includes(fileName);
-}
-
-export function remapFrameworkContent(
-    content: string,
-    frameworkDir: string,
-    adapterId: AdapterId,
-): string {
-    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;
-}