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

package/dist/manifest/dispatch.d.ts

@@ -0,0 +1,13 @@
+import type { EngineCommand, EngineManifest, Lane } from '../engine/engine.js';
+export declare class UnknownSpecCommandError extends Error {
+    readonly commandId: string;
+    constructor(commandId: string);
+}
+export declare class RoleMismatchError extends Error {
+    readonly commandId: string;
+    readonly expected: string[];
+    readonly received: string;
+    constructor(commandId: string, expected: string[], received: string);
+}
+export declare function resolveCommand(engine: EngineManifest, commandId: string, roleId: string): EngineCommand;
+export declare function commandsByLane(engine: EngineManifest, lane: Lane): EngineCommand[];

package/dist/manifest/dispatch.js

@@ -0,0 +1,36 @@
+export class UnknownSpecCommandError extends Error {
+    commandId;
+    constructor(commandId) {
+        super(`comando de Spec Kit desconocido: ${commandId}`);
+        this.commandId = commandId;
+        this.name = 'UnknownSpecCommandError';
+    }
+}
+export class RoleMismatchError extends Error {
+    commandId;
+    expected;
+    received;
+    constructor(commandId, expected, received) {
+        super(`el comando "${commandId}" pertenece a ${expected.join(', ')}; el rol recibido fue "${received}"`);
+        this.commandId = commandId;
+        this.expected = expected;
+        this.received = received;
+        this.name = 'RoleMismatchError';
+    }
+}
+export function resolveCommand(engine, commandId, roleId) {
+    const command = engine.commands.find((item) => item.id === commandId);
+    if (!command) {
+        throw new UnknownSpecCommandError(commandId);
+    }
+    const allowed = [command.role, ...(command.co_roles ?? [])];
+    if (!allowed.includes(roleId)) {
+        throw new RoleMismatchError(command.id, allowed, roleId);
+    }
+    return command;
+}
+export function commandsByLane(engine, lane) {
+    return engine.commands
+        .filter((command) => command.lane === lane)
+        .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+}

package/dist/manifest/labels.d.ts

@@ -0,0 +1,15 @@
+export declare const LABELS: readonly ["ai::todo", "ai::in-spec", "ai::spec-ready", "ai::in-dev", "ai::in-review", "ai::done", "ai::blocked"];
+export type Label = (typeof LABELS)[number];
+export type LabelEvent = 'spec-start' | 'spec-ready' | 'approve' | 'review-start' | 'review-pass' | 'block' | 'unblock' | 'reopen';
+export declare const LABEL_EVENTS: LabelEvent[];
+export declare class LabelTransitionError extends Error {
+    readonly from: Label;
+    readonly event: LabelEvent;
+    readonly allowed: LabelEvent[];
+    constructor(from: Label, event: LabelEvent, allowed: LabelEvent[]);
+}
+export declare function isLabel(value: string): value is Label;
+export declare function allowedEvents(from: Label): LabelEvent[];
+export declare function advanceLabel(from: Label, event: LabelEvent): Label;
+export declare function dryRunLane(start: Label, events: LabelEvent[]): Label[];
+export declare function assertHumanGate(from: Label, event: LabelEvent): void;

package/dist/manifest/labels.js

@@ -0,0 +1,70 @@
+export const LABELS = [
+    'ai::todo',
+    'ai::in-spec',
+    'ai::spec-ready',
+    'ai::in-dev',
+    'ai::in-review',
+    'ai::done',
+    'ai::blocked',
+];
+export const LABEL_EVENTS = [
+    'spec-start',
+    'spec-ready',
+    'approve',
+    'review-start',
+    'review-pass',
+    'block',
+    'unblock',
+    'reopen',
+];
+const TRANSITIONS = {
+    'ai::todo': { 'spec-start': 'ai::in-spec', block: 'ai::blocked' },
+    'ai::in-spec': { 'spec-ready': 'ai::spec-ready', block: 'ai::blocked' },
+    'ai::spec-ready': { approve: 'ai::in-dev', block: 'ai::blocked' },
+    'ai::in-dev': { 'review-start': 'ai::in-review', block: 'ai::blocked' },
+    'ai::in-review': {
+        'review-pass': 'ai::done',
+        block: 'ai::blocked',
+    },
+    'ai::done': { reopen: 'ai::todo' },
+    'ai::blocked': { unblock: 'ai::todo', reopen: 'ai::todo' },
+};
+export class LabelTransitionError extends Error {
+    from;
+    event;
+    allowed;
+    constructor(from, event, allowed) {
+        super(`transición no permitida: ${from} + ${event}. Eventos válidos: ${allowed.join(', ') || 'ninguno'}`);
+        this.from = from;
+        this.event = event;
+        this.allowed = allowed;
+        this.name = 'LabelTransitionError';
+    }
+}
+export function isLabel(value) {
+    return LABELS.includes(value);
+}
+export function allowedEvents(from) {
+    return Object.keys(TRANSITIONS[from]);
+}
+export function advanceLabel(from, event) {
+    const next = TRANSITIONS[from][event];
+    if (!next) {
+        throw new LabelTransitionError(from, event, allowedEvents(from));
+    }
+    return next;
+}
+export function dryRunLane(start, events) {
+    const path = [start];
+    let current = start;
+    for (const event of events) {
+        current = advanceLabel(current, event);
+        path.push(current);
+    }
+    return path;
+}
+export function assertHumanGate(from, event) {
+    if (event === 'approve' && from !== 'ai::spec-ready') {
+        throw new LabelTransitionError(from, event, allowedEvents(from));
+    }
+}

package/dist/manifest/manifest.d.ts

@@ -0,0 +1,113 @@
+import { ENGINE_COUNTS, type EngineManifest } from '../engine/engine.js';
+import { type ResolvedPreset } from '../presets/resolve.js';
+import type { PresetDangerPattern } from '../presets/schema.js';
+export declare const MANIFEST_FILE = "manifest.yaml";
+export declare const INVENTORY_RELATIVE = "core/manifest.json";
+export { ENGINE_COUNTS };
+export interface ProjectManifest {
+    version: 2;
+    project: {
+        id: string;
+        name: string;
+    };
+    preset: {
+        id: string;
+        version: number;
+        source: 'package';
+    };
+    stack: {
+        languages: string[];
+        frontend?: string;
+        backend?: string;
+        packageManager?: string;
+    };
+    commands: Record<string, string>;
+    paths: {
+        source: string[];
+        tests: string[];
+        docs: string[];
+    };
+    targets: string[];
+    policy: {
+        trunk: 'auto' | 'closed' | 'open';
+        guardMode: 'shadow' | 'enforce';
+        worktrees: boolean;
+        optOuts: string[];
+        dangerPatterns?: PresetDangerPattern[];
+    };
+    skills: {
+        source: string;
+        publish: string[];
+    };
+    agents: {
+        source: string;
+        publish: string[];
+    };
+    rules: {
+        source: string;
+        publish: string[];
+    };
+    mcp?: {
+        source: string;
+    };
+}
+export declare class ManifestError extends Error {
+    readonly errors: string[];
+    constructor(errors: string[]);
+}
+export declare function readManifestFile(root: string): Promise<unknown>;
+export interface LoadedManifest {
+    manifest: ProjectManifest;
+    engine: EngineManifest;
+    preset: ResolvedPreset;
+}
+export declare function loadManifest(root: string): Promise<ProjectManifest>;
+export declare function loadManifestContext(root: string): Promise<LoadedManifest>;
+export declare function validateManifestData(data: unknown, root?: string): Promise<LoadedManifest>;
+export declare function inventoryPath(root: string): string;
+export interface ManifestInventory {
+    version: 2;
+    generatedBy: string;
+    project: {
+        id: string;
+        name: string;
+    };
+    preset: {
+        id: string;
+        version: number;
+    };
+    engine: {
+        roles: number;
+        commands: number;
+        labels: number;
+    };
+    roles: string[];
+    commands: Array<{
+        id: string;
+        lane: string;
+        role: string;
+        skill: string;
+    }>;
+    labels: string[];
+    targets: string[];
+    agents: string[];
+    skills: string[];
+    rules: string[];
+    counts: {
+        roles: number;
+        commands: number;
+        labels: number;
+        targets: number;
+        agents: number;
+        skills: number;
+        rules: number;
+    };
+}
+export declare function buildInventory(manifest: ProjectManifest, engine: EngineManifest): ManifestInventory;
+export declare function serializeInventory(inventory: ManifestInventory): string;
+export declare function writeInventory(root: string): Promise<ManifestInventory>;
+export declare function checkInventory(root: string): Promise<{
+    ok: boolean;
+    expected: string;
+    actual: string | null;
+}>;

package/dist/manifest/manifest.js

@@ -0,0 +1,202 @@
+import fs from 'node:fs/promises';
+import { PACKAGE_NAME } from '../package-info.js';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Ajv } from 'ajv';
+import { parse } from 'yaml';
+import { ENGINE_COUNTS, ENGINE_SKILLS_DIR, loadEngine } from '../engine/engine.js';
+import { frontmatterString, splitFrontmatter } from '../frontmatter.js';
+import { resolvePreset } from '../presets/resolve.js';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const SCHEMA_PATH = path.join(__dirname, '..', '..', 'schema', 'manifest.schema.json');
+const ENGINE_AGENTS = path.join(__dirname, '..', '..', 'agents');
+export const MANIFEST_FILE = 'manifest.yaml';
+export const INVENTORY_RELATIVE = 'core/manifest.json';
+export { ENGINE_COUNTS };
+export class ManifestError extends Error {
+    errors;
+    constructor(errors) {
+        super(`manifiesto inválido:\n${errors.map((error) => `  - ${error}`).join('\n')}`);
+        this.name = 'ManifestError';
+        this.errors = errors;
+    }
+}
+let validateFn = null;
+async function validator() {
+    if (validateFn) {
+        return validateFn;
+    }
+    const schema = JSON.parse(await fs.readFile(SCHEMA_PATH, 'utf8'));
+    const ajv = new Ajv({ allErrors: true });
+    validateFn = ajv.compile(schema);
+    return validateFn;
+}
+async function exists(file) {
+    return fs.access(file).then(() => true, () => false);
+}
+async function validateCatalogFile(file, errors) {
+    const text = await fs.readFile(file, 'utf8').catch(() => null);
+    if (text === null) {
+        errors.push(`no se puede leer ${file}`);
+        return;
+    }
+    try {
+        const { data } = splitFrontmatter(text, file);
+        frontmatterString(data, 'name', file);
+        frontmatterString(data, 'description', file);
+    }
+    catch (error) {
+        errors.push(error instanceof Error ? error.message : String(error));
+    }
+}
+export async function readManifestFile(root) {
+    const file = path.join(root, MANIFEST_FILE);
+    const raw = await fs.readFile(file, 'utf8').catch(() => {
+        throw new ManifestError([`no se encuentra ${MANIFEST_FILE} en ${root}`]);
+    });
+    try {
+        return parse(raw);
+    }
+    catch (error) {
+        throw new ManifestError([`${MANIFEST_FILE} no es YAML válido: ${error.message}`]);
+    }
+}
+export async function loadManifest(root) {
+    return (await loadManifestContext(root)).manifest;
+}
+export async function loadManifestContext(root) {
+    return validateManifestData(await readManifestFile(root), root);
+}
+export async function validateManifestData(data, root = process.cwd()) {
+    const validate = await validator();
+    if (!validate(data)) {
+        throw new ManifestError((validate.errors ?? []).map((error) => {
+            const params = error.params;
+            const property = typeof params.additionalProperty === 'string' ? ` "${params.additionalProperty}"` : '';
+            return `${error.instancePath || '(root)'}${property} ${error.message ?? 'inválido'}`;
+        }));
+    }
+    const manifest = data;
+    const engine = await loadEngine();
+    let preset;
+    try {
+        preset = await resolvePreset(manifest.preset.id);
+    }
+    catch (error) {
+        throw new ManifestError([error.message]);
+    }
+    if (preset.version !== manifest.preset.version) {
+        throw new ManifestError([
+            `preset.version ${manifest.preset.version} no coincide con la versión ${preset.version} de "${preset.id}"`,
+        ]);
+    }
+    const errors = [];
+    for (const target of manifest.targets) {
+        if (!engine.targets.includes(target)) {
+            errors.push(`targets "${target}" no existe en el motor`);
+        }
+    }
+    const skillFiles = new Set();
+    for (const skill of manifest.skills.publish) {
+        const file = path.join(root, manifest.skills.source, skill, 'SKILL.md');
+        skillFiles.add(file);
+        if (!(await exists(file))) {
+            errors.push(`skills.publish "${skill}" no existe en ${manifest.skills.source}`);
+        }
+    }
+    for (const skill of new Set(engine.commands.map((command) => command.skill))) {
+        const file = path.join(ENGINE_SKILLS_DIR, skill, 'SKILL.md');
+        skillFiles.add(file);
+        if (!(await exists(file))) {
+            errors.push(`skill del motor "${skill}" no existe en ${ENGINE_SKILLS_DIR}`);
+        }
+    }
+    for (const file of skillFiles) {
+        if (await exists(file)) {
+            await validateCatalogFile(file, errors);
+        }
+    }
+    for (const agent of manifest.agents.publish) {
+        const projectFile = path.join(root, manifest.agents.source, `${agent}.md`);
+        const engineFile = path.join(ENGINE_AGENTS, `${agent}.md`);
+        const file = (await exists(projectFile))
+            ? projectFile
+            : (await exists(engineFile))
+                ? engineFile
+                : null;
+        if (file === null) {
+            errors.push(`agents.publish "${agent}" no existe en ${manifest.agents.source} ni en el motor`);
+            continue;
+        }
+        await validateCatalogFile(file, errors);
+    }
+    for (const rule of manifest.rules.publish) {
+        const file = path.join(root, manifest.rules.source, `${rule}.md`);
+        if (!(await exists(file))) {
+            errors.push(`rules.publish "${rule}" no existe en ${manifest.rules.source}`);
+        }
+    }
+    if (manifest.mcp && !(await exists(path.join(root, manifest.mcp.source)))) {
+        const projectMcp = path.join(root, '.ai-hub', path.basename(manifest.mcp.source));
+        if (!(await exists(projectMcp))) {
+            errors.push(`mcp.source "${manifest.mcp.source}" no existe`);
+        }
+    }
+    if (errors.length > 0) {
+        throw new ManifestError(errors);
+    }
+    return { manifest, engine, preset };
+}
+export function inventoryPath(root) {
+    return path.join(root, INVENTORY_RELATIVE);
+}
+export function buildInventory(manifest, engine) {
+    const roles = engine.roles.map((role) => role.id).sort();
+    const commands = [...engine.commands]
+        .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+        .map((command) => ({ id: command.id, lane: command.lane, role: command.role, skill: command.skill }));
+    const labels = [...engine.labels].sort();
+    const skills = [...new Set([...engine.commands.map((command) => command.skill), ...manifest.skills.publish])].sort();
+    const agents = [...manifest.agents.publish].sort();
+    const rules = [...manifest.rules.publish].sort();
+    return {
+        version: 2,
+        generatedBy: PACKAGE_NAME,
+        project: manifest.project,
+        preset: { id: manifest.preset.id, version: manifest.preset.version },
+        engine: { roles: engine.roles.length, commands: engine.commands.length, labels: engine.labels.length },
+        roles,
+        commands,
+        labels,
+        targets: [...manifest.targets].sort(),
+        agents,
+        skills,
+        rules,
+        counts: {
+            roles: roles.length,
+            commands: commands.length,
+            labels: labels.length,
+            targets: manifest.targets.length,
+            agents: agents.length,
+            skills: skills.length,
+            rules: rules.length,
+        },
+    };
+}
+export function serializeInventory(inventory) {
+    return `${JSON.stringify(inventory, null, 2)}\n`;
+}
+export async function writeInventory(root) {
+    const { manifest, engine } = await loadManifestContext(root);
+    const inventory = buildInventory(manifest, engine);
+    const file = inventoryPath(root);
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, serializeInventory(inventory), 'utf8');
+    return inventory;
+}
+export async function checkInventory(root) {
+    const { manifest, engine } = await loadManifestContext(root);
+    const expected = serializeInventory(buildInventory(manifest, engine));
+    const actual = await fs.readFile(inventoryPath(root), 'utf8').catch(() => null);
+    return { ok: actual === expected, expected, actual };
+}

package/dist/package-info.d.ts

@@ -0,0 +1,4 @@
+/** Nombre con el que se publica este paquete. Derivado del package.json, nunca hardcodeado. */
+export declare const PACKAGE_NAME: string;
+/** Versión del paquete en ejecución. */
+export declare const PACKAGE_VERSION: string;

package/dist/package-info.js

@@ -0,0 +1,7 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+const own = require('../package.json');
+/** Nombre con el que se publica este paquete. Derivado del package.json, nunca hardcodeado. */
+export const PACKAGE_NAME = own.name;
+/** Versión del paquete en ejecución. */
+export const PACKAGE_VERSION = own.version;

package/dist/paths.d.ts

@@ -0,0 +1,33 @@
+export type AiHubSource = 'env' | 'rc' | 'dot-dir' | 'plain-dir' | 'manifest-root';
+export interface AiHubLocation {
+    /** Absolute harness directory (the one that contains manifest.yaml). */
+    dir: string;
+    source: AiHubSource;
+    manifest: string;
+}
+export interface AiHubRc {
+    version: 1 | 2;
+    dir?: string;
+    preset?: string;
+    targets?: string[];
+    guardMode?: 'shadow' | 'enforce';
+}
+export declare class AiHubDirNotFoundError extends Error {
+    readonly tried: string[];
+    constructor(tried: string[]);
+}
+export declare class AiHubRcError extends Error {
+    constructor(message: string);
+}
+/** Reads `.ai-hubrc.json` next to the caller, if present. */
+export declare function readAiHubRc(startDir: string): AiHubRc | null;
+export declare function writeAiHubRc(startDir: string, rc: AiHubRc): void;
+/**
+ * Resolves the harness directory without assuming `.ai-hub/` or `ai-hub/`.
+ *
+ * Order: AI_HUB_DIR → .ai-hubrc.json `dir` → ./.ai-hub → ./ai-hub → nearest ancestor with manifest.yaml.
+ * An explicit source (env or rc) that points nowhere fails fast instead of silently falling through.
+ */
+export declare function resolveAiHubDir(startDir?: string): AiHubLocation;
+export declare function manifestPath(dir: string): string;
+export declare function lockPath(dir: string): string;

package/dist/paths.js

@@ -0,0 +1,123 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+export class AiHubDirNotFoundError extends Error {
+    tried;
+    constructor(tried) {
+        super(`No se encontró el arnés de ai-hub. Rutas probadas:\n${tried.map((p) => `  - ${p}`).join('\n')}`);
+        this.tried = tried;
+        this.name = 'AiHubDirNotFoundError';
+    }
+}
+export class AiHubRcError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'AiHubRcError';
+    }
+}
+const RC_NAME = '.ai-hubrc.json';
+const MANIFEST_NAME = 'manifest.yaml';
+function hasManifest(dir) {
+    return existsSync(path.join(dir, MANIFEST_NAME));
+}
+/** Reads `.ai-hubrc.json` next to the caller, if present. */
+export function readAiHubRc(startDir) {
+    const file = path.join(startDir, RC_NAME);
+    if (!existsSync(file)) {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch (error) {
+        throw new AiHubRcError(`${RC_NAME} no es JSON válido: ${error.message}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new AiHubRcError(`${RC_NAME} debe ser un objeto`);
+    }
+    const data = parsed;
+    if (data.version !== 1 && data.version !== 2) {
+        throw new AiHubRcError(`${RC_NAME}: "version" debe ser 1 o 2`);
+    }
+    if (data.dir !== undefined && (typeof data.dir !== 'string' || data.dir.trim() === '')) {
+        throw new AiHubRcError(`${RC_NAME}: "dir" debe ser un texto no vacío`);
+    }
+    if (data.preset !== undefined && (typeof data.preset !== 'string' || data.preset.trim() === '')) {
+        throw new AiHubRcError(`${RC_NAME}: "preset" debe ser un texto no vacío`);
+    }
+    if (data.guardMode !== undefined && data.guardMode !== 'shadow' && data.guardMode !== 'enforce') {
+        throw new AiHubRcError(`${RC_NAME}: "guardMode" debe ser "shadow" o "enforce"`);
+    }
+    if (data.targets !== undefined) {
+        if (!Array.isArray(data.targets) || !data.targets.every((t) => typeof t === 'string')) {
+            throw new AiHubRcError(`${RC_NAME}: "targets" debe ser una lista de textos`);
+        }
+    }
+    return {
+        version: data.version,
+        dir: data.dir,
+        preset: data.preset,
+        targets: data.targets,
+        guardMode: data.guardMode,
+    };
+}
+export function writeAiHubRc(startDir, rc) {
+    writeFileSync(path.join(startDir, RC_NAME), `${JSON.stringify(rc, null, 2)}\n`, 'utf8');
+}
+/**
+ * Resolves the harness directory without assuming `.ai-hub/` or `ai-hub/`.
+ *
+ * Order: AI_HUB_DIR → .ai-hubrc.json `dir` → ./.ai-hub → ./ai-hub → nearest ancestor with manifest.yaml.
+ * An explicit source (env or rc) that points nowhere fails fast instead of silently falling through.
+ */
+export function resolveAiHubDir(startDir = process.cwd()) {
+    const start = path.resolve(startDir);
+    const tried = [];
+    const fromEnv = process.env.AI_HUB_DIR;
+    if (fromEnv && fromEnv.trim() !== '') {
+        const dir = path.resolve(start, fromEnv);
+        tried.push(`${dir} (AI_HUB_DIR)`);
+        if (hasManifest(dir)) {
+            return { dir, source: 'env', manifest: path.join(dir, MANIFEST_NAME) };
+        }
+        throw new AiHubDirNotFoundError(tried);
+    }
+    const rc = readAiHubRc(start);
+    if (rc?.dir) {
+        const dir = path.resolve(start, rc.dir);
+        tried.push(`${dir} (${RC_NAME})`);
+        if (hasManifest(dir)) {
+            return { dir, source: 'rc', manifest: path.join(dir, MANIFEST_NAME) };
+        }
+        throw new AiHubDirNotFoundError(tried);
+    }
+    const dotDir = path.join(start, '.ai-hub');
+    tried.push(dotDir);
+    if (hasManifest(dotDir)) {
+        return { dir: dotDir, source: 'dot-dir', manifest: path.join(dotDir, MANIFEST_NAME) };
+    }
+    const plainDir = path.join(start, 'ai-hub');
+    tried.push(plainDir);
+    if (hasManifest(plainDir)) {
+        return { dir: plainDir, source: 'plain-dir', manifest: path.join(plainDir, MANIFEST_NAME) };
+    }
+    let cursor = start;
+    for (;;) {
+        tried.push(cursor);
+        if (hasManifest(cursor)) {
+            return { dir: cursor, source: 'manifest-root', manifest: path.join(cursor, MANIFEST_NAME) };
+        }
+        const parent = path.dirname(cursor);
+        if (parent === cursor) {
+            break;
+        }
+        cursor = parent;
+    }
+    throw new AiHubDirNotFoundError(tried);
+}
+export function manifestPath(dir) {
+    return path.join(dir, MANIFEST_NAME);
+}
+export function lockPath(dir) {
+    return path.join(dir, 'sync.lock.json');
+}

package/dist/presets/detect.d.ts

@@ -0,0 +1,24 @@
+export interface RepoProfile {
+    files: string[];
+    dependencies: Record<string, string>;
+    packageManagers: string[];
+    testRunners: string[];
+    signals: string[];
+}
+export interface DetectionCandidate {
+    id: string;
+    score: number;
+}
+export interface DetectionResult {
+    id: string;
+    candidates: DetectionCandidate[];
+    ambiguous: string[];
+    profile: RepoProfile;
+}
+export declare function detectRepo(root: string): Promise<RepoProfile>;
+export declare function detectPreset(root: string): Promise<DetectionResult>;
+export declare function chooseDetection(candidates: DetectionCandidate[]): {
+    id: string;
+    ambiguous: string[];
+};
+export declare function applyPackageManager(profile: RepoProfile, presetPackageManager: string | undefined): string | undefined;