@dsalazardev/ai-hub-cli 0.0.0-stage → 0.1.0

package/dist/sync/lock.js

@@ -0,0 +1,43 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export const LOCK_PATH = 'sync.lock.json';
+export const GENERATOR_VERSION = '1.0.0';
+export function sha256(text) {
+    return createHash('sha256').update(text, 'utf8').digest('hex');
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+export async function readLock(root) {
+    const raw = await fs.readFile(path.join(root, LOCK_PATH), 'utf8').catch(() => null);
+    if (raw === null) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`${LOCK_PATH} no es JSON válido: ${error.message}`);
+    }
+    if (!isRecord(parsed) || !isRecord(parsed.files) || !isRecord(parsed.sources)) {
+        throw new Error(`${LOCK_PATH} no tiene el formato esperado; bórralo y ejecuta ai-hub sync`);
+    }
+    if (parsed.version === 1) {
+        const legacy = parsed;
+        return { version: 2, generatorVersion: 'legacy', sources: legacy.sources, files: legacy.files };
+    }
+    if (parsed.version !== 2) {
+        throw new Error(`${LOCK_PATH} usa una versión no soportada; bórralo y ejecuta ai-hub sync`);
+    }
+    return {
+        version: 2,
+        generatorVersion: typeof parsed.generatorVersion === 'string' ? parsed.generatorVersion : 'unknown',
+        sources: parsed.sources,
+        files: parsed.files,
+    };
+}
+export async function writeLock(root, lock) {
+    await fs.writeFile(path.join(root, LOCK_PATH), `${JSON.stringify(lock, null, 2)}\n`, 'utf8');
+}

package/dist/sync/render.d.ts

@@ -0,0 +1,18 @@
+import { type SyncConfig } from './config.js';
+export interface RenderedFile {
+    content: string;
+    source: string;
+    markerSource?: string;
+}
+export type RenderedFiles = Map<string, RenderedFile>;
+export declare function renderAll(root: string, config: SyncConfig): Promise<RenderedFiles>;
+export declare class DestinationCollisionError extends Error {
+    readonly destination: string;
+    readonly first: string;
+    readonly second: string;
+    constructor(destination: string, first: string, second: string);
+}
+export declare function putRendered(out: RenderedFiles, destination: string, file: RenderedFile): void;
+export declare function normalize(text: string): string;
+export declare function markerFor(source: string): string;
+export declare function withMarker(content: string, source: string): string;

package/dist/sync/render.js

@@ -0,0 +1,255 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parse, stringify } from 'yaml';
+import { frontmatterString, splitFrontmatter } from '../frontmatter.js';
+import { resolveSourcePath } from './config.js';
+import { TARGETS } from './targets.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const MANIFEST_SOURCE = 'manifest.yaml';
+const CLAUDE_AGENT_KEYS = ['name', 'description', 'tools', 'model', 'color', 'memory'];
+const PREFLIGHT_SOURCE = '@engine/engine/preflight.md';
+const PREFLIGHT_MARKER_SOURCE = 'engine/preflight.md';
+export async function renderAll(root, config) {
+    const out = new Map();
+    await renderSkills(root, config, out);
+    await renderAgents(root, config, out);
+    await renderRules(root, config, out);
+    await renderPreflight(root, config, out);
+    await renderMcp(root, config, out);
+    return out;
+}
+async function renderPreflight(root, config, out) {
+    const sourcePath = path.join(__dirname, '..', '..', 'engine', 'preflight.md');
+    const body = normalize(await fs.readFile(sourcePath, 'utf8'));
+    for (const tool of config.tools) {
+        const spec = TARGETS[tool];
+        if (spec.hookKind === 'cursor-mdc') {
+            putRendered(out, spec.hook, {
+                content: withMarker(frontmatter({ description: 'Deterministic preflight guard', alwaysApply: true }) + body, PREFLIGHT_MARKER_SOURCE),
+                source: PREFLIGHT_SOURCE,
+                markerSource: PREFLIGHT_MARKER_SOURCE,
+            });
+            continue;
+        }
+        if (spec.hookKind === 'copilot-instructions') {
+            putRendered(out, spec.hook, {
+                content: withMarker(frontmatter({ applyTo: '**' }) + body, PREFLIGHT_MARKER_SOURCE),
+                source: PREFLIGHT_SOURCE,
+                markerSource: PREFLIGHT_MARKER_SOURCE,
+            });
+            continue;
+        }
+        putRendered(out, spec.hook, {
+            content: withMarker(body, PREFLIGHT_MARKER_SOURCE),
+            source: PREFLIGHT_SOURCE,
+            markerSource: PREFLIGHT_MARKER_SOURCE,
+        });
+    }
+}
+export class DestinationCollisionError extends Error {
+    destination;
+    first;
+    second;
+    constructor(destination, first, second) {
+        super(`colisión de destinos: ${destination} (${first} vs ${second})`);
+        this.destination = destination;
+        this.first = first;
+        this.second = second;
+        this.name = 'DestinationCollisionError';
+    }
+}
+export function putRendered(out, destination, file) {
+    const existing = out.get(destination);
+    if (existing && existing.source !== file.source) {
+        throw new DestinationCollisionError(destination, existing.source, file.source);
+    }
+    out.set(destination, file);
+}
+export function normalize(text) {
+    return text.replace(/\r\n?/g, '\n');
+}
+export function markerFor(source) {
+    return `<!-- GENERADO por ai-hub sync desde ${source} — no editar -->`;
+}
+export function withMarker(content, source) {
+    const marker = markerFor(source);
+    const frontmatter = /^---\n[\s\S]*?\n---\n/.exec(content);
+    if (frontmatter) {
+        return `${frontmatter[0]}${marker}\n${content.slice(frontmatter[0].length)}`;
+    }
+    return `${marker}\n${content}`;
+}
+function frontmatter(data) {
+    return `---\n${stringify(data)}---\n`;
+}
+async function readSource(root, sourcePath) {
+    const text = await fs.readFile(resolveSourcePath(root, sourcePath), 'utf8').catch(() => {
+        throw new Error(`fuente no encontrada: ${sourcePath}`);
+    });
+    return normalize(text);
+}
+async function listFiles(dir) {
+    const entries = await fs.readdir(dir, { withFileTypes: true });
+    const files = [];
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...(await listFiles(full)));
+        }
+        else if (entry.isFile()) {
+            files.push(full);
+        }
+    }
+    return files.sort();
+}
+function toPosix(relative) {
+    return relative.split(path.sep).join('/');
+}
+async function renderSkills(root, config, out) {
+    for (const { source, publish } of config.skills.sources) {
+        for (const name of publish) {
+            const skillDir = resolveSourcePath(root, `${source}/${name}`);
+            const skillSourcePath = `${source}/${name}/SKILL.md`;
+            const skillText = await readSource(root, skillSourcePath);
+            const { data: skillData, body: skillBody } = splitFrontmatter(skillText, skillSourcePath);
+            frontmatterString(skillData, 'name', skillSourcePath);
+            const description = frontmatterString(skillData, 'description', skillSourcePath);
+            const files = await listFiles(skillDir).catch(() => {
+                throw new Error(`skill publicada no existe: ${source}/${name}`);
+            });
+            for (const target of config.skills.targets) {
+                if (target.shape === 'file') {
+                    const content = frontmatter({ description, alwaysApply: false }) + withMarker(skillBody, skillSourcePath);
+                    putRendered(out, `${target.path}/${name}.mdc`, { content, source: skillSourcePath });
+                    continue;
+                }
+                for (const file of files) {
+                    const rel = toPosix(path.relative(skillDir, file));
+                    const sourcePath = `${source}/${name}/${rel}`;
+                    const text = rel === 'SKILL.md'
+                        ? skillText
+                        : normalize(await fs.readFile(file, 'utf8'));
+                    const content = rel.endsWith('.md') ? withMarker(text, sourcePath) : text;
+                    putRendered(out, `${target.path}/${name}/${rel}`, { content, source: sourcePath });
+                }
+            }
+        }
+    }
+}
+async function renderAgents(root, config, out) {
+    const { source, publish, targets } = config.agents;
+    for (const name of publish) {
+        const sourcePath = `${source}/${name}.md`;
+        const { data, body } = splitFrontmatter(await readSource(root, sourcePath), sourcePath);
+        frontmatterString(data, 'name', sourcePath);
+        const description = frontmatterString(data, 'description', sourcePath);
+        const claudeData = Object.fromEntries(CLAUDE_AGENT_KEYS.filter((key) => key in data).map((key) => [key, data[key]]));
+        const subagentData = { description, mode: 'subagent' };
+        for (const [tool, target] of Object.entries(targets)) {
+            putRendered(out, `${target.path}/${name}.md`, {
+                content: tool === 'claude'
+                    ? withMarker(frontmatter(claudeData) + body, sourcePath)
+                    : withMarker(frontmatter(subagentData) + body, sourcePath),
+                source: sourcePath,
+            });
+        }
+    }
+}
+async function renderRules(root, config, out) {
+    const dir = config.rules.source;
+    for (const area of config.rules.publish) {
+        const sourcePath = `${dir}/${area}.md`;
+        const body = await readSource(root, sourcePath);
+        const isCore = area === 'core';
+        for (const [tool, target] of Object.entries(config.rules.targets)) {
+            if (target.shape === 'mdc') {
+                putRendered(out, `${target.path}/${area}.mdc`, {
+                    content: withMarker(frontmatter({
+                        description: isCore ? 'Core project rules' : `Rules for ${area}`,
+                        globs: isCore ? '**' : `${area}/**`,
+                        alwaysApply: isCore,
+                    }) + body, sourcePath),
+                    source: sourcePath,
+                });
+                continue;
+            }
+            if (target.shape === 'instructions') {
+                putRendered(out, `${target.path}/${area}.instructions.md`, {
+                    content: withMarker(frontmatter({ applyTo: isCore ? '**' : `${area}/**` }) + body, sourcePath),
+                    source: sourcePath,
+                });
+                continue;
+            }
+            const data = isCore ? {} : { paths: [`${area}/**`] };
+            putRendered(out, `${target.path}/${area}.md`, {
+                content: withMarker(frontmatter(data) + body, sourcePath),
+                source: sourcePath,
+            });
+            void tool;
+        }
+    }
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function readMcpServers(text, source) {
+    const data = parse(text);
+    if (!isRecord(data) || !Array.isArray(data.required_mcps)) {
+        throw new Error(`${source}: falta la lista required_mcps`);
+    }
+    return data.required_mcps
+        .map((item) => {
+        if (!isRecord(item) || typeof item.id !== 'string' || !isRecord(item.client)) {
+            throw new Error(`${source}: cada MCP necesita "id" y un bloque "client"`);
+        }
+        const { url, command, args } = item.client;
+        const argList = Array.isArray(args) && args.every((a) => typeof a === 'string') ? args : [];
+        if (typeof url !== 'string' && typeof command !== 'string') {
+            throw new Error(`${source}: el MCP "${item.id}" necesita client.url o client.command`);
+        }
+        return {
+            id: item.id,
+            url: typeof url === 'string' ? url : null,
+            command: typeof command === 'string' ? command : null,
+            args: argList,
+        };
+    })
+        .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}
+async function renderMcp(root, config, out) {
+    const claude = {};
+    const cursor = {};
+    const vscode = {};
+    const opencode = {};
+    const source = config.mcp?.source ?? MANIFEST_SOURCE;
+    if (config.mcp) {
+        const servers = readMcpServers(await readSource(root, config.mcp.source), config.mcp.source);
+        for (const server of servers) {
+            if (server.url !== null) {
+                claude[server.id] = { type: 'http', url: server.url };
+                cursor[server.id] = { url: server.url };
+                vscode[server.id] = { type: 'http', url: server.url };
+                opencode[server.id] = { type: 'remote', url: server.url, enabled: true };
+            }
+            else if (server.command !== null) {
+                claude[server.id] = { command: server.command, args: server.args };
+                cursor[server.id] = { command: server.command, args: server.args };
+                vscode[server.id] = { type: 'stdio', command: server.command, args: server.args };
+                opencode[server.id] = { type: 'local', command: [server.command, ...server.args], enabled: true };
+            }
+        }
+        const json = (data) => `${JSON.stringify(data, null, 2)}\n`;
+        putRendered(out, '.mcp.json', { content: json({ mcpServers: claude }), source });
+        putRendered(out, '.cursor/mcp.json', { content: json({ mcpServers: cursor }), source });
+        putRendered(out, '.vscode/mcp.json', { content: json({ servers: vscode }), source });
+    }
+    putRendered(out, 'opencode.json', {
+        content: `${JSON.stringify({
+            $schema: 'https://opencode.ai/config.json',
+            instructions: config.opencode.instructions,
+            mcp: opencode,
+        }, null, 2)}\n`,
+        source: MANIFEST_SOURCE,
+    });
+}

package/dist/sync/sync.d.ts

@@ -0,0 +1,38 @@
+import { type RenderedFiles } from './render.js';
+import { type SyncLock } from './lock.js';
+export interface SyncResult {
+    written: string[];
+    removed: string[];
+    problems: string[];
+}
+export interface SyncOptions {
+    check: boolean;
+    force?: boolean;
+}
+export declare class SyncSourceError extends Error {
+    readonly source: string;
+    readonly resolvedPath: string;
+    constructor(source: string, resolvedPath: string);
+}
+export declare class SyncSourceCheckoutError extends Error {
+    readonly root: string;
+    constructor(root: string);
+}
+export declare function runSync(root: string, options: SyncOptions): Promise<SyncResult>;
+export declare function buildLock(root: string, rendered: RenderedFiles): Promise<SyncLock>;
+export declare function checkLockIntegrity(root: string, lock: SyncLock): Promise<string[]>;
+export type LockCategory = 'skills' | 'agents' | 'rules' | 'preflight' | 'mcp' | 'other';
+export interface LockCheckResult {
+    ok: boolean;
+    expectedCount: number;
+    actualCount: number;
+    expectedSourceCount: number;
+    actualSourceCount: number;
+    breakdown: Record<LockCategory, number>;
+    missing: string[];
+    extra: string[];
+    different: string[];
+    invalidSources: string[];
+    error: string | null;
+}
+export declare function checkLock(root: string): Promise<LockCheckResult>;

package/dist/sync/sync.js

@@ -0,0 +1,288 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { isEngineCheckout } from '../source-checkout.js';
+import { loadSyncConfig, resolveSourcePath } from './config.js';
+import { normalize, renderAll } from './render.js';
+import { GENERATOR_VERSION, readLock, sha256, writeLock, } from './lock.js';
+export class SyncSourceError extends Error {
+    source;
+    resolvedPath;
+    constructor(source, resolvedPath) {
+        super(`fuente no encontrada: ${source} (resuelta a ${resolvedPath})`);
+        this.source = source;
+        this.resolvedPath = resolvedPath;
+        this.name = 'SyncSourceError';
+    }
+}
+export class SyncSourceCheckoutError extends Error {
+    root;
+    constructor(root) {
+        super(`checkout del motor: ${root}\n` +
+            'Proyectar aquí replicaría skills, agentes y reglas sobre el taller.\n' +
+            'Los destinos de agente pertenecen al proyecto consumidor, no al repo que publica el motor.\n' +
+            'Usa sync --force sólo si quieres dogfooding deliberado.');
+        this.root = root;
+        this.name = 'SyncSourceCheckoutError';
+    }
+}
+export async function runSync(root, options) {
+    if (!options.check && !options.force && (await isEngineCheckout(root))) {
+        throw new SyncSourceCheckoutError(root);
+    }
+    const config = await loadSyncConfig(root);
+    const rendered = await renderAll(root, config);
+    const previous = await readLock(root);
+    const result = { written: [], removed: [], problems: [] };
+    const symlinks = await findSymlinks(root, config, rendered);
+    const obsolete = previous
+        ? Object.keys(previous.files)
+            .filter((rel) => !rendered.has(rel))
+            .sort()
+        : [];
+    if (options.check) {
+        result.problems.push(...(await checkCopies(root, rendered, previous)));
+        result.problems.push(...symlinks.map((rel) => `enlace simbólico no permitido: ${rel}`));
+        result.problems.push(...obsolete.map((rel) => `destino obsoleto: ${rel}`));
+        return result;
+    }
+    const nextLock = await buildLock(root, rendered);
+    for (const rel of symlinks) {
+        await fs.unlink(path.join(root, rel));
+        result.removed.push(rel);
+    }
+    for (const rel of obsolete) {
+        await fs.rm(path.join(root, rel), { force: true });
+        result.removed.push(rel);
+    }
+    for (const [rel, file] of sortedEntries(rendered)) {
+        const abs = path.join(root, rel);
+        const current = await readCopy(abs);
+        if (current === file.content) {
+            continue;
+        }
+        await fs.mkdir(path.dirname(abs), { recursive: true });
+        await fs.writeFile(abs, file.content, 'utf8');
+        result.written.push(rel);
+    }
+    await writeLock(root, nextLock);
+    return result;
+}
+function sourceDescription(source) {
+    return source.startsWith('@engine/')
+        ? 'viene del motor; actualiza el paquete'
+        : `fuente: ${source}`;
+}
+async function checkCopies(root, rendered, previous) {
+    const problems = [];
+    for (const [rel, file] of sortedEntries(rendered)) {
+        const current = await readCopy(path.join(root, rel));
+        if (current === null) {
+            problems.push(`falta ${rel} (${sourceDescription(file.source)})`);
+        }
+        else if (current !== file.content) {
+            const registered = previous?.files[rel];
+            if (registered && sha256(current) !== registered.sha256) {
+                const hint = file.source.startsWith('@engine/')
+                    ? 'viene del motor; actualiza el paquete'
+                    : `edita la fuente: ${file.source}`;
+                problems.push(`editado a mano: ${rel} (${hint}; luego ejecuta ai-hub sync)`);
+            }
+            else {
+                problems.push(`desactualizado: ${rel} (${sourceDescription(file.source)})`);
+            }
+        }
+    }
+    return problems;
+}
+export async function buildLock(root, rendered) {
+    const sources = {};
+    const files = {};
+    for (const [rel, file] of sortedEntries(rendered)) {
+        const entry = { sha256: sha256(file.content), source: file.source };
+        if (file.markerSource !== undefined) {
+            entry.markerSource = file.markerSource;
+        }
+        files[rel] = entry;
+        if (!(file.source in sources)) {
+            const resolvedPath = resolveSourcePath(root, file.source);
+            const sourceText = await readCopy(resolvedPath);
+            if (sourceText === null) {
+                throw new SyncSourceError(file.source, resolvedPath);
+            }
+            sources[file.source] = sha256(sourceText);
+        }
+    }
+    return { version: 2, generatorVersion: GENERATOR_VERSION, sources: sortRecord(sources), files };
+}
+export async function checkLockIntegrity(root, lock) {
+    const problems = [];
+    for (const [rel, entry] of Object.entries(lock.files)) {
+        if (!(entry.source in lock.sources)) {
+            problems.push(`files["${rel}"].source no está en sources: ${entry.source}`);
+        }
+    }
+    for (const [source, expected] of Object.entries(lock.sources)) {
+        const resolvedPath = resolveSourcePath(root, source);
+        const sourceText = await readCopy(resolvedPath);
+        if (sourceText === null) {
+            problems.push(`source no encontrada: ${source} (resuelta a ${resolvedPath})`);
+            continue;
+        }
+        if (sha256(sourceText) !== expected) {
+            problems.push(`hash de source no coincide: ${source}`);
+        }
+    }
+    return problems;
+}
+function categoryOf(source) {
+    if (source === '@engine/engine/preflight.md' || source === 'engine/preflight.md') {
+        return 'preflight';
+    }
+    if (source.startsWith('@engine/skills/') || source.includes('/skills/')) {
+        return 'skills';
+    }
+    if (source.includes('/agents/')) {
+        return 'agents';
+    }
+    if (source.startsWith('rules/') || source.includes('/rules/')) {
+        return 'rules';
+    }
+    if (source === 'manifest.yaml' || source === 'mcp-manifest.yaml') {
+        return 'mcp';
+    }
+    return 'other';
+}
+export async function checkLock(root) {
+    const config = await loadSyncConfig(root);
+    const rendered = await renderAll(root, config);
+    const breakdown = {
+        skills: 0,
+        agents: 0,
+        rules: 0,
+        preflight: 0,
+        mcp: 0,
+        other: 0,
+    };
+    for (const file of rendered.values()) {
+        breakdown[categoryOf(file.source)] += 1;
+    }
+    const expectedCount = rendered.size;
+    let expected;
+    try {
+        expected = await buildLock(root, rendered);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            ok: false,
+            expectedCount,
+            actualCount: 0,
+            expectedSourceCount: 0,
+            actualSourceCount: 0,
+            breakdown,
+            missing: [],
+            extra: [],
+            different: [],
+            invalidSources: [message],
+            error: message,
+        };
+    }
+    let actual;
+    try {
+        actual = await readLock(root);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            ok: false,
+            expectedCount,
+            actualCount: 0,
+            expectedSourceCount: Object.keys(expected.sources).length,
+            actualSourceCount: 0,
+            breakdown,
+            missing: Object.keys(expected.files).sort(),
+            extra: [],
+            different: [],
+            invalidSources: [message],
+            error: message,
+        };
+    }
+    const actualFiles = actual?.files ?? {};
+    const missing = Object.keys(expected.files)
+        .filter((rel) => !(rel in actualFiles))
+        .sort();
+    const extra = Object.keys(actualFiles)
+        .filter((rel) => !(rel in expected.files))
+        .sort();
+    const different = Object.keys(expected.files)
+        .filter((rel) => {
+        const current = actualFiles[rel];
+        const wanted = expected.files[rel];
+        return (current !== undefined &&
+            (current.sha256 !== wanted.sha256 ||
+                current.source !== wanted.source ||
+                current.markerSource !== wanted.markerSource));
+    })
+        .sort();
+    const invalidSources = actual === null ? ['sync.lock.json no existe'] : await checkLockIntegrity(root, actual);
+    return {
+        ok: missing.length === 0 &&
+            extra.length === 0 &&
+            different.length === 0 &&
+            invalidSources.length === 0,
+        expectedCount,
+        actualCount: Object.keys(actualFiles).length,
+        expectedSourceCount: Object.keys(expected.sources).length,
+        actualSourceCount: actual === null ? 0 : Object.keys(actual.sources).length,
+        breakdown,
+        missing,
+        extra,
+        different,
+        invalidSources,
+        error: actual === null ? 'sync.lock.json no existe' : null,
+    };
+}
+async function findSymlinks(root, config, rendered) {
+    const generatedDirs = [
+        ...config.skills.targets.map((target) => target.path),
+        ...Object.values(config.agents.targets).map((target) => target.path),
+        ...Object.values(config.rules.targets).map((target) => target.path),
+    ];
+    const found = new Set();
+    for (const dir of generatedDirs) {
+        await collectSymlinks(root, dir, found);
+    }
+    for (const rel of rendered.keys()) {
+        const stat = await fs.lstat(path.join(root, rel)).catch(() => null);
+        if (stat?.isSymbolicLink()) {
+            found.add(rel);
+        }
+    }
+    return [...found].sort();
+}
+async function collectSymlinks(root, relDir, found) {
+    const absDir = path.join(root, relDir);
+    const entries = await fs.readdir(absDir, { withFileTypes: true }).catch(() => null);
+    if (entries === null) {
+        return;
+    }
+    for (const entry of entries) {
+        const rel = `${relDir}/${entry.name}`;
+        if (entry.isSymbolicLink()) {
+            found.add(rel);
+        }
+        else if (entry.isDirectory()) {
+            await collectSymlinks(root, rel, found);
+        }
+    }
+}
+async function readCopy(abs) {
+    const text = await fs.readFile(abs, 'utf8').catch(() => null);
+    return text === null ? null : normalize(text);
+}
+function sortedEntries(rendered) {
+    return [...rendered.entries()].sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+}
+function sortRecord(record) {
+    return Object.fromEntries(Object.entries(record).sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0)));
+}

package/dist/sync/targets.d.ts

@@ -0,0 +1,24 @@
+export declare const TOOL_IDS: readonly ["claude", "opencode", "pi", "cursor", "copilot"];
+export type ToolId = (typeof TOOL_IDS)[number];
+export type SkillShape = 'dir' | 'file';
+export type RuleShape = 'md' | 'mdc' | 'instructions';
+export type HookKind = 'markdown' | 'cursor-mdc' | 'copilot-instructions';
+export interface ToolTargets {
+    skills: string;
+    agents: string | null;
+    rules: string;
+    hook: string;
+    skillShape: SkillShape;
+    ruleShape: RuleShape;
+    hookKind: HookKind;
+}
+/**
+ * Declarative destination table. Adding a tool means adding one row and one id
+ * in engine.yaml `targets`; renderers never branch on a tool name.
+ */
+export declare const TARGETS: Record<ToolId, ToolTargets>;
+export declare function isToolId(value: string): value is ToolId;
+export declare function assertToolIds(values: string[]): ToolId[];
+export declare function agentTargets(tools: ToolId[]): Record<string, string>;
+export declare function ruleTargets(tools: ToolId[]): Record<string, string>;
+export declare function skillTargets(tools: ToolId[]): string[];