@webpresso/agent-kit 0.21.0

package/dist/esm/symlinker/index.js

@@ -0,0 +1,496 @@
+#!/usr/bin/env node
+/**
+ * Audit & Auto-Fix: Agent Command/Workflow Symlinks
+ *
+ * Ensures all consumer directories (e.g. .claude/commands) use symlinks
+ * pointing to `.agent/` source files, keeps skill directories as single
+ * directory-symlinks, and regenerates `.gemini/commands/*.toml` from
+ * markdown sources.
+ *
+ * Auto-fixes:
+ * - Replaces real files with symlinks to .agent/ source
+ * - Removes broken symlinks and recreates them
+ * - Removes stale mirrored files when the .agent/ source no longer exists
+ * - Creates missing symlinks for all .agent/ entries
+ * - Removes symlinks pointing outside .agent/
+ *
+ * Usage:
+ *   wp symlink sync            # Phase 2 — wires to syncAll
+ *   node dist/symlinker/index  # direct invocation from built output
+ */
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, readlinkSync, rmSync, statSync, symlinkSync, unlinkSync, writeFileSync, } from 'node:fs';
+import { dirname, join, relative, resolve } from 'node:path';
+import { ALLOWED_REAL_FILES, DEFAULT_CONSUMERS, DEFAULT_PER_SKILL_CONSUMERS, DEFAULT_SKILLS_CONSUMERS, } from './consumers.js';
+import { parseMarkdownFrontmatter } from './frontmatter.js';
+import { toToml } from './toml.js';
+import { isSymlinkPointingTo } from './unified-sync.js';
+export { ALLOWED_REAL_FILES, DEFAULT_CONSUMERS, DEFAULT_PER_SKILL_CONSUMERS, DEFAULT_SKILLS_CONSUMERS, };
+export function isAgentOrConsumerFile(file) {
+    // Gemini TOML generated files
+    if (/^\.gemini\/commands\/.+\.toml$/.test(file))
+        return true;
+    if (!file.endsWith('.md'))
+        return false;
+    // .agent/ source markdown (commands, workflows, skills)
+    if (/^\.agent\/(commands|workflows|skills)\/.+\.md$/.test(file))
+        return true;
+    // Mirrored consumer command/workflow directories
+    for (const { dir } of DEFAULT_CONSUMERS) {
+        if (file.startsWith(`${dir}/`))
+            return true;
+    }
+    // Mirrored consumer skill directories (nested under skill subdirs)
+    for (const { linkPath } of DEFAULT_SKILLS_CONSUMERS) {
+        if (file.startsWith(`${linkPath}/`))
+            return true;
+    }
+    // Per-skill consumer directories (e.g. .agents/skills/<skill>/...)
+    for (const { dir } of DEFAULT_PER_SKILL_CONSUMERS) {
+        if (file.startsWith(`${dir}/`))
+            return true;
+    }
+    return false;
+}
+export function getAgentSources(repoRoot) {
+    const sources = new Map();
+    const commandsDir = join(repoRoot, '.agent/commands');
+    if (existsSync(commandsDir)) {
+        for (const commandFile of readdirSync(commandsDir).filter((fileName) => fileName.endsWith('.md'))) {
+            sources.set(commandFile, `commands/${commandFile}`);
+        }
+    }
+    const workflowsDir = join(repoRoot, '.agent/workflows');
+    if (existsSync(workflowsDir)) {
+        for (const workflowFile of readdirSync(workflowsDir).filter((fileName) => fileName.endsWith('.md'))) {
+            sources.set(workflowFile, `workflows/${workflowFile}`);
+        }
+    }
+    return sources;
+}
+export function syncSkillsConsumer(repoRoot, config) {
+    const fullPath = join(repoRoot, config.linkPath);
+    const parentDir = join(fullPath, '..');
+    mkdirSync(parentDir, { recursive: true });
+    console.log(`\n📁 ${config.linkPath}`);
+    const stats = (() => {
+        try {
+            return lstatSync(fullPath);
+        }
+        catch {
+            return null;
+        }
+    })();
+    if (stats) {
+        if (stats.isSymbolicLink()) {
+            const target = readlinkSync(fullPath);
+            const resolvedTarget = resolve(parentDir, target);
+            const isBroken = !existsSync(resolvedTarget);
+            const isCorrect = target.replace(/\\/g, '/') === config.target;
+            if (!isBroken && isCorrect) {
+                console.log('  ✅ Symlink correct');
+                return 0;
+            }
+            unlinkSync(fullPath);
+            const reason = isBroken ? 'broken' : `wrong target (${target})`;
+            console.log(`  🔧 Removed ${reason} symlink`);
+        }
+        else {
+            console.log(`  ⚠️  ${config.linkPath}: is a real directory — skipped (remove manually)`);
+            return 0;
+        }
+    }
+    createSymlinkWithType(config.target, fullPath, 'dir', config.linkPath);
+    console.log(`  ✅ ${config.linkPath} → ${config.target}`);
+    return 1;
+}
+export function syncSkills(repoRoot, consumers = DEFAULT_SKILLS_CONSUMERS) {
+    const skillsSource = join(repoRoot, '.agent/skills');
+    if (!existsSync(skillsSource))
+        return 0;
+    let fixCount = 0;
+    for (const consumer of consumers) {
+        fixCount += syncSkillsConsumer(repoRoot, consumer);
+    }
+    return fixCount;
+}
+/**
+ * Directory-level skill projection from `.agent/skills/<slug>/` into a
+ * per-IDE consumer dir (e.g. `.agents/skills/<slug>`). Codex documents support
+ * for symlinked skill folders; file-level `SKILL.md` symlinks inside real
+ * folders are not a documented discovery shape and can be skipped by hosts.
+ *
+ * Source-of-truth: `.agent/skills/<slug>/` (the consumer projection
+ * produced by `runUnifiedSync` + scaffolders). NOT `node_modules/.../skills/`
+ * (the legacy `sourceRootDir` semantic was dropped — the bug class was
+ * an asymmetric fallback where listing succeeded against `.agent/skills/`
+ * but symlink targets pointed at the missing `node_modules/.../skills/`).
+ *
+ * Contract: `.agents/skills/<slug>` is an webpresso-owned generated symlink.
+ * Top-level entries that do not correspond to a skill in `.agent/skills/` are
+ * removed recursively. Real directories for expected slugs are also replaced
+ * so stale file-level projections cannot mask the official directory-symlink
+ * discovery surface.
+ *
+ * Throws (synchronously) on any file-op error so callers see fail-loud
+ * exit codes instead of `console.log('✅')` followed by broken state.
+ */
+export function syncSkillFanout(repoRoot, config) {
+    const skillsSource = join(repoRoot, '.agent/skills');
+    if (!existsSync(skillsSource))
+        return { wrote: 0 };
+    const consumerDir = join(repoRoot, config.dir);
+    mkdirSync(consumerDir, { recursive: true });
+    console.log(`\n📁 ${config.dir} (per-skill, directory symlinks)`);
+    const agentSkills = readdirSync(skillsSource).filter((name) => {
+        try {
+            // `.agent/skills/<slug>` may be a symlink (catalog projection via
+            // unified-sync). statSync follows symlinks, lstatSync would not.
+            return statSync(join(skillsSource, name)).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    });
+    let wrote = 0;
+    for (const skill of agentSkills) {
+        const skillLinkDir = join(consumerDir, skill);
+        const srcDir = join(skillsSource, skill);
+        const expectedAbs = resolve(srcDir);
+        const stats = lstatNullable(skillLinkDir);
+        if (stats && stats.isSymbolicLink() && isSymlinkPointingTo(skillLinkDir, expectedAbs)) {
+            continue;
+        }
+        if (stats) {
+            rmSync(skillLinkDir, { recursive: true, force: true });
+            wrote++;
+        }
+        const relativeTarget = relative(consumerDir, srcDir);
+        createSymlinkWithType(relativeTarget, skillLinkDir, 'dir', `${config.dir}/${skill}`);
+        console.log(`  ✅ ${skill}/ → ${relativeTarget}`);
+        wrote++;
+    }
+    // Top-level prune: remove any consumer-dir entry that doesn't correspond
+    // to a current skill. Aggressive: real non-empty dirs are removed
+    // recursively (per the documented `.agents/skills/` ownership contract).
+    // Stderr line per removal so the destructive action is never silent.
+    const expectedSlugs = new Set(agentSkills);
+    for (const entry of readdirSync(consumerDir)) {
+        if (expectedSlugs.has(entry))
+            continue;
+        const entryPath = join(consumerDir, entry);
+        const entryStats = lstatNullable(entryPath);
+        if (!entryStats)
+            continue;
+        if (entryStats.isSymbolicLink()) {
+            unlinkSync(entryPath);
+            console.error(`Removed unexpected directory: ${config.dir}/${entry}`);
+            wrote++;
+        }
+        else if (entryStats.isDirectory()) {
+            rmSync(entryPath, { recursive: true, force: true });
+            console.error(`Removed unexpected directory: ${config.dir}/${entry}`);
+            wrote++;
+        }
+    }
+    if (wrote === 0)
+        console.log('  ✅ All symlinks correct');
+    return { wrote };
+}
+export function syncSkillFanouts(repoRoot, consumers = DEFAULT_PER_SKILL_CONSUMERS) {
+    const skillsSource = join(repoRoot, '.agent/skills');
+    if (!existsSync(skillsSource))
+        return { wrote: 0 };
+    let wrote = 0;
+    for (const consumer of consumers) {
+        wrote += syncSkillFanout(repoRoot, consumer).wrote;
+    }
+    return { wrote };
+}
+function lstatNullable(path) {
+    try {
+        return lstatSync(path);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Create a symlink with an explicit Windows type hint.
+ *
+ * On POSIX the `type` argument is ignored — symlinks carry no type. On
+ * Windows, `fs.symlinkSync` without a type arg tries to auto-detect by
+ * stat'ing the target; any failure there silently falls back to `'file'`,
+ * which breaks directory symlinks. Passing the type explicitly is safe on
+ * every platform and eliminates the Windows auto-detect failure mode.
+ *
+ * Windows also requires elevation or Developer Mode for symlink creation;
+ * an EPERM failure here rethrows with a pointer to the fix instead of a
+ * generic errno that's opaque to a first-time contributor.
+ */
+function createSymlinkWithType(target, linkPath, type, label) {
+    try {
+        symlinkSync(target, linkPath, type);
+    }
+    catch (error) {
+        const code = error.code;
+        if (process.platform === 'win32' && code === 'EPERM') {
+            throw new Error(`Cannot create symlink ${label} → ${target}: Windows denied permission. ` +
+                'Enable Developer Mode (Settings → Privacy & security → For developers) ' +
+                'or run this script from an elevated shell.', { cause: error });
+        }
+        throw error;
+    }
+}
+export function createSymlink(repoRoot, consumerDir, file, symlinkTarget) {
+    const fullPath = join(repoRoot, consumerDir, file);
+    createSymlinkWithType(symlinkTarget, fullPath, 'file', `${consumerDir}/${file}`);
+    console.log(`  ✅ ${file} → ${symlinkTarget}`);
+}
+function removeAndRelink(repoRoot, consumerDir, file, symlinkTarget) {
+    const fullPath = join(repoRoot, consumerDir, file);
+    unlinkSync(fullPath);
+    createSymlinkWithType(symlinkTarget, fullPath, 'file', `${consumerDir}/${file}`);
+}
+export function fixExistingFile(repoRoot, config, file, agentSources) {
+    const fullPath = join(repoRoot, config.dir, file);
+    const stats = lstatSync(fullPath);
+    const agentPath = agentSources.get(file);
+    const expectedTarget = agentPath ? `${config.sourcePrefix}${agentPath}` : null;
+    if (!stats.isSymbolicLink()) {
+        if (!expectedTarget) {
+            console.log(`  ⚠️  ${file}: real file with no .agent/ source — skipped (move manually)`);
+            return false;
+        }
+        removeAndRelink(repoRoot, config.dir, file, expectedTarget);
+        console.log(`  🔧 ${file}: replaced real file → ${expectedTarget}`);
+        return true;
+    }
+    const target = readlinkSync(fullPath);
+    const normalizedTarget = target.replace(/\\/g, '/');
+    const resolvedTarget = resolve(join(repoRoot, config.dir), target);
+    const isBroken = !existsSync(resolvedTarget);
+    const isOutsideAgent = !normalizedTarget.includes('.agent/');
+    const isWrongTarget = expectedTarget !== null && normalizedTarget !== expectedTarget;
+    if (!isBroken && !isOutsideAgent && !isWrongTarget)
+        return false;
+    if (!expectedTarget) {
+        unlinkSync(fullPath);
+        console.log(`  🗑️  ${file}: removed broken symlink (no .agent/ source)`);
+        return true;
+    }
+    removeAndRelink(repoRoot, config.dir, file, expectedTarget);
+    const reason = isBroken
+        ? 'broken'
+        : isOutsideAgent
+            ? 'outside .agent/'
+            : `wrong target (was ${target})`;
+    console.log(`  🔧 ${file}: fixed ${reason} symlink → ${expectedTarget}`);
+    return true;
+}
+export function createMissingSymlinks(repoRoot, config, existingFiles, agentSources) {
+    let count = 0;
+    for (const [agentFile, agentPath] of agentSources) {
+        if (ALLOWED_REAL_FILES.has(agentFile) || existingFiles.has(agentFile))
+            continue;
+        createSymlink(repoRoot, config.dir, agentFile, `${config.sourcePrefix}${agentPath}`);
+        count++;
+    }
+    return count;
+}
+export function syncConsumer(repoRoot, config, agentSources) {
+    const fullDir = join(repoRoot, config.dir);
+    mkdirSync(fullDir, { recursive: true });
+    const files = readdirSync(fullDir);
+    console.log(`\n📁 ${config.dir}`);
+    let fixCount = 0;
+    for (const file of files) {
+        if (!file.endsWith('.md') || ALLOWED_REAL_FILES.has(file))
+            continue;
+        if (fixExistingFile(repoRoot, config, file, agentSources))
+            fixCount++;
+    }
+    const consumerFiles = new Set(files.filter((f) => f.endsWith('.md')));
+    fixCount += createMissingSymlinks(repoRoot, config, consumerFiles, agentSources);
+    if (fixCount === 0)
+        console.log('  ✅ All symlinks correct');
+    return fixCount;
+}
+// === Gemini CLI TOML Generation ===
+// Gemini CLI uses .gemini/commands/*.toml (not markdown symlinks)
+// We generate TOML from .agent/commands/ and .agent/workflows/ sources
+export function syncGeminiCommands(repoRoot) {
+    const geminiDir = join(repoRoot, '.gemini/commands');
+    mkdirSync(geminiDir, { recursive: true });
+    console.log('\n📁 .gemini/commands (TOML generation)');
+    // Collect sources: workflows first (lower priority), then commands override
+    const sources = new Map();
+    const workflowsDir = join(repoRoot, '.agent/workflows');
+    if (existsSync(workflowsDir)) {
+        for (const workflowFile of readdirSync(workflowsDir).filter((fileName) => fileName.endsWith('.md'))) {
+            const name = workflowFile.replace('.md', '');
+            const content = readFileSync(join(workflowsDir, workflowFile), 'utf8');
+            const { description, body } = parseMarkdownFrontmatter(content);
+            sources.set(name, { description, body, source: 'workflows' });
+        }
+    }
+    const commandsDir = join(repoRoot, '.agent/commands');
+    if (existsSync(commandsDir)) {
+        for (const commandFile of readdirSync(commandsDir).filter((fileName) => fileName.endsWith('.md'))) {
+            const name = commandFile.replace('.md', '');
+            const content = readFileSync(join(commandsDir, commandFile), 'utf8');
+            const { description, body } = parseMarkdownFrontmatter(content);
+            sources.set(name, { description, body, source: 'commands' });
+        }
+    }
+    let fixCount = 0;
+    const existingToml = new Set(readdirSync(geminiDir).filter((f) => f.endsWith('.toml')));
+    for (const [name, src] of sources) {
+        const tomlFile = `${name}.toml`;
+        const tomlPath = join(geminiDir, tomlFile);
+        // Convert $ARGUMENTS → {{args}} for Gemini's argument substitution
+        const prompt = src.body.replace(/\$ARGUMENTS/g, '{{args}}');
+        const tomlContent = toToml(src.description, prompt);
+        let needsWrite = true;
+        if (existsSync(tomlPath)) {
+            const existing = readFileSync(tomlPath, 'utf8');
+            if (existing === tomlContent) {
+                needsWrite = false;
+            }
+        }
+        if (needsWrite) {
+            writeFileSync(tomlPath, tomlContent);
+            console.log(`  ✅ ${tomlFile} (from .agent/${src.source}/${name}.md)`);
+            fixCount++;
+        }
+        existingToml.delete(tomlFile);
+    }
+    // Remove stale TOML files that no longer have a source
+    for (const stale of existingToml) {
+        unlinkSync(join(geminiDir, stale));
+        console.log(`  🗑️  ${stale}: removed (no source)`);
+        fixCount++;
+    }
+    if (fixCount === 0)
+        console.log('  ✅ All TOML files up to date');
+    return fixCount;
+}
+/**
+ * Sync repo-root AGENTS.md from canonical .agent/AGENTS.md.
+ * Returns 1 if a write occurred, 0 if already up to date.
+ */
+export function syncAgentsMd(repoRoot) {
+    const source = join(repoRoot, '.agent', 'AGENTS.md');
+    if (!existsSync(source))
+        return 0;
+    const dest = join(repoRoot, 'AGENTS.md');
+    const content = readFileSync(source, 'utf8');
+    if (existsSync(dest)) {
+        const existing = readFileSync(dest, 'utf8');
+        if (existing === content) {
+            console.log('\n📄 AGENTS.md — up to date');
+            return 0;
+        }
+    }
+    writeFileSync(dest, content);
+    console.log('\n📄 AGENTS.md — written from .agent/AGENTS.md');
+    return 1;
+}
+/**
+ * Fan out .agent/mcp.json to canonical MCP consumer paths:
+ *   .mcp.json, .cursor/mcp.json
+ * Returns the number of files written/updated.
+ */
+export function syncMcpJson(repoRoot) {
+    const source = join(repoRoot, '.agent', 'mcp.json');
+    if (!existsSync(source))
+        return 0;
+    const content = readFileSync(source, 'utf8');
+    const targets = [join(repoRoot, '.mcp.json'), join(repoRoot, '.cursor', 'mcp.json')];
+    let writeCount = 0;
+    console.log('\n🔌 MCP server registration fan-out');
+    for (const dest of targets) {
+        mkdirSync(dirname(dest), { recursive: true });
+        if (existsSync(dest)) {
+            const existing = readFileSync(dest, 'utf8');
+            if (existing === content) {
+                const rel = relative(repoRoot, dest);
+                console.log(`  ✅ ${rel} — up to date`);
+                continue;
+            }
+        }
+        writeFileSync(dest, content);
+        const rel = relative(repoRoot, dest);
+        console.log(`  ✅ ${rel} — written from .agent/mcp.json`);
+        writeCount++;
+    }
+    return writeCount;
+}
+export function syncAll(repoRoot, consumers = DEFAULT_CONSUMERS) {
+    console.log('🔗 Syncing agent command/workflow symlinks...');
+    const agentSources = getAgentSources(repoRoot);
+    console.log(`   Found ${agentSources.size} source files in .agent/`);
+    let totalFixes = 0;
+    for (const consumer of consumers) {
+        totalFixes += syncConsumer(repoRoot, consumer, agentSources);
+    }
+    totalFixes += syncSkills(repoRoot, DEFAULT_SKILLS_CONSUMERS);
+    totalFixes += syncSkillFanouts(repoRoot, DEFAULT_PER_SKILL_CONSUMERS).wrote;
+    totalFixes += syncGeminiCommands(repoRoot);
+    // Fan-out writes are tracked separately — they are not "broken symlinks",
+    // so they must not pollute totalFixes (which gates `wp symlink check`).
+    syncAgentsMd(repoRoot);
+    syncMcpJson(repoRoot);
+    console.log();
+    if (totalFixes > 0) {
+        console.log(`🔧 Fixed ${totalFixes} symlinks`);
+    }
+    else {
+        console.log('✅ All agent command/workflow/skill symlinks are properly configured');
+    }
+    return totalFixes;
+}
+/**
+ * Import an existing IDE rule file into the canonical .agent/ directory.
+ *
+ * Supported sources: .cursorrules, CLAUDE.md, .github/copilot-instructions.md
+ *
+ * The source file is copied to .agent/AGENTS.md (if it does not already
+ * exist), leaving the original in place so that a subsequent `wp symlink sync`
+ * can fan it back out.  Returns the destination path on success, or null when
+ * the source file does not exist.
+ */
+export function importAgentFile(repoRoot, fromPath) {
+    const KNOWN_SOURCES = {
+        '.cursorrules': 'AGENTS.md',
+        'CLAUDE.md': 'AGENTS.md',
+        '.github/copilot-instructions.md': 'AGENTS.md',
+    };
+    // Normalise: strip leading ./ for map lookup
+    const normalised = fromPath.replace(/^\.\//, '');
+    const destName = KNOWN_SOURCES[normalised];
+    if (destName === undefined) {
+        return null;
+    }
+    const sourcePath = join(repoRoot, normalised);
+    if (!existsSync(sourcePath)) {
+        return null;
+    }
+    const agentDir = join(repoRoot, '.agent');
+    mkdirSync(agentDir, { recursive: true });
+    const destPath = join(agentDir, destName);
+    const content = readFileSync(sourcePath, 'utf8');
+    writeFileSync(destPath, content);
+    return { source: normalised, dest: `.agent/${destName}` };
+}
+// CLI entrypoint — executes when the module is run directly.
+// `import.meta.main` is Bun-specific; fall back to a `process.argv[1]` URL
+// comparison for Node compatibility. `@types/bun` makes `main` a typed
+// property on `ImportMeta`, so we can read it directly under either runtime.
+const isMain = (typeof import.meta.main === 'boolean' && import.meta.main) ||
+    (typeof process !== 'undefined' &&
+        process.argv[1] !== undefined &&
+        import.meta.url === `file://${process.argv[1]}`);
+if (isMain) {
+    syncAll(process.cwd());
+}
+//# sourceMappingURL=index.js.map

package/dist/esm/symlinker/test-utils/assert-symlink-resolves.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Test helper enforcing the bc88 invariant: every emitted symlink under
+ * `.agents/skills/` (or anywhere webpresso's symlinker writes) must resolve
+ * to a real file on disk.
+ *
+ * The historical failure mode was `console.log('✅')` followed by a symlink
+ * whose target doesn't exist — `lstatSync` succeeds (symlink exists), but
+ * the file the symlink points to doesn't. Use this helper instead of
+ * `expect(stat.isSymbolicLink()).toBe(true)` so dangling links fail tests.
+ */
+export declare function assertSymlinkResolves(linkPath: string): void;
+//# sourceMappingURL=assert-symlink-resolves.d.ts.map

package/dist/esm/symlinker/test-utils/assert-symlink-resolves.js

@@ -0,0 +1,24 @@
+import { existsSync, realpathSync } from 'node:fs';
+/**
+ * Test helper enforcing the bc88 invariant: every emitted symlink under
+ * `.agents/skills/` (or anywhere webpresso's symlinker writes) must resolve
+ * to a real file on disk.
+ *
+ * The historical failure mode was `console.log('✅')` followed by a symlink
+ * whose target doesn't exist — `lstatSync` succeeds (symlink exists), but
+ * the file the symlink points to doesn't. Use this helper instead of
+ * `expect(stat.isSymbolicLink()).toBe(true)` so dangling links fail tests.
+ */
+export function assertSymlinkResolves(linkPath) {
+    let target;
+    try {
+        target = realpathSync(linkPath);
+    }
+    catch (cause) {
+        throw new Error(`Dangling symlink: ${linkPath} (realpathSync failed)`, { cause });
+    }
+    if (!existsSync(target)) {
+        throw new Error(`Dangling symlink: ${linkPath} → ${target} (target does not exist)`);
+    }
+}
+//# sourceMappingURL=assert-symlink-resolves.js.map

package/dist/esm/symlinker/toml.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Gemini CLI TOML writer.
+ *
+ * Gemini's command surface lives under `.gemini/commands/*.toml`, not markdown.
+ * Rather than symlinking, we transform `.agent/commands/*.md` and
+ * `.agent/workflows/*.md` sources into TOML and write them out. This module
+ * owns the TOML shape; the `$ARGUMENTS` → `{{args}}` substitution is applied
+ * by the caller before passing the `prompt` string in.
+ */
+export declare function toToml(description: string, prompt: string): string;
+//# sourceMappingURL=toml.d.ts.map

package/dist/esm/symlinker/toml.js

@@ -0,0 +1,16 @@
+/**
+ * Gemini CLI TOML writer.
+ *
+ * Gemini's command surface lives under `.gemini/commands/*.toml`, not markdown.
+ * Rather than symlinking, we transform `.agent/commands/*.md` and
+ * `.agent/workflows/*.md` sources into TOML and write them out. This module
+ * owns the TOML shape; the `$ARGUMENTS` → `{{args}}` substitution is applied
+ * by the caller before passing the `prompt` string in.
+ */
+export function toToml(description, prompt) {
+    const escapedDesc = description.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    // In TOML multiline basic strings ("""), escape backslashes and sequences of 3+ quotes
+    const escapedPrompt = prompt.replace(/\\/g, '\\\\').replace(/"""/g, '""\\"');
+    return `description = "${escapedDesc}"\n\nprompt = """\n${escapedPrompt}\n"""\n`;
+}
+//# sourceMappingURL=toml.js.map

package/dist/esm/symlinker/unified-sync.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Unified rule + skill sync.
+ *
+ * Source of truth: catalog (`<pkg>/dist/catalog/agent/{rules,skills}/`) UNION
+ * consumer (`<repo>/agent-{rules,skills}/`). The loader returns a
+ * source-tagged record list; this module projects that list into per-IDE
+ * surfaces according to `DEFAULT_UNIFIED_CONSUMERS`.
+ *
+ * Per-consumer strategy:
+ *   - 'symlink':   relative symlink (file for rules, dir for skills).
+ *   - 'copy':      atomic copy (file for rules, recursive copy for skills).
+ *   - 'transform': apply the consumer's transform function to the record body
+ *                  and atomic-write the result at the target path.
+ *
+ * Prune: any file/dir under a consumer's dir whose name matches the unified
+ * filename pattern but is not in the expected set is removed. This propagates
+ * deletions in `agent-rules/` and `agent-skills/` to per-IDE cleanup.
+ *
+ * `--check` mode (dry-run): produce a list of (target, status) pairs and
+ * return the count of mismatches; perform no writes.
+ */
+import { type ContentKind } from '#content/loader';
+import { type UnifiedConsumerConfig } from './consumers.js';
+export interface UnifiedSyncOptions {
+    readonly catalogDir: string;
+    readonly consumerRoot: string;
+    /** Optional kind filter. Default: rules + skills. */
+    readonly kinds?: readonly ContentKind[];
+    /** When true, report mismatches without writing. */
+    readonly check?: boolean;
+    /** Override consumer registry (testing). */
+    readonly consumers?: readonly UnifiedConsumerConfig[];
+    /**
+     * Optional allowlist of skill slugs. When provided, only `kind === 'skill'`
+     * records whose slug is in this set are projected. Rules are unaffected.
+     * Used by `wp setup` to gate Tier-3 skills behind opt-in selection while
+     * still letting all canonical rules flow through.
+     */
+    readonly allowedSkillSlugs?: ReadonlySet<string>;
+    /**
+     * Optional set of skill slugs that must NOT be pruned even though they are
+     * absent from the projected record set. Used by `wp setup` for skills that
+     * are produced by separate scaffolders (e.g. the rendered
+     * generated skills that are produced outside the catalog.
+     */
+    readonly preserveSkillSlugs?: ReadonlySet<string>;
+}
+export interface UnifiedSyncMismatch {
+    readonly consumerId: string;
+    readonly targetPath: string;
+    readonly reason: string;
+}
+export interface UnifiedSyncResult {
+    /** Number of writes performed (or, in check mode, mismatches detected). */
+    readonly fixCount: number;
+    /** Mismatches surfaced in check mode. Empty in non-check mode. */
+    readonly mismatches: readonly UnifiedSyncMismatch[];
+}
+export declare function isSymlinkPointingTo(linkPath: string, expectedAbs: string): boolean;
+/**
+ * Main entrypoint. See module docstring.
+ */
+export declare function runUnifiedSync(options: UnifiedSyncOptions): UnifiedSyncResult;
+//# sourceMappingURL=unified-sync.d.ts.map