@patchen0518/agentbrew 1.0.2 → 1.2.0

package/dist/sync.js

@@ -0,0 +1,713 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INSTRUCTIONS_FILE = exports.MARKER_END = exports.MARKER_START = void 0;
+exports.extractSkillEntries = extractSkillEntries;
+exports.syncSkillsToClaudeCode = syncSkillsToClaudeCode;
+exports.unsyncSkillsFromClaudeCode = unsyncSkillsFromClaudeCode;
+exports.syncSkillsToGeminiCLI = syncSkillsToGeminiCLI;
+exports.unsyncSkillsFromGeminiCLI = unsyncSkillsFromGeminiCLI;
+exports.syncSkillsToWindsurf = syncSkillsToWindsurf;
+exports.unsyncSkillsFromWindsurf = unsyncSkillsFromWindsurf;
+exports.syncSkillsToAntigravityCLI = syncSkillsToAntigravityCLI;
+exports.unsyncSkillsFromAntigravityCLI = unsyncSkillsFromAntigravityCLI;
+exports.cleanOrphanSkills = cleanOrphanSkills;
+exports.syncMcpServerToCursor = syncMcpServerToCursor;
+exports.unsyncMcpServerFromCursor = unsyncMcpServerFromCursor;
+exports.syncSkillsToCursor = syncSkillsToCursor;
+exports.unsyncSkillsFromCursor = unsyncSkillsFromCursor;
+exports.getDefaultTargets = getDefaultTargets;
+exports.getInstructionsPath = getInstructionsPath;
+exports.buildInjectedSection = buildInjectedSection;
+exports.injectIntoFile = injectIntoFile;
+exports.removeFromFile = removeFromFile;
+exports.syncInstructions = syncInstructions;
+exports.unsyncInstructions = unsyncInstructions;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("./config");
+const package_json_1 = __importDefault(require("../package.json"));
+/**
+ * Extracts SkillEntry objects from discovered packages by scanning for SKILL.md prompts.
+ */
+function extractSkillEntries(packages) {
+    const skills = [];
+    for (const pkg of packages) {
+        if (!pkg.manifest.prompts)
+            continue;
+        for (const prompt of pkg.manifest.prompts) {
+            if (path_1.default.basename(prompt.file).toUpperCase() !== 'SKILL.MD')
+                continue;
+            skills.push({
+                packageName: pkg.packageName,
+                skillName: prompt.name,
+                skillDir: path_1.default.dirname(path_1.default.resolve(pkg.path, prompt.file)),
+                description: prompt.description,
+            });
+        }
+    }
+    return skills;
+}
+const SYNCED_SKILLS_FILE = 'synced-skills.json';
+const AGENTBREW_EXTENSION_NAME = 'agentbrew';
+const CURSOR_SKILLS_INDEX_FILE = 'agentbrew-skills-index.md';
+function getSyncedSkillsPath(brewRoot) {
+    return path_1.default.join(brewRoot ?? (0, config_1.getBrewRoot)(), SYNCED_SKILLS_FILE);
+}
+function loadSyncedState(brewRoot) {
+    try {
+        const raw = JSON.parse(fs_1.default.readFileSync(getSyncedSkillsPath(brewRoot), 'utf-8'));
+        // Migrate old flat format: { skills: [...] } → { claude: [...] }
+        if (raw.skills && !raw.claude) {
+            return { claude: raw.skills, gemini: [], windsurf: [], cursor: false, cursorMcp: false, antigravity: [] };
+        }
+        return {
+            claude: raw.claude ?? [],
+            gemini: raw.gemini ?? [],
+            windsurf: raw.windsurf ?? [],
+            cursor: raw.cursor ?? false,
+            cursorMcp: raw.cursorMcp ?? false,
+            antigravity: raw.antigravity ?? [],
+        };
+    }
+    catch {
+        return { claude: [], gemini: [], windsurf: [], cursor: false, cursorMcp: false, antigravity: [] };
+    }
+}
+function saveSyncedState(state, brewRoot) {
+    const p = getSyncedSkillsPath(brewRoot);
+    fs_1.default.mkdirSync(path_1.default.dirname(p), { recursive: true });
+    fs_1.default.writeFileSync(p, JSON.stringify(state, null, 2), 'utf-8');
+}
+function symlinkSkills(skills, targetDir, state, agentKey, brewRoot) {
+    const results = [];
+    const newEntries = [];
+    for (const skill of skills) {
+        const entryName = `${skill.packageName}-${skill.skillName}`;
+        const entryPath = path_1.default.join(targetDir, entryName);
+        if (!fs_1.default.existsSync(skill.skillDir)) {
+            results.push({ entryName, status: 'skipped', note: 'Source directory not found' });
+            continue;
+        }
+        let exists = false;
+        try {
+            fs_1.default.lstatSync(entryPath);
+            exists = true;
+        }
+        catch { }
+        if (exists) {
+            let currentTarget = null;
+            try {
+                currentTarget = fs_1.default.readlinkSync(entryPath);
+            }
+            catch { }
+            if (currentTarget === null) {
+                // Not a symlink — not created by AgentBrew, leave it alone
+                results.push({ entryName, status: 'skipped', note: 'Path exists and is not a symlink' });
+                continue;
+            }
+            if (currentTarget === skill.skillDir) {
+                newEntries.push(entryName);
+                results.push({ entryName, status: 'already_exists', path: entryPath });
+                continue;
+            }
+            // Stale symlink pointing at a different target — remove and re-create
+            try {
+                fs_1.default.rmSync(entryPath, { force: true });
+            }
+            catch { }
+        }
+        try {
+            fs_1.default.symlinkSync(skill.skillDir, entryPath);
+            newEntries.push(entryName);
+            results.push({ entryName, status: 'linked', path: entryPath });
+        }
+        catch (e) {
+            results.push({ entryName, status: 'error', note: e.message });
+        }
+    }
+    state[agentKey] = [...new Set([...state[agentKey], ...newEntries])];
+    saveSyncedState(state, brewRoot);
+    return results;
+}
+function removeTrackedSymlinks(tracked, skillsDir) {
+    const results = [];
+    for (const entryName of tracked) {
+        const entryPath = path_1.default.join(skillsDir, entryName);
+        let exists = false;
+        try {
+            fs_1.default.lstatSync(entryPath);
+            exists = true;
+        }
+        catch { }
+        if (!exists) {
+            results.push({ entryName, status: 'skipped', note: 'Not found' });
+            continue;
+        }
+        try {
+            fs_1.default.rmSync(entryPath, { recursive: true, force: true });
+            results.push({ entryName, status: 'removed', path: entryPath });
+        }
+        catch (e) {
+            results.push({ entryName, status: 'error', note: e.message });
+        }
+    }
+    return results;
+}
+// ─── Claude Code ────────────────────────────────────────────────────────────
+/**
+ * Symlinks each skill directory into ~/.claude/skills/<pkgName>-<skillName>
+ * so Claude Code can discover them as invocable skills.
+ */
+function syncSkillsToClaudeCode(skills, brewRoot) {
+    const claudeDir = path_1.default.join(os_1.default.homedir(), '.claude');
+    if (!fs_1.default.existsSync(claudeDir))
+        return [];
+    const skillsDir = path_1.default.join(claudeDir, 'skills');
+    fs_1.default.mkdirSync(skillsDir, { recursive: true });
+    const state = loadSyncedState(brewRoot);
+    return symlinkSkills(skills, skillsDir, state, 'claude', brewRoot);
+}
+/**
+ * Removes all skill symlinks previously created by syncSkillsToClaudeCode.
+ */
+function unsyncSkillsFromClaudeCode(brewRoot) {
+    const skillsDir = path_1.default.join(os_1.default.homedir(), '.claude', 'skills');
+    const state = loadSyncedState(brewRoot);
+    const results = removeTrackedSymlinks(state.claude, skillsDir);
+    state.claude = [];
+    saveSyncedState(state, brewRoot);
+    return results;
+}
+// ─── Gemini CLI ──────────────────────────────────────────────────────────────
+/**
+ * Registers skills with Gemini CLI by creating an agentbrew extension at
+ * ~/.gemini/extensions/agentbrew/ and symlinking each skill's directory into
+ * ~/.gemini/extensions/agentbrew/skills/<pkgName>-<skillName>.
+ */
+function syncSkillsToGeminiCLI(skills, brewRoot) {
+    const geminiDir = path_1.default.join(os_1.default.homedir(), '.gemini');
+    if (!fs_1.default.existsSync(geminiDir))
+        return [];
+    const extensionDir = path_1.default.join(geminiDir, 'extensions', AGENTBREW_EXTENSION_NAME);
+    const skillsDir = path_1.default.join(extensionDir, 'skills');
+    fs_1.default.mkdirSync(skillsDir, { recursive: true });
+    // Write extension manifest (we own this file)
+    const manifestPath = path_1.default.join(extensionDir, 'gemini-extension.json');
+    fs_1.default.writeFileSync(manifestPath, JSON.stringify({ name: AGENTBREW_EXTENSION_NAME, version: package_json_1.default.version }, null, 2), 'utf-8');
+    // Enable extension in extension-enablement.json
+    _enableGeminiExtension(geminiDir);
+    const state = loadSyncedState(brewRoot);
+    return symlinkSkills(skills, skillsDir, state, 'gemini', brewRoot);
+}
+/**
+ * Removes Gemini CLI skill symlinks, the extension manifest, and the
+ * agentbrew extension entry from extension-enablement.json.
+ */
+function unsyncSkillsFromGeminiCLI(brewRoot) {
+    const geminiDir = path_1.default.join(os_1.default.homedir(), '.gemini');
+    const extensionDir = path_1.default.join(geminiDir, 'extensions', AGENTBREW_EXTENSION_NAME);
+    const skillsDir = path_1.default.join(extensionDir, 'skills');
+    const state = loadSyncedState(brewRoot);
+    const results = removeTrackedSymlinks(state.gemini, skillsDir);
+    // Clean up extension dir (best-effort; ignores non-empty)
+    try {
+        fs_1.default.rmSync(path_1.default.join(extensionDir, 'gemini-extension.json'), { force: true });
+    }
+    catch { }
+    try {
+        fs_1.default.rmdirSync(skillsDir);
+    }
+    catch { }
+    try {
+        fs_1.default.rmdirSync(extensionDir);
+    }
+    catch { }
+    _disableGeminiExtension(geminiDir);
+    state.gemini = [];
+    saveSyncedState(state, brewRoot);
+    return results;
+}
+function _enableGeminiExtension(geminiDir) {
+    const enablementPath = path_1.default.join(geminiDir, 'extensions', 'extension-enablement.json');
+    let data = {};
+    try {
+        data = JSON.parse(fs_1.default.readFileSync(enablementPath, 'utf-8'));
+    }
+    catch { }
+    if (!data[AGENTBREW_EXTENSION_NAME]) {
+        data[AGENTBREW_EXTENSION_NAME] = { overrides: [`${os_1.default.homedir()}/*`] };
+        fs_1.default.writeFileSync(enablementPath, JSON.stringify(data, null, 2), 'utf-8');
+    }
+}
+function _disableGeminiExtension(geminiDir) {
+    const enablementPath = path_1.default.join(geminiDir, 'extensions', 'extension-enablement.json');
+    try {
+        const data = JSON.parse(fs_1.default.readFileSync(enablementPath, 'utf-8'));
+        if (AGENTBREW_EXTENSION_NAME in data) {
+            delete data[AGENTBREW_EXTENSION_NAME];
+            if (Object.keys(data).length === 0) {
+                fs_1.default.rmSync(enablementPath, { force: true });
+            }
+            else {
+                fs_1.default.writeFileSync(enablementPath, JSON.stringify(data, null, 2), 'utf-8');
+            }
+        }
+    }
+    catch { }
+}
+// ─── Windsurf ────────────────────────────────────────────────────────────────
+/**
+ * Symlinks each skill directory into ~/.codeium/windsurf/skills/<pkgName>-<skillName>
+ * so Windsurf can discover them.
+ */
+function syncSkillsToWindsurf(skills, brewRoot) {
+    const windsurfDir = path_1.default.join(os_1.default.homedir(), '.codeium', 'windsurf');
+    if (!fs_1.default.existsSync(windsurfDir))
+        return [];
+    const skillsDir = path_1.default.join(windsurfDir, 'skills');
+    fs_1.default.mkdirSync(skillsDir, { recursive: true });
+    const state = loadSyncedState(brewRoot);
+    return symlinkSkills(skills, skillsDir, state, 'windsurf', brewRoot);
+}
+/**
+ * Removes all Windsurf skill symlinks previously created by syncSkillsToWindsurf.
+ */
+function unsyncSkillsFromWindsurf(brewRoot) {
+    const skillsDir = path_1.default.join(os_1.default.homedir(), '.codeium', 'windsurf', 'skills');
+    const state = loadSyncedState(brewRoot);
+    const results = removeTrackedSymlinks(state.windsurf, skillsDir);
+    state.windsurf = [];
+    saveSyncedState(state, brewRoot);
+    return results;
+}
+// ─── Antigravity CLI ─────────────────────────────────────────────────────────
+/**
+ * Symlinks each skill directory into ~/.gemini/antigravity-cli/skills/<pkgName>-<skillName>
+ * so Antigravity CLI can auto-discover them.
+ */
+function syncSkillsToAntigravityCLI(skills, brewRoot) {
+    const antigravityDir = path_1.default.join(os_1.default.homedir(), '.gemini', 'antigravity-cli');
+    if (!fs_1.default.existsSync(antigravityDir))
+        return [];
+    const skillsDir = path_1.default.join(antigravityDir, 'skills');
+    fs_1.default.mkdirSync(skillsDir, { recursive: true });
+    const state = loadSyncedState(brewRoot);
+    return symlinkSkills(skills, skillsDir, state, 'antigravity', brewRoot);
+}
+/**
+ * Removes all Antigravity CLI skill symlinks previously created by syncSkillsToAntigravityCLI.
+ */
+function unsyncSkillsFromAntigravityCLI(brewRoot) {
+    const skillsDir = path_1.default.join(os_1.default.homedir(), '.gemini', 'antigravity-cli', 'skills');
+    const state = loadSyncedState(brewRoot);
+    const results = removeTrackedSymlinks(state.antigravity, skillsDir);
+    state.antigravity = [];
+    saveSyncedState(state, brewRoot);
+    return results;
+}
+// ─── Orphan cleanup ──────────────────────────────────────────────────────────
+/**
+ * Removes symlinks whose targets no longer exist (e.g. after a package is uninstalled).
+ * Call after `agentbrew uninstall` to prevent stale entries.
+ */
+function cleanOrphanSkills(brewRoot) {
+    const state = loadSyncedState(brewRoot);
+    const results = [];
+    const agentDirs = [
+        { key: 'claude', dir: path_1.default.join(os_1.default.homedir(), '.claude', 'skills') },
+        { key: 'gemini', dir: path_1.default.join(os_1.default.homedir(), '.gemini', 'extensions', AGENTBREW_EXTENSION_NAME, 'skills') },
+        { key: 'windsurf', dir: path_1.default.join(os_1.default.homedir(), '.codeium', 'windsurf', 'skills') },
+        { key: 'antigravity', dir: path_1.default.join(os_1.default.homedir(), '.gemini', 'antigravity-cli', 'skills') },
+    ];
+    for (const { key, dir } of agentDirs) {
+        const remaining = [];
+        for (const entryName of state[key]) {
+            const entryPath = path_1.default.join(dir, entryName);
+            let symlinkTarget = null;
+            try {
+                symlinkTarget = fs_1.default.readlinkSync(entryPath);
+            }
+            catch { }
+            if (symlinkTarget !== null && !fs_1.default.existsSync(symlinkTarget)) {
+                try {
+                    fs_1.default.rmSync(entryPath, { force: true });
+                    results.push({ entryName, status: 'removed', path: entryPath });
+                }
+                catch (e) {
+                    results.push({ entryName, status: 'error', note: e.message });
+                    remaining.push(entryName);
+                }
+            }
+            else {
+                remaining.push(entryName);
+            }
+        }
+        state[key] = remaining;
+    }
+    // Handle Cursor index file: parse referenced SKILL.md paths and remove the file if any are stale
+    if (state.cursor) {
+        const indexPath = path_1.default.join(os_1.default.homedir(), '.cursor', 'rules', CURSOR_SKILLS_INDEX_FILE);
+        let indexContent = null;
+        try {
+            indexContent = fs_1.default.readFileSync(indexPath, 'utf-8');
+        }
+        catch { }
+        if (indexContent === null) {
+            state.cursor = false;
+        }
+        else {
+            const pathMatches = [...indexContent.matchAll(/`([^`]+SKILL\.md)`/gi)];
+            const hasStalePath = pathMatches.some(m => !fs_1.default.existsSync(m[1]));
+            if (hasStalePath) {
+                try {
+                    fs_1.default.rmSync(indexPath, { force: true });
+                    state.cursor = false;
+                    results.push({ entryName: CURSOR_SKILLS_INDEX_FILE, status: 'removed', path: indexPath });
+                }
+                catch (e) {
+                    results.push({ entryName: CURSOR_SKILLS_INDEX_FILE, status: 'error', note: e.message });
+                }
+            }
+        }
+    }
+    saveSyncedState(state, brewRoot);
+    return results;
+}
+// ─── Cursor MCP server registration ─────────────────────────────────────────
+const CURSOR_MCP_ENTRY = 'agentbrew';
+/**
+ * Adds agentbrew to ~/.cursor/mcp.json so Cursor can discover MCP tools directly.
+ * Merges into any existing config without disturbing other servers.
+ */
+function syncMcpServerToCursor(brewRoot) {
+    const cursorDir = path_1.default.join(os_1.default.homedir(), '.cursor');
+    if (!fs_1.default.existsSync(cursorDir))
+        return [];
+    const mcpJsonPath = path_1.default.join(cursorDir, 'mcp.json');
+    const entryName = 'agentbrew (Cursor MCP)';
+    let config = {};
+    try {
+        config = JSON.parse(fs_1.default.readFileSync(mcpJsonPath, 'utf-8'));
+    }
+    catch { }
+    const mcpServers = config.mcpServers ?? {};
+    const existing = mcpServers[CURSOR_MCP_ENTRY];
+    if (existing?.command === 'agentbrew') {
+        const state = loadSyncedState(brewRoot);
+        state.cursorMcp = true;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName, status: 'already_exists', path: mcpJsonPath }];
+    }
+    config.mcpServers = { ...mcpServers, [CURSOR_MCP_ENTRY]: { command: 'agentbrew' } };
+    try {
+        fs_1.default.writeFileSync(mcpJsonPath, JSON.stringify(config, null, 2), 'utf-8');
+        const state = loadSyncedState(brewRoot);
+        state.cursorMcp = true;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName, status: 'linked', path: mcpJsonPath }];
+    }
+    catch (e) {
+        return [{ entryName, status: 'error', note: e.message }];
+    }
+}
+/**
+ * Removes the agentbrew entry from ~/.cursor/mcp.json.
+ * Leaves other servers intact; removes the file only if it becomes empty.
+ */
+function unsyncMcpServerFromCursor(brewRoot) {
+    const state = loadSyncedState(brewRoot);
+    if (!state.cursorMcp)
+        return [];
+    const mcpJsonPath = path_1.default.join(os_1.default.homedir(), '.cursor', 'mcp.json');
+    const entryName = 'agentbrew (Cursor MCP)';
+    let config = {};
+    try {
+        config = JSON.parse(fs_1.default.readFileSync(mcpJsonPath, 'utf-8'));
+    }
+    catch {
+        state.cursorMcp = false;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName, status: 'skipped', note: 'Not found' }];
+    }
+    if (!config.mcpServers?.[CURSOR_MCP_ENTRY]) {
+        state.cursorMcp = false;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName, status: 'skipped', note: 'Not found' }];
+    }
+    delete config.mcpServers[CURSOR_MCP_ENTRY];
+    if (Object.keys(config.mcpServers).length === 0)
+        delete config.mcpServers;
+    try {
+        if (Object.keys(config).length === 0) {
+            fs_1.default.rmSync(mcpJsonPath, { force: true });
+        }
+        else {
+            fs_1.default.writeFileSync(mcpJsonPath, JSON.stringify(config, null, 2), 'utf-8');
+        }
+        state.cursorMcp = false;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName, status: 'removed', path: mcpJsonPath }];
+    }
+    catch (e) {
+        return [{ entryName, status: 'error', note: e.message }];
+    }
+}
+// ─── Cursor ──────────────────────────────────────────────────────────────────
+function buildCursorSkillsIndex(skills) {
+    const lines = [
+        '---',
+        'description: AgentBrew skills index — reference when asked about available skills, tools, or capabilities',
+        'alwaysApply: false',
+        '---',
+        '<!-- Managed by AgentBrew. Run `agentbrew sync` to update. Do not edit manually. -->',
+        '',
+        '# AgentBrew Skills',
+        '',
+        'Skills installed via AgentBrew. Read a SKILL.md file to learn how to invoke it.',
+        '',
+    ];
+    for (const skill of skills) {
+        const desc = skill.description ? ` — ${skill.description}` : '';
+        lines.push(`- **${skill.packageName}/${skill.skillName}**${desc}: \`${path_1.default.join(skill.skillDir, 'SKILL.md')}\``);
+    }
+    return lines.join('\n') + '\n';
+}
+/**
+ * Writes a single skills index file to ~/.cursor/rules/agentbrew-skills-index.md
+ * listing all AgentBrew skills with paths for on-demand discovery.
+ * Does NOT copy individual SKILL.md files — Cursor rules are always-on context.
+ */
+function syncSkillsToCursor(skills, brewRoot) {
+    const cursorDir = path_1.default.join(os_1.default.homedir(), '.cursor');
+    if (!fs_1.default.existsSync(cursorDir))
+        return [];
+    if (skills.length === 0)
+        return unsyncSkillsFromCursor(brewRoot);
+    const rulesDir = path_1.default.join(cursorDir, 'rules');
+    fs_1.default.mkdirSync(rulesDir, { recursive: true });
+    const indexPath = path_1.default.join(rulesDir, CURSOR_SKILLS_INDEX_FILE);
+    const content = buildCursorSkillsIndex(skills);
+    const state = loadSyncedState(brewRoot);
+    try {
+        fs_1.default.writeFileSync(indexPath, content, 'utf-8');
+        state.cursor = true;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName: CURSOR_SKILLS_INDEX_FILE, status: 'linked', path: indexPath }];
+    }
+    catch (e) {
+        return [{ entryName: CURSOR_SKILLS_INDEX_FILE, status: 'error', note: e.message }];
+    }
+}
+/**
+ * Removes the AgentBrew skills index file from ~/.cursor/rules/.
+ */
+function unsyncSkillsFromCursor(brewRoot) {
+    const state = loadSyncedState(brewRoot);
+    if (!state.cursor)
+        return [];
+    const indexPath = path_1.default.join(os_1.default.homedir(), '.cursor', 'rules', CURSOR_SKILLS_INDEX_FILE);
+    let exists = false;
+    try {
+        fs_1.default.lstatSync(indexPath);
+        exists = true;
+    }
+    catch { }
+    if (!exists) {
+        state.cursor = false;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName: CURSOR_SKILLS_INDEX_FILE, status: 'skipped', note: 'Not found' }];
+    }
+    try {
+        fs_1.default.rmSync(indexPath, { force: true });
+        state.cursor = false;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName: CURSOR_SKILLS_INDEX_FILE, status: 'removed', path: indexPath }];
+    }
+    catch (e) {
+        return [{ entryName: CURSOR_SKILLS_INDEX_FILE, status: 'error', note: e.message }];
+    }
+}
+// ─── Instruction sync (unchanged) ───────────────────────────────────────────
+exports.MARKER_START = '<!-- agentbrew:shared:start -->';
+exports.MARKER_END = '<!-- agentbrew:shared:end -->';
+exports.INSTRUCTIONS_FILE = 'INSTRUCTIONS.md';
+const EXAMPLE_INSTRUCTIONS = `# AgentBrew Shared Instructions
+
+These instructions are shared across all your AI agents via AgentBrew.
+Edit this file and run \`agentbrew sync\` to push updates to all agent configs.
+
+## Example: API Usage Policy
+- Always use Context7 (the \`context7\` MCP tool) to fetch live API documentation
+  before writing code that calls an external library. This prevents using stale or
+  hallucinated function signatures.
+
+## Notes
+- This file is global. For project-specific context, add it directly to the
+  project's CLAUDE.md or GEMINI.md — or reference project docs from within this file.
+`;
+function getDefaultTargets() {
+    const home = os_1.default.homedir();
+    return [
+        {
+            name: 'Claude Code',
+            configPath: path_1.default.join(home, '.claude', 'CLAUDE.md'),
+            isFileOwned: false,
+        },
+        {
+            name: 'Gemini CLI',
+            configPath: path_1.default.join(home, '.gemini', 'GEMINI.md'),
+            isFileOwned: false,
+        },
+        {
+            name: 'OpenAI Codex CLI',
+            // Codex CLI's canonical instruction file is AGENTS.md (instructions.md is a legacy fallback)
+            configPath: path_1.default.join(home, '.codex', 'AGENTS.md'),
+            isFileOwned: false,
+        },
+        {
+            name: 'Cursor',
+            // Cursor "User Rules" directory (Cursor 0.47+): each .md file in this dir is a global rule.
+            // We own this specific file entirely — no markers needed.
+            configPath: path_1.default.join(home, '.cursor', 'rules', 'agentbrew-shared.md'),
+            isFileOwned: true,
+        },
+        {
+            name: 'Windsurf',
+            configPath: path_1.default.join(home, '.codeium', 'windsurf', 'memories', 'global_rules.md'),
+            isFileOwned: false,
+        },
+    ];
+}
+function getInstructionsPath(brewRoot) {
+    return path_1.default.join(brewRoot ?? (0, config_1.getBrewRoot)(), exports.INSTRUCTIONS_FILE);
+}
+function buildInjectedSection(content) {
+    const warning = `> ⚠️ Managed by AgentBrew. Edit \`~/.agentbrew/INSTRUCTIONS.md\` and run \`agentbrew sync\` to update.`;
+    return `${exports.MARKER_START}\n${warning}\n\n${content.trim()}\n${exports.MARKER_END}`;
+}
+/**
+ * Injects (or updates) the agentbrew section in a file.
+ * Creates the file and any parent directories if they don't exist.
+ */
+function injectIntoFile(filePath, content) {
+    const section = buildInjectedSection(content);
+    if (!fs_1.default.existsSync(filePath)) {
+        fs_1.default.mkdirSync(path_1.default.dirname(filePath), { recursive: true });
+        fs_1.default.writeFileSync(filePath, section + '\n', 'utf-8');
+        return 'created';
+    }
+    const existing = fs_1.default.readFileSync(filePath, 'utf-8');
+    const startIdx = existing.indexOf(exports.MARKER_START);
+    const endIdx = existing.indexOf(exports.MARKER_END);
+    if (startIdx !== -1 && endIdx !== -1) {
+        const replaced = existing.substring(0, startIdx) +
+            section +
+            existing.substring(endIdx + exports.MARKER_END.length);
+        if (replaced === existing)
+            return 'unchanged';
+        fs_1.default.writeFileSync(filePath, replaced, 'utf-8');
+        return 'updated';
+    }
+    // No markers yet — append to end
+    const appended = existing.trimEnd() + '\n\n' + section + '\n';
+    fs_1.default.writeFileSync(filePath, appended, 'utf-8');
+    return 'updated';
+}
+/**
+ * Removes the agentbrew section from a file, leaving surrounding content intact.
+ */
+function removeFromFile(filePath) {
+    if (!fs_1.default.existsSync(filePath))
+        return 'not_found';
+    const existing = fs_1.default.readFileSync(filePath, 'utf-8');
+    const startIdx = existing.indexOf(exports.MARKER_START);
+    const endIdx = existing.indexOf(exports.MARKER_END);
+    if (startIdx === -1 || endIdx === -1)
+        return 'no_section';
+    const before = existing.substring(0, startIdx).trimEnd();
+    const after = existing.substring(endIdx + exports.MARKER_END.length).trimStart();
+    let result = before;
+    if (after)
+        result += '\n\n' + after;
+    result = result.trimEnd() + '\n';
+    fs_1.default.writeFileSync(filePath, result, 'utf-8');
+    return 'removed';
+}
+/**
+ * Syncs ~/.agentbrew/INSTRUCTIONS.md into each target agent's global config file.
+ * Accepts an optional `targets` override (used in tests).
+ */
+function syncInstructions(targets, brewRoot) {
+    const instructionsPath = getInstructionsPath(brewRoot);
+    if (!fs_1.default.existsSync(instructionsPath)) {
+        fs_1.default.mkdirSync(path_1.default.dirname(instructionsPath), { recursive: true });
+        fs_1.default.writeFileSync(instructionsPath, EXAMPLE_INSTRUCTIONS, 'utf-8');
+        return [];
+    }
+    const content = fs_1.default.readFileSync(instructionsPath, 'utf-8');
+    const resolvedTargets = targets ?? getDefaultTargets();
+    const results = [];
+    for (const target of resolvedTargets) {
+        if (target.configPath === null) {
+            results.push({ agent: target.name, status: 'manual', note: target.manualInstructions });
+            continue;
+        }
+        if (target.isFileOwned) {
+            // We own this file entirely — write raw content, no markers needed.
+            // unsync deletes the file; there is no surrounding user content to delimit around.
+            const header = `> ⚠️ Managed by AgentBrew. Edit \`~/.agentbrew/INSTRUCTIONS.md\` and run \`agentbrew sync\` to update.\n`;
+            const fileContent = header + '\n' + content.trim() + '\n';
+            fs_1.default.mkdirSync(path_1.default.dirname(target.configPath), { recursive: true });
+            const existing = fs_1.default.existsSync(target.configPath)
+                ? fs_1.default.readFileSync(target.configPath, 'utf-8')
+                : null;
+            if (existing === fileContent) {
+                results.push({ agent: target.name, status: 'unchanged', path: target.configPath });
+            }
+            else {
+                fs_1.default.writeFileSync(target.configPath, fileContent, 'utf-8');
+                results.push({ agent: target.name, status: existing !== null ? 'updated' : 'created', path: target.configPath });
+            }
+            continue;
+        }
+        // Skip agents that aren't installed (config parent dir absent)
+        if (!fs_1.default.existsSync(path_1.default.dirname(target.configPath))) {
+            results.push({ agent: target.name, status: 'skipped', note: 'Agent not installed (config directory not found)' });
+            continue;
+        }
+        const status = injectIntoFile(target.configPath, content);
+        results.push({ agent: target.name, status, path: target.configPath });
+    }
+    return results;
+}
+/**
+ * Removes the agentbrew section from all target agent config files.
+ */
+function unsyncInstructions(targets) {
+    const resolvedTargets = targets ?? getDefaultTargets();
+    const results = [];
+    for (const target of resolvedTargets) {
+        if (target.configPath === null) {
+            results.push({ agent: target.name, status: 'manual', note: 'Remove manually from your agent UI settings.' });
+            continue;
+        }
+        if (target.isFileOwned) {
+            if (fs_1.default.existsSync(target.configPath)) {
+                fs_1.default.rmSync(target.configPath);
+                results.push({ agent: target.name, status: 'removed', path: target.configPath });
+            }
+            else {
+                results.push({ agent: target.name, status: 'not_found', path: target.configPath });
+            }
+            continue;
+        }
+        const status = removeFromFile(target.configPath);
+        results.push({ agent: target.name, status, path: target.configPath });
+    }
+    return results;
+}
+//# sourceMappingURL=sync.js.map