@patchen0518/agentbrew 1.1.0 → 1.2.5

package/dist/sync.js

@@ -1,9 +1,62 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 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.syncMcpServerToCodex = syncMcpServerToCodex;
+exports.unsyncMcpServerFromCodex = unsyncMcpServerFromCodex;
+exports.syncSkillsToCursor = syncSkillsToCursor;
+exports.unsyncSkillsFromCursor = unsyncSkillsFromCursor;
+exports.syncSkillsToKiro = syncSkillsToKiro;
+exports.unsyncSkillsFromKiro = unsyncSkillsFromKiro;
+exports.syncMcpServerToKiro = syncMcpServerToKiro;
+exports.unsyncMcpServerFromKiro = unsyncMcpServerFromKiro;
 exports.getDefaultTargets = getDefaultTargets;
 exports.getInstructionsPath = getInstructionsPath;
 exports.buildInjectedSection = buildInjectedSection;
@@ -14,7 +67,724 @@ exports.unsyncInstructions = unsyncInstructions;
 const fs_1 = __importDefault(require("fs"));
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
+const toml = __importStar(require("smol-toml"));
 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: [], codexMcp: false, kiro: [], kiroMcp: false };
+        }
+        return {
+            claude: raw.claude ?? [],
+            gemini: raw.gemini ?? [],
+            windsurf: raw.windsurf ?? [],
+            cursor: raw.cursor ?? false,
+            cursorMcp: raw.cursorMcp ?? false,
+            antigravity: raw.antigravity ?? [],
+            codexMcp: raw.codexMcp ?? false,
+            kiro: raw.kiro ?? [],
+            kiroMcp: raw.kiroMcp ?? false,
+        };
+    }
+    catch {
+        return { claude: [], gemini: [], windsurf: [], cursor: false, cursorMcp: false, antigravity: [], codexMcp: false, kiro: [], kiroMcp: false };
+    }
+}
+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') },
+        { key: 'kiro', dir: path_1.default.join(os_1.default.homedir(), '.kiro', '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 });
+                }
+            }
+        }
+    }
+    if (state.codexMcp && !fs_1.default.existsSync(path_1.default.join(os_1.default.homedir(), '.codex'))) {
+        state.codexMcp = false;
+    }
+    if (state.kiroMcp && !fs_1.default.existsSync(path_1.default.join(os_1.default.homedir(), '.kiro'))) {
+        state.kiroMcp = false;
+    }
+    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 }];
+    }
+}
+// ─── Codex MCP server registration ──────────────────────────────────────────
+function _removeTomlSection(content, sectionHeader) {
+    const lines = content.split('\n');
+    const headerLine = `[${sectionHeader}]`;
+    const startIdx = lines.findIndex(l => l.trim() === headerLine);
+    if (startIdx === -1)
+        return content;
+    let endIdx = lines.length;
+    for (let i = startIdx + 1; i < lines.length; i++) {
+        if (lines[i].trim().startsWith('[')) {
+            endIdx = i;
+            break;
+        }
+    }
+    // Also absorb a preceding blank line
+    let removeFrom = startIdx;
+    if (removeFrom > 0 && lines[removeFrom - 1].trim() === '')
+        removeFrom--;
+    return [...lines.slice(0, removeFrom), ...lines.slice(endIdx)].join('\n');
+}
+/**
+ * Adds agentbrew to ~/.codex/config.toml so Codex CLI can discover MCP tools directly.
+ * Appends the [mcp_servers.agentbrew] section without disturbing existing content.
+ */
+function syncMcpServerToCodex(brewRoot) {
+    const codexDir = path_1.default.join(os_1.default.homedir(), '.codex');
+    if (!fs_1.default.existsSync(codexDir))
+        return [];
+    const configPath = path_1.default.join(codexDir, 'config.toml');
+    const entryName = 'agentbrew (Codex MCP)';
+    let raw = '';
+    try {
+        raw = fs_1.default.readFileSync(configPath, 'utf-8');
+    }
+    catch { }
+    // Check if already registered with the right command
+    try {
+        const parsed = toml.parse(raw);
+        if (parsed?.mcp_servers?.agentbrew?.command === 'agentbrew') {
+            const state = loadSyncedState(brewRoot);
+            state.codexMcp = true;
+            saveSyncedState(state, brewRoot);
+            return [{ entryName, status: 'already_exists', path: configPath }];
+        }
+    }
+    catch { }
+    // Remove any stale entry (e.g. wrong command) before re-adding to avoid duplicate TOML table headers
+    const cleaned = _removeTomlSection(raw, 'mcp_servers.agentbrew');
+    const sep = cleaned.length > 0 && !cleaned.endsWith('\n') ? '\n' : '';
+    const newContent = cleaned + sep + '\n[mcp_servers.agentbrew]\ncommand = "agentbrew"\n';
+    try {
+        fs_1.default.writeFileSync(configPath, newContent, 'utf-8');
+        const state = loadSyncedState(brewRoot);
+        state.codexMcp = true;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName, status: 'linked', path: configPath }];
+    }
+    catch (e) {
+        return [{ entryName, status: 'error', note: e.message }];
+    }
+}
+/**
+ * Removes the agentbrew entry from ~/.codex/config.toml.
+ * Leaves the file in place; other sections are untouched.
+ */
+function unsyncMcpServerFromCodex(brewRoot) {
+    const state = loadSyncedState(brewRoot);
+    if (!state.codexMcp)
+        return [];
+    const configPath = path_1.default.join(os_1.default.homedir(), '.codex', 'config.toml');
+    const entryName = 'agentbrew (Codex MCP)';
+    let raw;
+    try {
+        raw = fs_1.default.readFileSync(configPath, 'utf-8');
+    }
+    catch {
+        state.codexMcp = false;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName, status: 'skipped', note: 'Not found' }];
+    }
+    const cleaned = _removeTomlSection(raw, 'mcp_servers.agentbrew');
+    if (cleaned === raw) {
+        state.codexMcp = false;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName, status: 'skipped', note: 'Not found' }];
+    }
+    try {
+        const trimmed = cleaned.trimEnd();
+        fs_1.default.writeFileSync(configPath, trimmed ? trimmed + '\n' : '', 'utf-8');
+        state.codexMcp = false;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName, status: 'removed', path: configPath }];
+    }
+    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 }];
+    }
+}
+// ─── Kiro ────────────────────────────────────────────────────────────────────
+/**
+ * Symlinks each skill directory into ~/.kiro/skills/<pkgName>-<skillName>
+ * so Kiro can discover them as invocable skills.
+ */
+function syncSkillsToKiro(skills, brewRoot) {
+    const kiroDir = path_1.default.join(os_1.default.homedir(), '.kiro');
+    if (!fs_1.default.existsSync(kiroDir))
+        return [];
+    const skillsDir = path_1.default.join(kiroDir, 'skills');
+    fs_1.default.mkdirSync(skillsDir, { recursive: true });
+    const state = loadSyncedState(brewRoot);
+    return symlinkSkills(skills, skillsDir, state, 'kiro', brewRoot);
+}
+/**
+ * Removes all Kiro skill symlinks previously created by syncSkillsToKiro.
+ */
+function unsyncSkillsFromKiro(brewRoot) {
+    const skillsDir = path_1.default.join(os_1.default.homedir(), '.kiro', 'skills');
+    const state = loadSyncedState(brewRoot);
+    const results = removeTrackedSymlinks(state.kiro, skillsDir);
+    state.kiro = [];
+    saveSyncedState(state, brewRoot);
+    return results;
+}
+// ─── Kiro MCP server registration ────────────────────────────────────────────
+const KIRO_MCP_ENTRY = 'agentbrew';
+/**
+ * Adds agentbrew to ~/.kiro/settings/mcp.json so Kiro can discover MCP tools directly.
+ * Merges into any existing config without disturbing other servers.
+ */
+function syncMcpServerToKiro(brewRoot) {
+    const kiroDir = path_1.default.join(os_1.default.homedir(), '.kiro');
+    if (!fs_1.default.existsSync(kiroDir))
+        return [];
+    const settingsDir = path_1.default.join(kiroDir, 'settings');
+    fs_1.default.mkdirSync(settingsDir, { recursive: true });
+    const mcpJsonPath = path_1.default.join(settingsDir, 'mcp.json');
+    const entryName = 'agentbrew (Kiro MCP)';
+    let config = {};
+    try {
+        config = JSON.parse(fs_1.default.readFileSync(mcpJsonPath, 'utf-8'));
+    }
+    catch { }
+    const mcpServers = config.mcpServers ?? {};
+    const existing = mcpServers[KIRO_MCP_ENTRY];
+    if (existing?.command === 'agentbrew') {
+        const state = loadSyncedState(brewRoot);
+        state.kiroMcp = true;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName, status: 'already_exists', path: mcpJsonPath }];
+    }
+    config.mcpServers = { ...mcpServers, [KIRO_MCP_ENTRY]: { command: 'agentbrew' } };
+    try {
+        fs_1.default.writeFileSync(mcpJsonPath, JSON.stringify(config, null, 2), 'utf-8');
+        const state = loadSyncedState(brewRoot);
+        state.kiroMcp = true;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName, status: 'linked', path: mcpJsonPath }];
+    }
+    catch (e) {
+        return [{ entryName, status: 'error', note: e.message }];
+    }
+}
+/**
+ * Removes the agentbrew entry from ~/.kiro/settings/mcp.json.
+ * Leaves other servers intact; removes the file only if it becomes empty.
+ */
+function unsyncMcpServerFromKiro(brewRoot) {
+    const state = loadSyncedState(brewRoot);
+    if (!state.kiroMcp)
+        return [];
+    const mcpJsonPath = path_1.default.join(os_1.default.homedir(), '.kiro', 'settings', 'mcp.json');
+    const entryName = 'agentbrew (Kiro MCP)';
+    let config = {};
+    try {
+        config = JSON.parse(fs_1.default.readFileSync(mcpJsonPath, 'utf-8'));
+    }
+    catch {
+        state.kiroMcp = false;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName, status: 'skipped', note: 'Not found' }];
+    }
+    if (!config.mcpServers?.[KIRO_MCP_ENTRY]) {
+        state.kiroMcp = false;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName, status: 'skipped', note: 'Not found' }];
+    }
+    delete config.mcpServers[KIRO_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.kiroMcp = false;
+        saveSyncedState(state, brewRoot);
+        return [{ entryName, status: 'removed', path: mcpJsonPath }];
+    }
+    catch (e) {
+        return [{ entryName, 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';
@@ -57,12 +827,22 @@ function getDefaultTargets() {
             // We own this specific file entirely — no markers needed.
             configPath: path_1.default.join(home, '.cursor', 'rules', 'agentbrew-shared.md'),
             isFileOwned: true,
+            agentRootDir: path_1.default.join(home, '.cursor'),
         },
         {
             name: 'Windsurf',
             configPath: path_1.default.join(home, '.codeium', 'windsurf', 'memories', 'global_rules.md'),
             isFileOwned: false,
         },
+        {
+            name: 'Kiro',
+            // Steering files in ~/.kiro/steering/ are auto-loaded in every Kiro interaction.
+            // We own this file entirely and must place the frontmatter at the very top.
+            configPath: path_1.default.join(home, '.kiro', 'steering', 'agentbrew-shared.md'),
+            isFileOwned: true,
+            frontmatter: '---\ninclusion: always\n---',
+            agentRootDir: path_1.default.join(home, '.kiro'),
+        },
     ];
 }
 function getInstructionsPath(brewRoot) {
@@ -140,10 +920,17 @@ function syncInstructions(targets, brewRoot) {
             continue;
         }
         if (target.isFileOwned) {
+            // Skip if the agent's root directory doesn't exist (agent not installed).
+            // Without this guard, mkdirSync below would create the directory unconditionally.
+            if (target.agentRootDir && !fs_1.default.existsSync(target.agentRootDir)) {
+                results.push({ agent: target.name, status: 'skipped', note: 'Agent not installed (config directory not found)' });
+                continue;
+            }
             // 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';
+            const prefix = target.frontmatter ? target.frontmatter + '\n' : '';
+            const fileContent = prefix + 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')