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

package/dist/cli/run.js

@@ -0,0 +1,183 @@
+import { AiHubDirNotFoundError, resolveAiHubDir } from '../paths.js';
+import { checkLock, runSync, SyncSourceCheckoutError, SyncSourceError } from '../sync/sync.js';
+import { SyncConfigError } from '../sync/config.js';
+import { diagnose, printReport } from './doctor.js';
+import { parseArgs } from './args.js';
+import { cmdContext } from './context.js';
+import { cmdDrift } from './drift.js';
+import { cmdJudge, cmdVerify } from './legacy.js';
+import { cmdMemory } from './memory.js';
+import { cmdAdd, cmdBackups, cmdList, cmdPurge, cmdRestore, cmdUninstall, cmdUpgrade, } from './maintenance.js';
+import { cmdInit, cmdInstall, cmdRepair } from './onboarding.js';
+import { cmdTrunk } from './trunk.js';
+import { cmdWorktrees } from './worktrees.js';
+import { cliVersion } from './onboarding.js';
+import { sourceCheckout } from './source.js';
+import { processIO } from './types.js';
+function printLockCheck(result, ctx) {
+    const header = `destinos esperados ${result.expectedCount} / actuales ${result.actualCount} · sources ${result.expectedSourceCount}/${result.actualSourceCount}`;
+    const extraCategories = result.breakdown.other > 0 ? `, other ${result.breakdown.other}` : '';
+    const breakdown = `desglose: skills ${result.breakdown.skills}, agents ${result.breakdown.agents}, rules ${result.breakdown.rules}, preflight ${result.breakdown.preflight}, mcp ${result.breakdown.mcp}${extraCategories}`;
+    if (result.ok) {
+        ctx.io.out(`[OK]    lock: ${header}`);
+        ctx.io.out(breakdown);
+        return;
+    }
+    ctx.io.err(`[FAIL]  lock: ${header}`);
+    ctx.io.out(breakdown);
+    if (result.error !== null) {
+        ctx.io.err(result.error);
+    }
+    for (const [label, list] of [
+        ['faltan', result.missing],
+        ['sobran', result.extra],
+        ['difieren', result.different],
+        ['sources inválidas', result.invalidSources],
+    ]) {
+        ctx.io.out(`${label}: ${list.length}`);
+        for (const item of list) {
+            ctx.io.out(`  ${item}`);
+        }
+    }
+}
+async function cmdSync(args, ctx) {
+    try {
+        if (args.flags['check-lock']) {
+            const source = await sourceCheckout(ctx.root);
+            if (source.isSource) {
+                ctx.io.out('[OK]    lock: no aplica en el checkout del motor');
+                return 0;
+            }
+            const result = await checkLock(ctx.root);
+            printLockCheck(result, ctx);
+            return result.ok ? 0 : 1;
+        }
+        if (args.flags['dry-run']) {
+            const preview = await runSync(ctx.root, { check: true });
+            for (const problem of preview.problems) {
+                ctx.io.out(`[DRY-RUN] ${problem}`);
+            }
+            ctx.io.out(preview.problems.length === 0
+                ? '[DRY-RUN] sin cambios pendientes'
+                : `[DRY-RUN] ${preview.problems.length} cambios pendientes; no se escribió nada`);
+            return preview.problems.length === 0 ? 0 : 1;
+        }
+        const result = await runSync(ctx.root, {
+            check: Boolean(args.flags.check),
+            force: Boolean(args.flags.force),
+        });
+        if (args.flags.check) {
+            if (result.problems.length > 0) {
+                for (const problem of result.problems) {
+                    ctx.io.err(`[FAIL]  ${problem}`);
+                }
+                ctx.io.err(`Ejecuta ai-hub sync tras editar la fuente en ${ctx.root}`);
+                return 1;
+            }
+            ctx.io.out('[OK]    Destinos sincronizados');
+            return 0;
+        }
+        ctx.io.out(`[OK]    Escritos: ${result.written.length} · Eliminados: ${result.removed.length}`);
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof SyncConfigError ||
+            error instanceof SyncSourceError ||
+            error instanceof SyncSourceCheckoutError) {
+            ctx.io.err(error.message);
+            return 1;
+        }
+        ctx.io.err(`Error en sync: ${error.message}`);
+        return 1;
+    }
+}
+async function cmdDoctor(_args, ctx) {
+    const report = await diagnose(ctx);
+    printReport(report, ctx);
+    return report.ok ? 0 : 1;
+}
+async function cmdCheck(_args, ctx) {
+    return cmdDoctor(_args, ctx);
+}
+export const COMMANDS = {
+    init: { summary: 'Detecta el stack, elige preset y aplica un plan reproducible', handler: cmdInit },
+    install: { summary: 'Materializa el preset y sincroniza los destinos', handler: cmdInstall },
+    add: { summary: 'Añade una skill o un agente del preset', handler: cmdAdd },
+    sync: { summary: 'Proyecta las fuentes a los destinos; --check informa deriva', handler: cmdSync },
+    drift: { summary: 'Informa deriva de hash sin escribir', handler: cmdDrift },
+    list: { summary: 'Lista preset, targets, comandos, skills y agentes', handler: cmdList },
+    doctor: { summary: 'Diagnostica motor, preset, manifiesto, drift y hooks', handler: cmdDoctor },
+    check: { summary: 'Alias de doctor', handler: cmdCheck },
+    backups: { summary: 'Lista los snapshots disponibles', handler: cmdBackups },
+    restore: { summary: 'Restaura un snapshot', handler: cmdRestore },
+    uninstall: { summary: 'Elimina una skill o agente añadido', handler: cmdUninstall },
+    purge: { summary: 'Elimina el arnés tras crear un snapshot', handler: cmdPurge },
+    upgrade: { summary: 'Actualiza el paquete y re-sincroniza', handler: cmdUpgrade },
+    repair: { summary: 'Reaplica solo lo que falta o está roto', handler: cmdRepair },
+    worktrees: { summary: 'Lista o reapea worktrees con reglas conservadoras', handler: cmdWorktrees },
+    trunk: { summary: 'Muestra, cierra o abre la rama trunk', handler: cmdTrunk },
+    memory: { summary: 'Escribe, lista y reanuda el ledger de .planning', handler: cmdMemory },
+    context: { summary: 'Regenera .planning/context-next.md', handler: cmdContext },
+};
+export const COMMAND_NAMES = Object.keys(COMMANDS);
+const LEGACY_COMMANDS = {
+    verify: (_args, ctx) => cmdVerify(ctx),
+    judge: (_args, ctx) => cmdJudge(ctx),
+};
+export function printHelp(io) {
+    io.out('Uso: ai-hub <comando> [opciones]');
+    io.out('');
+    io.out(`Comandos (${COMMAND_NAMES.length}):`);
+    for (const name of COMMAND_NAMES) {
+        io.out(`  ${name.padEnd(10)} ${COMMANDS[name].summary}`);
+    }
+    io.out('');
+    io.out('Compatibilidad: verify, judge (fuera del catálogo).');
+}
+export async function createContext(cwd, io) {
+    try {
+        const location = resolveAiHubDir(cwd);
+        return { cwd, root: location.dir, source: location.source, io };
+    }
+    catch (error) {
+        if (error instanceof AiHubDirNotFoundError) {
+            return { cwd, root: cwd, source: null, io };
+        }
+        throw error;
+    }
+}
+export async function runCli(argv, options = {}) {
+    const io = options.io ?? processIO;
+    const cwd = options.cwd ?? process.cwd();
+    const [command, ...rest] = argv;
+    const ctx = await createContext(cwd, io);
+    if (!command) {
+        printHelp(io);
+        return 2;
+    }
+    if (command === 'help' || command === '--help' || command === '-h') {
+        printHelp(io);
+        return 0;
+    }
+    if (command === 'version' || command === '--version' || command === '-v') {
+        io.out(await cliVersion());
+        return 0;
+    }
+    const spec = COMMANDS[command];
+    if (spec) {
+        try {
+            return await spec.handler(parseArgs(rest), ctx);
+        }
+        catch (error) {
+            io.err(`Error inesperado en "${command}": ${error.message}`);
+            return 1;
+        }
+    }
+    const legacy = LEGACY_COMMANDS[command];
+    if (legacy) {
+        return legacy(parseArgs(rest), ctx);
+    }
+    io.err(`Comando desconocido: ${command}`);
+    printHelp(io);
+    return 2;
+}

package/dist/cli/source.d.ts

@@ -0,0 +1,5 @@
+export interface SourceCheckout {
+    isSource: boolean;
+    files: string[];
+}
+export declare function sourceCheckout(root: string): Promise<SourceCheckout>;

package/dist/cli/source.js

@@ -0,0 +1,22 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { PACKAGE_NAME } from '../package-info.js';
+export async function sourceCheckout(root) {
+    const raw = await fs.readFile(path.join(root, 'core', 'package.json'), 'utf8').catch(() => null);
+    if (raw === null) {
+        return { isSource: false, files: [] };
+    }
+    try {
+        const pkg = JSON.parse(raw);
+        const files = Array.isArray(pkg.files)
+            ? pkg.files.filter((file) => typeof file === 'string')
+            : [];
+        const hasRc = await fs
+            .access(path.join(root, '.ai-hubrc.json'))
+            .then(() => true, () => false);
+        return { isSource: pkg.name === PACKAGE_NAME && !hasRc, files };
+    }
+    catch {
+        return { isSource: false, files: [] };
+    }
+}

package/dist/cli/trunk.d.ts

@@ -0,0 +1,8 @@
+import type { CliContext, ParsedArgs } from './types.js';
+export declare const TRUNK_RELATIVE = ".planning/trunk.json";
+export interface TrunkState {
+    branch: string;
+    closed: boolean;
+    updatedAt: string;
+}
+export declare function cmdTrunk(args: ParsedArgs, ctx: CliContext): Promise<number>;

package/dist/cli/trunk.js

@@ -0,0 +1,54 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+export const TRUNK_RELATIVE = '.planning/trunk.json';
+function currentBranch(root) {
+    const result = spawnSync('git', ['rev-parse', '--abbrev-ref', 'HEAD'], {
+        cwd: root,
+        encoding: 'utf8',
+    });
+    const branch = (result.stdout ?? '').trim();
+    return branch === '' ? 'main' : branch;
+}
+async function readTrunk(root) {
+    const raw = await fs.readFile(path.join(root, TRUNK_RELATIVE), 'utf8').catch(() => null);
+    if (raw === null) {
+        return null;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+async function writeTrunk(root, state) {
+    const file = path.join(root, TRUNK_RELATIVE);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, `${JSON.stringify(state, null, 2)}\n`, 'utf8');
+}
+export async function cmdTrunk(args, ctx) {
+    const sub = args.positionals[0] ?? 'show';
+    if (sub === 'show') {
+        const state = await readTrunk(ctx.root);
+        const branch = state?.branch ?? currentBranch(ctx.root);
+        const closed = state?.closed ?? false;
+        ctx.io.out(`trunk: ${branch} · ${closed ? 'cerrada' : 'abierta'}`);
+        return 0;
+    }
+    if (sub === 'lock') {
+        const branch = args.positionals[1] ?? currentBranch(ctx.root);
+        await writeTrunk(ctx.root, { branch, closed: true, updatedAt: new Date().toISOString() });
+        ctx.io.out(`trunk: ${branch} cerrada (los guardias bloquearán commits directos)`);
+        return 0;
+    }
+    if (sub === 'unlock') {
+        const state = await readTrunk(ctx.root);
+        const branch = state?.branch ?? args.positionals[1] ?? currentBranch(ctx.root);
+        await writeTrunk(ctx.root, { branch, closed: false, updatedAt: new Date().toISOString() });
+        ctx.io.out(`trunk: ${branch} abierta`);
+        return 0;
+    }
+    ctx.io.err('uso: ai-hub trunk [show|lock|unlock]');
+    return 2;
+}

package/dist/cli/types.d.ts

@@ -0,0 +1,17 @@
+import type { AiHubSource } from '../paths.js';
+export interface CliIO {
+    out(message: string): void;
+    err(message: string): void;
+}
+export interface CliContext {
+    cwd: string;
+    root: string;
+    source: AiHubSource | null;
+    io: CliIO;
+}
+export interface ParsedArgs {
+    positionals: string[];
+    flags: Record<string, string | boolean>;
+}
+export type CommandHandler = (args: ParsedArgs, ctx: CliContext) => Promise<number>;
+export declare const processIO: CliIO;

package/dist/cli/types.js

@@ -0,0 +1,4 @@
+export const processIO = {
+    out: (message) => process.stdout.write(`${message}\n`),
+    err: (message) => process.stderr.write(`${message}\n`),
+};

package/dist/cli/worktrees.d.ts

@@ -0,0 +1,11 @@
+import { type WorktreeFacts } from '../harness/worktree/reaper.js';
+import type { CliContext, ParsedArgs } from './types.js';
+export interface RawWorktree {
+    path: string;
+    head: string;
+    branch: string | null;
+    bare: boolean;
+}
+export declare function parseWorktreeList(text: string): RawWorktree[];
+export declare function collectWorktreeFacts(root: string): Promise<WorktreeFacts[]>;
+export declare function cmdWorktrees(args: ParsedArgs, ctx: CliContext): Promise<number>;

package/dist/cli/worktrees.js

@@ -0,0 +1,141 @@
+import { spawnSync } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { planReap } from '../harness/worktree/reaper.js';
+const GENERATED_PREFIXES = [
+    '.claude/',
+    '.opencode/',
+    '.pi/',
+    '.cursor/',
+    'node_modules/',
+    'dist/',
+    '.backups/',
+];
+export function parseWorktreeList(text) {
+    const entries = [];
+    let current = {};
+    const flush = () => {
+        if (current.path) {
+            entries.push({
+                path: current.path,
+                head: current.head ?? '',
+                branch: current.branch ?? null,
+                bare: current.bare ?? false,
+            });
+        }
+        current = {};
+    };
+    for (const line of text.split(/\r?\n/)) {
+        if (line.trim() === '') {
+            flush();
+            continue;
+        }
+        const [key, ...rest] = line.split(' ');
+        const value = rest.join(' ');
+        if (key === 'worktree') {
+            current.path = value;
+        }
+        else if (key === 'HEAD') {
+            current.head = value;
+        }
+        else if (key === 'branch') {
+            current.branch = value.replace(/^refs\/heads\//, '');
+        }
+        else if (key === 'bare') {
+            current.bare = true;
+        }
+        else if (key === 'detached') {
+            current.branch = null;
+        }
+    }
+    flush();
+    return entries;
+}
+function runGit(args, cwd) {
+    const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
+    return { ok: result.status === 0, stdout: result.stdout ?? '' };
+}
+function normalize(value) {
+    return value.replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+}
+function isOwned(root, worktreePath) {
+    const base = normalize(root);
+    const candidate = normalize(worktreePath);
+    return (candidate.startsWith(`${base}/.worktrees/`) ||
+        candidate.startsWith(`${base}/.ai-hub/worktrees/`) ||
+        candidate.startsWith(`${base}/.git/worktrees/`));
+}
+async function hasMarker(worktreePath) {
+    return fs
+        .access(path.join(worktreePath, '.ai-hub-worktree'))
+        .then(() => true, () => false);
+}
+export async function collectWorktreeFacts(root) {
+    const listed = runGit(['worktree', 'list', '--porcelain'], root);
+    const raw = listed.ok ? parseWorktreeList(listed.stdout) : [];
+    const facts = [];
+    for (const worktree of raw) {
+        if (worktree.bare) {
+            continue;
+        }
+        const status = runGit(['status', '--porcelain'], worktree.path);
+        const lines = status.ok ? status.stdout.split(/\r?\n/).filter((line) => line.trim() !== '') : [];
+        const dirty = lines.some((line) => !line.startsWith('??'));
+        const untrackedNonRegenerable = lines.some((line) => {
+            if (!line.startsWith('??')) {
+                return false;
+            }
+            const rel = line.slice(3).replace(/^"|"$/g, '').replace(/\\/g, '/');
+            return !GENERATED_PREFIXES.some((prefix) => rel.startsWith(prefix));
+        });
+        const ahead = runGit(['rev-list', '--count', 'HEAD', '--not', 'main', 'master', 'trunk'], worktree.path);
+        const unmergedCommits = ahead.ok ? Number.parseInt(ahead.stdout.trim(), 10) || 0 : 0;
+        const integrated = ahead.ok ? unmergedCommits === 0 : false;
+        facts.push({
+            path: worktree.path,
+            branch: worktree.branch ?? 'detached',
+            owned: isOwned(root, worktree.path) || (await hasMarker(worktree.path)),
+            dirty,
+            untrackedNonRegenerable,
+            unmergedCommits,
+            integrated,
+        });
+    }
+    return facts;
+}
+function printReport(report, ctx) {
+    for (const plan of [...report.keep, ...report.ask, ...report.remove]) {
+        ctx.io.out(`${plan.decision.padEnd(6)} ${plan.path} [${plan.branch}] ${plan.rule}: ${plan.reason}`);
+    }
+    ctx.io.out(`resumen: ${report.remove.length} eliminar · ${report.ask.length} pedir confirmación · ${report.keep.length} conservar`);
+}
+export async function cmdWorktrees(args, ctx) {
+    const sub = args.positionals[0] ?? 'list';
+    if (sub !== 'list' && sub !== 'reap') {
+        ctx.io.err('uso: ai-hub worktrees [list|reap] [--confirm]');
+        return 2;
+    }
+    const facts = await collectWorktreeFacts(ctx.root);
+    const auto = Boolean(args.flags.auto);
+    const report = planReap(facts, { confirm: Boolean(args.flags.confirm) || auto });
+    if (sub === 'list') {
+        printReport(report, ctx);
+        return 0;
+    }
+    let removed = 0;
+    for (const plan of report.remove) {
+        const result = spawnSync('git', ['worktree', 'remove', plan.path], {
+            cwd: ctx.root,
+            encoding: 'utf8',
+        });
+        if (result.status === 0) {
+            removed += 1;
+            ctx.io.out(`remove ${plan.path}`);
+        }
+        else {
+            ctx.io.err(`no se pudo eliminar ${plan.path}: ${result.stderr ?? 'error de git'}`);
+        }
+    }
+    ctx.io.out(`worktrees reap: ${removed} eliminados, ${report.ask.length} pendientes de --confirm`);
+    return removed === report.remove.length ? 0 : 1;
+}

package/dist/engine/engine.d.ts

@@ -0,0 +1,48 @@
+export declare const ENGINE_SKILLS_DIR: string;
+export declare const ENGINE_COUNTS: {
+    readonly roles: 8;
+    readonly commands: 17;
+    readonly labels: 7;
+};
+export declare const ENGINE_LANES: {
+    readonly assessment: 5;
+    readonly feature: 9;
+    readonly bug: 3;
+};
+export type Lane = keyof typeof ENGINE_LANES;
+export interface EngineRole {
+    id: string;
+    canonical: string;
+    derived: boolean;
+    description?: string;
+    can_modify: string[];
+    cannot_modify: string[];
+    commands: string[];
+    gate: string;
+}
+export interface EngineCommand {
+    id: string;
+    name: string;
+    lane: Lane;
+    artifacts: string[];
+    exit: string[];
+    role: string;
+    co_roles?: string[];
+    skill: string;
+}
+export interface EngineManifest {
+    version: 2;
+    roles: EngineRole[];
+    commands: EngineCommand[];
+    labels: string[];
+    targets: string[];
+}
+export declare class EngineError extends Error {
+    readonly errors: string[];
+    constructor(errors: string[]);
+}
+export declare function loadEngine(): Promise<EngineManifest>;
+export declare function findDuplicateIds(ids: string[]): string[];
+export declare function crossValidate(engine: EngineManifest): string[];
+export declare function commandById(engine: EngineManifest, id: string): EngineCommand | null;
+export declare function commandsByLane(engine: EngineManifest, lane: Lane): EngineCommand[];

package/dist/engine/engine.js

@@ -0,0 +1,114 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Ajv } from 'ajv';
+import { parse } from 'yaml';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const ENGINE_PATH = path.join(__dirname, '..', '..', 'engine', 'engine.yaml');
+const SCHEMA_PATH = path.join(__dirname, '..', '..', 'schema', 'engine.schema.json');
+export const ENGINE_SKILLS_DIR = path.join(__dirname, '..', '..', 'skills', 'shared');
+export const ENGINE_COUNTS = { roles: 8, commands: 17, labels: 7 };
+export const ENGINE_LANES = { assessment: 5, feature: 9, bug: 3 };
+export class EngineError extends Error {
+    errors;
+    constructor(errors) {
+        super(`motor inválido:\n${errors.map((error) => `  - ${error}`).join('\n')}`);
+        this.name = 'EngineError';
+        this.errors = errors;
+    }
+}
+let cache = null;
+export async function loadEngine() {
+    if (cache) {
+        return cache;
+    }
+    const raw = await fs.readFile(ENGINE_PATH, 'utf8').catch(() => {
+        throw new EngineError([`no se encuentra ${ENGINE_PATH}`]);
+    });
+    let data;
+    try {
+        data = parse(raw);
+    }
+    catch (error) {
+        throw new EngineError([`engine.yaml no es YAML válido: ${error.message}`]);
+    }
+    const schema = JSON.parse(await fs.readFile(SCHEMA_PATH, 'utf8'));
+    const ajv = new Ajv({ allErrors: true });
+    const validate = ajv.compile(schema);
+    if (!validate(data)) {
+        throw new EngineError((validate.errors ?? []).map((error) => `${error.instancePath || '(root)'} ${error.message ?? 'inválido'}`));
+    }
+    const engine = data;
+    const errors = crossValidate(engine);
+    if (errors.length > 0) {
+        throw new EngineError(errors);
+    }
+    cache = engine;
+    return engine;
+}
+export function findDuplicateIds(ids) {
+    const seen = new Set();
+    const duplicates = new Set();
+    for (const id of ids) {
+        if (seen.has(id)) {
+            duplicates.add(id);
+        }
+        seen.add(id);
+    }
+    return [...duplicates].sort();
+}
+export function crossValidate(engine) {
+    const errors = [];
+    if (engine.roles.length !== ENGINE_COUNTS.roles) {
+        errors.push(`deben existir ${ENGINE_COUNTS.roles} roles`);
+    }
+    if (engine.commands.length !== ENGINE_COUNTS.commands) {
+        errors.push(`deben existir ${ENGINE_COUNTS.commands} comandos`);
+    }
+    if (engine.labels.length !== ENGINE_COUNTS.labels) {
+        errors.push(`deben existir ${ENGINE_COUNTS.labels} etiquetas`);
+    }
+    for (const id of findDuplicateIds(engine.roles.map((role) => role.id))) {
+        errors.push(`rol duplicado: ${id}`);
+    }
+    for (const id of findDuplicateIds(engine.commands.map((command) => command.id))) {
+        errors.push(`comando duplicado: ${id}`);
+    }
+    for (const label of findDuplicateIds(engine.labels)) {
+        errors.push(`etiqueta duplicada: ${label}`);
+    }
+    const roleIds = new Set(engine.roles.map((role) => role.id));
+    for (const command of engine.commands) {
+        if (!roleIds.has(command.role)) {
+            errors.push(`commands "${command.id}".role "${command.role}" no existe`);
+        }
+        for (const coRole of command.co_roles ?? []) {
+            if (!roleIds.has(coRole)) {
+                errors.push(`commands "${command.id}".co_roles "${coRole}" no existe`);
+            }
+        }
+    }
+    for (const role of engine.roles) {
+        const expected = engine.commands
+            .filter((command) => command.role === role.id || (command.co_roles ?? []).includes(role.id))
+            .map((command) => command.id)
+            .sort();
+        const declared = [...role.commands].sort();
+        if (JSON.stringify(expected) !== JSON.stringify(declared)) {
+            errors.push(`roles "${role.id}".commands no coincide con los comandos asignados`);
+        }
+    }
+    for (const [lane, count] of Object.entries(ENGINE_LANES)) {
+        const actual = engine.commands.filter((command) => command.lane === lane).length;
+        if (actual !== count) {
+            errors.push(`lane "${lane}" debe tener ${count} comandos (tiene ${actual})`);
+        }
+    }
+    return errors;
+}
+export function commandById(engine, id) {
+    return engine.commands.find((command) => command.id === id) ?? null;
+}
+export function commandsByLane(engine, lane) {
+    return engine.commands.filter((command) => command.lane === lane);
+}

package/dist/engine/gates.d.ts

@@ -0,0 +1,2 @@
+export declare function scanLegacyArtifacts(root: string): Promise<string[]>;
+export declare function scanCoupling(root: string, terms: string[]): Promise<string[]>;