@dsalazardev/ai-hub-cli 0.2.0 → 0.3.1

package/dist/speckit/runner.d.ts

@@ -0,0 +1,19 @@
+export interface RunResult {
+    /** Código de salida; `null` si el proceso no llegó a ejecutarse o fue interrumpido. */
+    status: number | null;
+    stdout: string;
+    stderr: string;
+    /** Error de arranque (por ejemplo `ENOENT` cuando el ejecutable no existe). */
+    error?: string;
+}
+export interface RunOptions {
+    cwd: string;
+    timeoutMs?: number;
+}
+/**
+ * Ejecuta un proceso externo. Los argumentos viajan como array, nunca a través de un shell,
+ * para que las rutas con espacios no se interpreten. La entrada estándar se cierra.
+ */
+export type ProcessRunner = (command: string, args: string[], options: RunOptions) => Promise<RunResult>;
+export declare const defaultRunner: ProcessRunner;
+export declare function succeeded(result: RunResult): boolean;

package/dist/speckit/runner.js

@@ -0,0 +1,22 @@
+import { spawnSync } from 'node:child_process';
+const DEFAULT_TIMEOUT_MS = 300_000;
+export const defaultRunner = async (command, args, options) => {
+    const result = spawnSync(command, args, {
+        cwd: options.cwd,
+        shell: false,
+        encoding: 'utf8',
+        input: '',
+        windowsHide: true,
+        timeout: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+        env: { ...process.env, PYTHONIOENCODING: 'utf-8', NO_COLOR: '1' },
+    });
+    return {
+        status: result.status,
+        stdout: result.stdout ?? '',
+        stderr: result.stderr ?? '',
+        ...(result.error ? { error: result.error.message } : {}),
+    };
+};
+export function succeeded(result) {
+    return result.error === undefined && result.status === 0;
+}

package/dist/speckit/seal.d.ts

@@ -0,0 +1,12 @@
+/** Archivos que sella `ai::spec-ready`, dentro de `specs/<feature>/`. */
+export declare const SEALED_FILES: readonly ["plan.md", "spec.md", "tasks.md"];
+export declare class IncompleteFeatureError extends Error {
+    readonly missing: string[];
+    constructor(missing: string[]);
+}
+/**
+ * Sello SHA-256 de una feature de Spec Kit (implementación de referencia del contrato de
+ * `hermes-control`, AGENTS.md §5): rutas relativas a la raíz, ordenadas, separador `/`;
+ * por archivo `ruta + "\n" + bytes` normalizados a LF y sin BOM; SHA-256 sobre la secuencia.
+ */
+export declare function featureSeal(root: string, featureDir: string): Promise<string>;

package/dist/speckit/seal.js

@@ -0,0 +1,47 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+/** Archivos que sella `ai::spec-ready`, dentro de `specs/<feature>/`. */
+export const SEALED_FILES = ['plan.md', 'spec.md', 'tasks.md'];
+export class IncompleteFeatureError extends Error {
+    missing;
+    constructor(missing) {
+        super(`la feature no se puede sellar; faltan: ${missing.join(', ')}`);
+        this.missing = missing;
+        this.name = 'IncompleteFeatureError';
+    }
+}
+/** Normaliza el contenido como exige el contrato: sin BOM y con LF. */
+function canonicalContent(bytes) {
+    const text = bytes.toString('utf8').replace(/^/, '').replace(/\r\n?/g, '\n');
+    return Buffer.from(text, 'utf8');
+}
+/**
+ * Sello SHA-256 de una feature de Spec Kit (implementación de referencia del contrato de
+ * `hermes-control`, AGENTS.md §5): rutas relativas a la raíz, ordenadas, separador `/`;
+ * por archivo `ruta + "\n" + bytes` normalizados a LF y sin BOM; SHA-256 sobre la secuencia.
+ */
+export async function featureSeal(root, featureDir) {
+    const dir = featureDir.replace(/\\/g, '/').replace(/\/+$/, '');
+    const rels = SEALED_FILES.map((name) => `${dir}/${name}`).sort();
+    const contents = [];
+    const missing = [];
+    for (const rel of rels) {
+        const bytes = await fs.readFile(path.join(root, ...rel.split('/'))).catch(() => null);
+        if (bytes === null) {
+            missing.push(rel);
+        }
+        else {
+            contents.push([rel, canonicalContent(bytes)]);
+        }
+    }
+    if (missing.length > 0) {
+        throw new IncompleteFeatureError(missing);
+    }
+    const hash = createHash('sha256');
+    for (const [rel, bytes] of contents) {
+        hash.update(`${rel}\n`, 'utf8');
+        hash.update(bytes);
+    }
+    return hash.digest('hex');
+}

package/dist/speckit/settings.d.ts

@@ -0,0 +1,36 @@
+import type { EngineManifest, SpeckitScript } from '../engine/engine.js';
+import { type ToolId } from '../sync/targets.js';
+/** Bloque `speckit` de manifest.yaml: solo restringe lo que fija el paquete. */
+export interface ProjectSpeckit {
+    managed?: boolean;
+    version?: string;
+    script?: SpeckitScript;
+    defaultTarget?: string;
+}
+/** Campos que pertenecen al motor y que un proyecto no puede redefinir. */
+export declare const ENGINE_OWNED_SPECKIT_FIELDS: readonly ["extensions", "excludeNewer", "integrations", "package", "pin", "supported"];
+export interface SpeckitSettings {
+    managed: boolean;
+    package: string;
+    version: string;
+    excludeNewer: string;
+    script: SpeckitScript;
+    /** Destinos declarados que reciben Spec Kit; el de por defecto va primero. */
+    targets: ToolId[];
+    defaultTarget: ToolId | null;
+    defaultIntegration: string | null;
+    /** Integraciones de Spec Kit en el mismo orden que `targets`. */
+    integrations: string[];
+    extensions: Record<string, string>;
+}
+export declare function speckitEnabledTargets(targets: readonly string[]): ToolId[];
+export declare function integrationOf(target: ToolId): string;
+export declare function effectiveSpeckit(manifest: {
+    targets: readonly string[];
+    speckit?: ProjectSpeckit;
+}, engine: EngineManifest): SpeckitSettings;
+/**
+ * Valida el bloque `speckit` del proyecto contra el paquete. Devuelve errores con el nombre del campo.
+ * Se ejecuta antes del schema para poder explicar los campos que pertenecen al motor.
+ */
+export declare function validateProjectSpeckit(block: unknown, targets: readonly string[], engine: EngineManifest): string[];

package/dist/speckit/settings.js

@@ -0,0 +1,75 @@
+import { TARGETS, isToolId } from '../sync/targets.js';
+import { satisfiesRange } from './version.js';
+/** Campos que pertenecen al motor y que un proyecto no puede redefinir. */
+export const ENGINE_OWNED_SPECKIT_FIELDS = ['extensions', 'excludeNewer', 'integrations', 'package', 'pin', 'supported'];
+export function speckitEnabledTargets(targets) {
+    return targets.filter((target) => isToolId(target) && TARGETS[target].speckit !== null);
+}
+export function integrationOf(target) {
+    const speckit = TARGETS[target].speckit;
+    if (speckit === null) {
+        throw new Error(`el destino ${target} no recibe Spec Kit`);
+    }
+    return speckit.integration;
+}
+export function effectiveSpeckit(manifest, engine) {
+    const block = manifest.speckit ?? {};
+    const enabled = speckitEnabledTargets(manifest.targets);
+    const declaredDefault = block.defaultTarget !== undefined && enabled.includes(block.defaultTarget)
+        ? block.defaultTarget
+        : null;
+    const defaultTarget = declaredDefault ?? enabled[0] ?? null;
+    const targets = defaultTarget === null ? [] : [defaultTarget, ...enabled.filter((target) => target !== defaultTarget)];
+    return {
+        managed: block.managed !== false,
+        package: engine.speckit.package,
+        version: block.version ?? engine.speckit.pin,
+        excludeNewer: engine.speckit.excludeNewer,
+        script: block.script ?? engine.speckit.script,
+        targets,
+        defaultTarget,
+        defaultIntegration: defaultTarget === null ? null : integrationOf(defaultTarget),
+        integrations: targets.map(integrationOf),
+        extensions: { ...engine.speckit.extensions },
+    };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/**
+ * Valida el bloque `speckit` del proyecto contra el paquete. Devuelve errores con el nombre del campo.
+ * Se ejecuta antes del schema para poder explicar los campos que pertenecen al motor.
+ */
+export function validateProjectSpeckit(block, targets, engine) {
+    if (block === undefined) {
+        return speckitEnabledTargets(targets).length === 0
+            ? ['speckit requiere al menos un destino con Spec Kit (claude, opencode, pi, cursor) o speckit.managed: false']
+            : [];
+    }
+    if (!isRecord(block)) {
+        return ['speckit debe ser un objeto'];
+    }
+    const errors = [];
+    for (const field of ENGINE_OWNED_SPECKIT_FIELDS) {
+        if (field in block) {
+            errors.push(`speckit.${field} pertenece al motor; el proyecto no puede redefinirlo`);
+        }
+    }
+    if (block.version !== undefined) {
+        if (typeof block.version !== 'string' || !satisfiesRange(block.version, engine.speckit.supported)) {
+            errors.push(`speckit.version ${String(block.version)} está fuera del rango soportado por el paquete "${engine.speckit.supported}"`);
+        }
+    }
+    const enabled = speckitEnabledTargets(targets);
+    if (block.defaultTarget !== undefined) {
+        const value = String(block.defaultTarget);
+        if (!enabled.includes(value)) {
+            const all = Object.keys(TARGETS).filter((tool) => TARGETS[tool].speckit !== null);
+            errors.push(`speckit.defaultTarget "${value}" debe ser un destino declarado con Spec Kit: ${all.join(', ')}`);
+        }
+    }
+    if (block.managed !== false && enabled.length === 0) {
+        errors.push('speckit requiere al menos un destino con Spec Kit (claude, opencode, pi, cursor) o speckit.managed: false');
+    }
+    return errors;
+}

package/dist/speckit/state.d.ts

@@ -0,0 +1,59 @@
+import { type SpeckitTarget } from '../sync/targets.js';
+import type { SpeckitSettings } from './settings.js';
+/**
+ * Lectura de `.specify/` sin ejecutar Python. Los timestamps `installed_at` de los manifiestos
+ * de integración y del registro de extensiones nunca se comparan ni se hashean.
+ */
+export declare const SPECIFY_DIR = ".specify";
+export interface IntegrationManifest {
+    integration: string;
+    files: Record<string, string>;
+}
+export interface SpeckitState {
+    present: boolean;
+    initOptions: {
+        speckit_version?: string;
+        script?: string;
+    } | null;
+    integration: {
+        installed_integrations: string[];
+        default_integration?: string;
+    } | null;
+    installedExtensions: string[];
+    registry: Record<string, {
+        version?: string;
+        registered_commands?: Record<string, string[]>;
+    }>;
+    manifests: IntegrationManifest[];
+}
+export declare function readSpeckitState(root: string): Promise<SpeckitState>;
+/** Ruta de un comando de Spec Kit en un destino: `<dir>/speckit-bug-assess/SKILL.md` o `<dir>/speckit.bug.assess.md`. */
+export declare function commandPath(target: SpeckitTarget, canonical: string): string;
+/** Ids canónicos de los comandos de una extensión, leídos de `.specify/extensions/<id>/commands/`. */
+export declare function extensionCommands(root: string, extension: string): Promise<string[]>;
+/** `true` si la ruta cae en el espacio de nombres reservado de algún destino con Spec Kit declarado. */
+export declare function inReservedNamespace(rel: string, tools: readonly string[]): boolean;
+/**
+ * Rutas que pertenecen a Spec Kit (agent-guardrails "Every generated file has one owner"):
+ * las de sus manifiestos de integración y los comandos de sus extensiones en cada destino con Spec Kit.
+ * El espacio de nombres reservado se evalúa aparte con `inReservedNamespace`.
+ */
+export declare function speckitOwnedPaths(root: string, tools: readonly string[]): Promise<Set<string>>;
+/** Decide si una ruta es de Spec Kit, sea por manifiesto, por extensión o por espacio de nombres. */
+export declare function ownedBySpeckit(rel: string, owned: Set<string>, tools: readonly string[], present: boolean): boolean;
+/** speckit:integrations — exactamente las integraciones de los destinos declarados, sin Copilot. */
+export declare function checkIntegrations(settings: SpeckitSettings, state: SpeckitState): string[];
+/** speckit:extensions — extensiones fijadas, con su versión y sus comandos en cada destino con Spec Kit. */
+export declare function checkExtensions(root: string, settings: SpeckitSettings, state: SpeckitState): Promise<string[]>;
+export interface IntegrityReport {
+    missing: string[];
+    modified: string[];
+    checked: number;
+}
+/**
+ * speckit:integrity — cada ruta de los manifiestos de integración existe y conserva su hash.
+ * Un archivo con finales de línea CRLF (autocrlf de git) se compara también normalizado a LF.
+ */
+export declare function checkIntegrity(root: string, state: SpeckitState): Promise<IntegrityReport>;
+/** speckit:constitution — `true` si la constitución sigue siendo la plantilla. */
+export declare function constitutionIsTemplate(root: string): Promise<boolean | null>;

package/dist/speckit/state.js

@@ -0,0 +1,279 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { parse } from 'yaml';
+import { TARGETS, isToolId } from '../sync/targets.js';
+/**
+ * Lectura de `.specify/` sin ejecutar Python. Los timestamps `installed_at` de los manifiestos
+ * de integración y del registro de extensiones nunca se comparan ni se hashean.
+ */
+export const SPECIFY_DIR = '.specify';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+async function readJson(file) {
+    const text = await fs.readFile(file, 'utf8').catch(() => null);
+    if (text === null) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+async function exists(file) {
+    return fs.access(file).then(() => true, () => false);
+}
+export async function readSpeckitState(root) {
+    const dir = path.join(root, SPECIFY_DIR);
+    const present = await exists(dir);
+    const initRaw = await readJson(path.join(dir, 'init-options.json'));
+    const integrationRaw = await readJson(path.join(dir, 'integration.json'));
+    const registryRaw = await readJson(path.join(dir, 'extensions', '.registry'));
+    const extensionsText = await fs.readFile(path.join(dir, 'extensions.yml'), 'utf8').catch(() => null);
+    let installedExtensions = [];
+    if (extensionsText !== null) {
+        try {
+            const parsed = parse(extensionsText);
+            if (isRecord(parsed) && Array.isArray(parsed.installed)) {
+                installedExtensions = parsed.installed.filter((item) => typeof item === 'string');
+            }
+        }
+        catch {
+            installedExtensions = [];
+        }
+    }
+    const manifests = [];
+    const integrationsDir = path.join(dir, 'integrations');
+    for (const name of (await fs.readdir(integrationsDir).catch(() => [])).sort()) {
+        if (!name.endsWith('.manifest.json')) {
+            continue;
+        }
+        const raw = await readJson(path.join(integrationsDir, name));
+        if (isRecord(raw) && isRecord(raw.files)) {
+            manifests.push({
+                integration: typeof raw.integration === 'string' ? raw.integration : name.replace(/\.manifest\.json$/, ''),
+                files: Object.fromEntries(Object.entries(raw.files).filter((entry) => typeof entry[1] === 'string')),
+            });
+        }
+    }
+    const registry = {};
+    if (isRecord(registryRaw) && isRecord(registryRaw.extensions)) {
+        for (const [id, entry] of Object.entries(registryRaw.extensions)) {
+            if (!isRecord(entry)) {
+                continue;
+            }
+            const commands = {};
+            if (isRecord(entry.registered_commands)) {
+                for (const [integration, list] of Object.entries(entry.registered_commands)) {
+                    if (Array.isArray(list)) {
+                        commands[integration] = list.filter((item) => typeof item === 'string');
+                    }
+                }
+            }
+            registry[id] = {
+                ...(typeof entry.version === 'string' ? { version: entry.version } : {}),
+                registered_commands: commands,
+            };
+        }
+    }
+    return {
+        present,
+        initOptions: isRecord(initRaw)
+            ? {
+                ...(typeof initRaw.speckit_version === 'string' ? { speckit_version: initRaw.speckit_version } : {}),
+                ...(typeof initRaw.script === 'string' ? { script: initRaw.script } : {}),
+            }
+            : null,
+        integration: isRecord(integrationRaw) && Array.isArray(integrationRaw.installed_integrations)
+            ? {
+                installed_integrations: integrationRaw.installed_integrations.filter((item) => typeof item === 'string'),
+                ...(typeof integrationRaw.default_integration === 'string'
+                    ? { default_integration: integrationRaw.default_integration }
+                    : {}),
+            }
+            : null,
+        installedExtensions,
+        registry,
+        manifests,
+    };
+}
+/** Ruta de un comando de Spec Kit en un destino: `<dir>/speckit-bug-assess/SKILL.md` o `<dir>/speckit.bug.assess.md`. */
+export function commandPath(target, canonical) {
+    return target.layout === 'skill-dir'
+        ? `${target.commandsDir}/${canonical.replace(/\./g, '-')}/SKILL.md`
+        : `${target.commandsDir}/${canonical}.md`;
+}
+/** Ids canónicos de los comandos de una extensión, leídos de `.specify/extensions/<id>/commands/`. */
+export async function extensionCommands(root, extension) {
+    const dir = path.join(root, SPECIFY_DIR, 'extensions', extension, 'commands');
+    return (await fs.readdir(dir).catch(() => []))
+        .filter((name) => name.endsWith('.md'))
+        .map((name) => name.slice(0, -'.md'.length))
+        .sort();
+}
+/** Destinos declarados que reciben Spec Kit, con su fila del registro. */
+function enabledTargets(tools) {
+    const rows = [];
+    for (const tool of tools) {
+        if (!isToolId(tool)) {
+            continue;
+        }
+        const speckit = TARGETS[tool].speckit;
+        if (speckit !== null) {
+            rows.push([tool, speckit]);
+        }
+    }
+    return rows;
+}
+/** `true` si la ruta cae en el espacio de nombres reservado de algún destino con Spec Kit declarado. */
+export function inReservedNamespace(rel, tools) {
+    return enabledTargets(tools).some(([, speckit]) => {
+        const prefix = `${speckit.commandsDir}/`;
+        if (!rel.startsWith(prefix)) {
+            return false;
+        }
+        const name = rel.slice(prefix.length);
+        return name.startsWith('speckit-') || name.startsWith('speckit.');
+    });
+}
+/**
+ * Rutas que pertenecen a Spec Kit (agent-guardrails "Every generated file has one owner"):
+ * las de sus manifiestos de integración y los comandos de sus extensiones en cada destino con Spec Kit.
+ * El espacio de nombres reservado se evalúa aparte con `inReservedNamespace`.
+ */
+export async function speckitOwnedPaths(root, tools) {
+    const owned = new Set();
+    const state = await readSpeckitState(root);
+    if (!state.present) {
+        return owned;
+    }
+    for (const manifest of state.manifests) {
+        for (const rel of Object.keys(manifest.files)) {
+            owned.add(rel);
+        }
+    }
+    const extensions = new Set([...state.installedExtensions, ...Object.keys(state.registry)]);
+    for (const extension of extensions) {
+        const commands = await extensionCommands(root, extension);
+        for (const [, speckit] of enabledTargets(tools)) {
+            for (const canonical of commands) {
+                owned.add(commandPath(speckit, canonical));
+            }
+        }
+    }
+    return owned;
+}
+/** Decide si una ruta es de Spec Kit, sea por manifiesto, por extensión o por espacio de nombres. */
+export function ownedBySpeckit(rel, owned, tools, present) {
+    return owned.has(rel) || (present && inReservedNamespace(rel, tools));
+}
+/** speckit:integrations — exactamente las integraciones de los destinos declarados, sin Copilot. */
+export function checkIntegrations(settings, state) {
+    if (state.integration === null) {
+        return ['falta .specify/integration.json'];
+    }
+    const problems = [];
+    const installed = state.integration.installed_integrations;
+    for (const [index, integration] of settings.integrations.entries()) {
+        if (!installed.includes(integration)) {
+            problems.push(`${settings.targets[index]}: falta la integración ${integration}`);
+        }
+    }
+    for (const integration of installed) {
+        if (!settings.integrations.includes(integration)) {
+            problems.push(integration === 'copilot'
+                ? 'copilot: integración instalada aunque Copilot no recibe Spec Kit; ejecuta specify integration uninstall copilot'
+                : `integración no declarada: ${integration}`);
+        }
+    }
+    if (settings.defaultIntegration !== null && state.integration.default_integration !== settings.defaultIntegration) {
+        problems.push(`integración por defecto ${state.integration.default_integration ?? '(ninguna)'}; se esperaba ${settings.defaultIntegration}`);
+    }
+    return problems;
+}
+/** speckit:extensions — extensiones fijadas, con su versión y sus comandos en cada destino con Spec Kit. */
+export async function checkExtensions(root, settings, state) {
+    const problems = [];
+    for (const [extension, version] of Object.entries(settings.extensions).sort()) {
+        if (!state.installedExtensions.includes(extension)) {
+            problems.push(`${extension}: extensión no instalada`);
+            continue;
+        }
+        const registered = state.registry[extension]?.version;
+        if (registered !== version) {
+            problems.push(`${extension}: versión ${registered ?? '(desconocida)'}; se esperaba ${version}`);
+        }
+        const commands = await extensionCommands(root, extension);
+        if (commands.length === 0) {
+            problems.push(`${extension}: no hay comandos en .specify/extensions/${extension}/commands`);
+            continue;
+        }
+        for (const tool of settings.targets) {
+            const speckit = TARGETS[tool].speckit;
+            if (speckit === null) {
+                continue;
+            }
+            // Un mensaje por extensión y destino, para que el informe nombre todos los destinos afectados.
+            const registeredFor = state.registry[extension]?.registered_commands?.[speckit.integration] ?? [];
+            const unregistered = [];
+            const absent = [];
+            for (const canonical of commands) {
+                if (!registeredFor.includes(canonical)) {
+                    unregistered.push(canonical);
+                }
+                else if (!(await exists(path.join(root, ...commandPath(speckit, canonical).split('/'))))) {
+                    absent.push(canonical);
+                }
+            }
+            if (unregistered.length > 0) {
+                problems.push(`${extension}: ${tool} (${speckit.integration}) no tiene registrados ${unregistered.join(', ')}`);
+            }
+            if (absent.length > 0) {
+                problems.push(`${extension}: ${tool} no tiene en ${speckit.commandsDir} ${absent.join(', ')}`);
+            }
+        }
+    }
+    return problems;
+}
+function sha(bytes) {
+    return createHash('sha256').update(bytes).digest('hex');
+}
+/**
+ * speckit:integrity — cada ruta de los manifiestos de integración existe y conserva su hash.
+ * Un archivo con finales de línea CRLF (autocrlf de git) se compara también normalizado a LF.
+ */
+export async function checkIntegrity(root, state) {
+    const missing = [];
+    const modified = [];
+    let checked = 0;
+    for (const manifest of state.manifests) {
+        for (const [rel, expected] of Object.entries(manifest.files).sort()) {
+            checked += 1;
+            const bytes = await fs.readFile(path.join(root, ...rel.split('/'))).catch(() => null);
+            if (bytes === null) {
+                missing.push(rel);
+                continue;
+            }
+            if (sha(bytes) !== expected && sha(bytes.toString('utf8').replace(/\r\n/g, '\n')) !== expected) {
+                modified.push(rel);
+            }
+        }
+    }
+    return { missing: [...new Set(missing)].sort(), modified: [...new Set(modified)].sort(), checked };
+}
+/** speckit:constitution — `true` si la constitución sigue siendo la plantilla. */
+export async function constitutionIsTemplate(root) {
+    const memory = path.join(root, SPECIFY_DIR, 'memory');
+    const marker = await readJson(path.join(memory, '.constitution-template.json'));
+    const constitution = await fs.readFile(path.join(memory, 'constitution.md')).catch(() => null);
+    if (constitution === null) {
+        return null;
+    }
+    if (!isRecord(marker) || typeof marker.sha256 !== 'string') {
+        return false;
+    }
+    return sha(constitution) === marker.sha256 || sha(constitution.toString('utf8').replace(/\r\n/g, '\n')) === marker.sha256;
+}

package/dist/speckit/version.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Comparación mínima de versiones `x.y.z` para validar el pin de Spec Kit.
+ * Una versión con sufijo (por ejemplo `1.2.1.dev0`) no se considera estable y no satisface ningún rango.
+ */
+export declare function parseVersion(version: string): [number, number, number] | null;
+export declare function compareVersions(left: [number, number, number], right: [number, number, number]): number;
+/** Evalúa un rango de comparadores separados por espacios: `>=1.2.3 <1.3.0`. */
+export declare function satisfiesRange(version: string, range: string): boolean;

package/dist/speckit/version.js

@@ -0,0 +1,53 @@
+/**
+ * Comparación mínima de versiones `x.y.z` para validar el pin de Spec Kit.
+ * Una versión con sufijo (por ejemplo `1.2.1.dev0`) no se considera estable y no satisface ningún rango.
+ */
+export function parseVersion(version) {
+    const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version.trim());
+    if (match === null) {
+        return null;
+    }
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+export function compareVersions(left, right) {
+    for (let index = 0; index < 3; index += 1) {
+        if (left[index] !== right[index]) {
+            return left[index] < right[index] ? -1 : 1;
+        }
+    }
+    return 0;
+}
+/** Evalúa un rango de comparadores separados por espacios: `>=1.2.3 <1.3.0`. */
+export function satisfiesRange(version, range) {
+    const parsed = parseVersion(version);
+    if (parsed === null) {
+        return false;
+    }
+    const comparators = range.trim().split(/\s+/).filter((item) => item !== '');
+    if (comparators.length === 0) {
+        return false;
+    }
+    return comparators.every((comparator) => {
+        const match = /^(>=|<=|>|<|=)?(\d+\.\d+\.\d+)$/.exec(comparator);
+        if (match === null) {
+            return false;
+        }
+        const bound = parseVersion(match[2]);
+        if (bound === null) {
+            return false;
+        }
+        const order = compareVersions(parsed, bound);
+        switch (match[1] ?? '=') {
+            case '>=':
+                return order >= 0;
+            case '<=':
+                return order <= 0;
+            case '>':
+                return order > 0;
+            case '<':
+                return order < 0;
+            default:
+                return order === 0;
+        }
+    });
+}

package/dist/sync/config.js

@@ -53,8 +53,9 @@ export async function loadSyncConfig(root) {
         const spec = TARGETS[tool];
         ruleTargets[tool] = { path: spec.rules, shape: spec.ruleShape };
     }
-    const engineSkills = [...new Set(engine.commands.map((command) => command.skill))].sort();
-    const sources = [{ source: ENGINE_SKILLS_SOURCE, publish: engineSkills }];
+    // Los 17 comandos los provee Spec Kit en cada destino; AI-Hub no proyecta sus cuerpos.
+    void engine;
+    const sources = [];
     if (manifest.skills.publish.length > 0) {
         sources.push({ source: manifest.skills.source, publish: manifest.skills.publish });
     }