@webpresso/agent-kit 0.21.0

package/dist/esm/cli/commands/test.js

@@ -0,0 +1,88 @@
+import { spawnSync } from 'node:child_process';
+import { buildTestCommand, resolveTestTarget } from '#test';
+export const TEST_COMMAND_HELP = [
+    'Run tests through the portable webpresso test surface.',
+    '',
+    'Examples:',
+    '  wp test --package cli2',
+    '  wp test --file apps/cli2/src/commands/target.test.ts',
+    '  wp test --package cli2 -- --reporter=dot',
+].join('\n');
+export function createAkTestCommandConfig(input) {
+    const target = resolveTestTarget({
+        package: toArray(input.package),
+        file: toArray(input.file),
+        positional: toArray(input.targets),
+    });
+    return buildTestCommand(target, input);
+}
+export function registerTestCommand(cli) {
+    cli
+        .command('test [...targets]', TEST_COMMAND_HELP)
+        .option('--package <name>', 'Run tests for a package target')
+        .option('--file <path>', 'Run tests for a file target')
+        .option('--watch', 'Run Vitest in watch mode or vp test:watch for package targets')
+        .option('--coverage', 'Forward coverage to the underlying test runner')
+        .option('-t, --test-name-pattern <pattern>', 'Forward a Vitest test name pattern')
+        .option('--mutation', 'Use the vp test:mutation task for package targets')
+        .option('--workers', 'Use the vp test:workers task for package targets')
+        .option('--cache', 'Enable vp cache')
+        .option('--no-cache', 'Disable vp cache')
+        .option('--parallel', 'Forward --parallel to vp')
+        .option('--concurrency-limit <n>', 'Forward a vp concurrency limit')
+        .option('--log <mode>', 'Forward vp log mode')
+        .option('--print-command', 'Print the resolved command instead of executing it')
+        .action((targets, flags) => {
+        const rawArgv = process.argv.slice(2);
+        const command = createAkTestCommandConfig({
+            package: flags.package,
+            file: flags.file,
+            targets: targets ?? [],
+            passthrough: getPassthroughArgs(rawArgv),
+            watch: Boolean(flags.watch),
+            coverage: Boolean(flags.coverage),
+            testNamePattern: flags.testNamePattern,
+            mutation: Boolean(flags.mutation),
+            workers: Boolean(flags.workers),
+            cache: rawArgv.includes('--cache'),
+            noCache: rawArgv.includes('--no-cache'),
+            parallel: Boolean(flags.parallel),
+            concurrencyLimit: toOptionalNumber(flags.concurrencyLimit),
+            log: flags.log,
+        });
+        if (flags.printCommand) {
+            console.log(formatShellCommand(command));
+            return 0;
+        }
+        return runCommand(command);
+    });
+}
+function runCommand(config) {
+    const result = spawnSync(config.command, config.args, {
+        env: { ...process.env, ...config.env },
+        stdio: 'inherit',
+    });
+    return result.status ?? 1;
+}
+function getPassthroughArgs(argv) {
+    const separatorIndex = argv.indexOf('--');
+    return separatorIndex === -1 ? [] : argv.slice(separatorIndex + 1);
+}
+function formatShellCommand(config) {
+    return [config.command, ...config.args].map(shellQuote).join(' ');
+}
+function shellQuote(value) {
+    return /^[A-Za-z0-9_./:=@+-]+$/u.test(value) ? value : `'${value.replace(/'/gu, "'\\''")}'`;
+}
+function toArray(value) {
+    if (value === undefined)
+        return [];
+    return typeof value === 'string' ? [value] : [...value];
+}
+function toOptionalNumber(value) {
+    if (value === undefined)
+        return;
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+//# sourceMappingURL=test.js.map

package/dist/esm/cli/commands/typecheck.d.ts

@@ -0,0 +1,18 @@
+import type { CAC } from 'cac';
+import type { SpawnSyncReturns } from 'node:child_process';
+export declare const TYPECHECK_COMMAND_HELP: string;
+export interface TypecheckOptions {
+    readonly pretty?: boolean;
+    readonly cwd?: string;
+}
+export interface TypecheckCommandConfig {
+    readonly command: string;
+    readonly args: readonly string[];
+}
+export interface TypecheckCommandDeps {
+    readonly run?: (command: string, args: readonly string[]) => SpawnSyncReturns<string>;
+}
+export declare function registerTypecheckCommand(cli: CAC): void;
+export declare function buildTypecheckCommand(options?: TypecheckOptions): TypecheckCommandConfig;
+export declare function runTypecheckCommand(options?: TypecheckOptions, deps?: TypecheckCommandDeps): number;
+//# sourceMappingURL=typecheck.d.ts.map

package/dist/esm/cli/commands/typecheck.js

@@ -0,0 +1,57 @@
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+export const TYPECHECK_COMMAND_HELP = [
+    'Typecheck the current workspace through the portable wp surface.',
+    '',
+    'Examples:',
+    '  wp typecheck',
+    '  wp typecheck --pretty',
+].join('\n');
+export function registerTypecheckCommand(cli) {
+    cli
+        .command('typecheck', TYPECHECK_COMMAND_HELP)
+        .option('--pretty', 'Keep TypeScript pretty output enabled')
+        .action((flags) => runTypecheckCommand({ pretty: Boolean(flags.pretty) }));
+}
+export function buildTypecheckCommand(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    if (hasCheckTypesScript(cwd)) {
+        return {
+            command: 'vp',
+            args: ['run', 'check-types'],
+        };
+    }
+    return {
+        command: 'tsc',
+        args: ['--noEmit', ...(options.pretty ? [] : ['--pretty', 'false'])],
+    };
+}
+export function runTypecheckCommand(options = {}, deps = {}) {
+    const command = buildTypecheckCommand(options);
+    const result = (deps.run ?? defaultRun)(command.command, command.args);
+    if (typeof result.status === 'number')
+        return result.status;
+    return 1;
+}
+function defaultRun(command, args) {
+    return spawnSync(command, [...args], {
+        encoding: 'utf8',
+        env: process.env,
+        stdio: 'inherit',
+        windowsHide: true,
+    });
+}
+function hasCheckTypesScript(cwd) {
+    const packageJsonPath = join(cwd, 'package.json');
+    if (!existsSync(packageJsonPath))
+        return false;
+    try {
+        const parsed = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+        return typeof parsed.scripts?.['check-types'] === 'string';
+    }
+    catch {
+        return false;
+    }
+}
+//# sourceMappingURL=typecheck.js.map

package/dist/esm/cli/commands/worktree/router-dispatch.d.ts

@@ -0,0 +1,39 @@
+export interface WorktreeCommandOptions {
+    base?: string;
+    path?: string;
+    name?: string;
+    prefix?: string;
+    dryRun?: boolean;
+    force?: boolean;
+    cwd?: string;
+}
+export interface WorktreeEntry {
+    path: string;
+    head: string;
+    branch: string | null;
+    bare: boolean;
+}
+export interface NewWorktreeTarget {
+    branch: string;
+    path: string;
+    generated: boolean;
+}
+export interface NewWorktreeTargetInput {
+    branch?: string;
+    name?: string;
+    prefix?: string;
+    explicitPath?: string;
+    repoRoot: string;
+    now?: Date;
+    randomSuffix?: () => string;
+    existingEntries?: WorktreeEntry[];
+    branchExists?: (branch: string) => boolean;
+    pathExists?: (path: string) => boolean;
+}
+export declare function parseWorktreePorcelain(raw: string): WorktreeEntry[];
+export declare function sanitizeWorktreeSegment(value: string, fallback?: string): string;
+export declare function resolveNewWorktreeTarget(input: NewWorktreeTargetInput): NewWorktreeTarget;
+export declare function resolveWorktreePath(nameOrPath: string, entries: WorktreeEntry[]): string;
+export declare function formatWorktreeList(entries: WorktreeEntry[], currentWorktreePath: string): string[];
+export declare function executeWorktreeSubcommand(subcommand: string, args: string[], opts: WorktreeCommandOptions): Promise<void>;
+//# sourceMappingURL=router-dispatch.d.ts.map

package/dist/esm/cli/commands/worktree/router-dispatch.js

@@ -0,0 +1,217 @@
+/**
+ * `wp worktree` subcommand dispatch.
+ *
+ * Handles: new, list, remove
+ */
+import { execFileSync, spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+import { scaffoldAgent } from '#cli/commands/init/scaffold-agent';
+import { resolveCatalogDir } from '#cli/commands/init/index';
+import { runUnifiedSync } from '#symlinker/unified-sync';
+import { getProjectRoot } from '#cli/utils';
+export function parseWorktreePorcelain(raw) {
+    const entries = [];
+    const blocks = raw.trim().split(/\n\n+/);
+    for (const block of blocks) {
+        if (!block.trim())
+            continue;
+        const lines = block.split('\n');
+        let path = '';
+        let head = '';
+        let branch = null;
+        let bare = false;
+        for (const line of lines) {
+            if (line.startsWith('worktree '))
+                path = line.slice('worktree '.length);
+            else if (line.startsWith('HEAD '))
+                head = line.slice('HEAD '.length);
+            else if (line.startsWith('branch '))
+                branch = line.slice('branch '.length);
+            else if (line === 'bare')
+                bare = true;
+        }
+        if (path)
+            entries.push({ path, head, branch, bare });
+    }
+    return entries;
+}
+export function sanitizeWorktreeSegment(value, fallback = 'agent') {
+    const sanitized = value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9_.-]+/gi, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return sanitized || fallback;
+}
+function formatTimestamp(now) {
+    const year = now.getFullYear();
+    const month = String(now.getMonth() + 1).padStart(2, '0');
+    const day = String(now.getDate()).padStart(2, '0');
+    const hour = String(now.getHours()).padStart(2, '0');
+    const minute = String(now.getMinutes()).padStart(2, '0');
+    return `${year}-${month}-${day}-${hour}${minute}`;
+}
+function defaultRandomSuffix() {
+    return Math.random().toString(36).slice(2, 5).padEnd(3, '0');
+}
+function defaultWorktreePath(repoRoot, branch) {
+    const pathSegment = sanitizeWorktreeSegment(branch);
+    return join(dirname(repoRoot), `${basename(repoRoot)}-${pathSegment}`);
+}
+function collides(branch, path, entries, branchExists, pathExists) {
+    return branchExists(branch) || entries.some((e) => e.path === path) || pathExists(path);
+}
+export function resolveNewWorktreeTarget(input) {
+    const branch = input.branch?.trim();
+    const name = input.name?.trim();
+    if (branch && name) {
+        throw new Error('Use either <branch> or --name, not both.');
+    }
+    if (branch) {
+        return {
+            branch,
+            path: input.explicitPath ?? defaultWorktreePath(input.repoRoot, branch),
+            generated: false,
+        };
+    }
+    const prefix = sanitizeWorktreeSegment(input.prefix ?? 'agent');
+    const now = input.now ?? new Date();
+    const randomSuffix = input.randomSuffix ?? defaultRandomSuffix;
+    const entries = input.existingEntries ?? [];
+    const branchExists = input.branchExists ?? (() => false);
+    const pathExists = input.pathExists ?? (() => false);
+    const baseSlug = name ? sanitizeWorktreeSegment(name) : formatTimestamp(now);
+    for (let attempt = 0; attempt < 20; attempt += 1) {
+        const suffix = name && attempt === 0 ? '' : `-${sanitizeWorktreeSegment(randomSuffix(), 'x')}`;
+        const candidateBranch = `${prefix}/${baseSlug}${suffix}`;
+        const candidatePath = input.explicitPath ?? defaultWorktreePath(input.repoRoot, candidateBranch);
+        if (!collides(candidateBranch, candidatePath, entries, branchExists, pathExists)) {
+            return { branch: candidateBranch, path: candidatePath, generated: true };
+        }
+    }
+    throw new Error('Could not generate a collision-free worktree branch/path after 20 attempts.');
+}
+export function resolveWorktreePath(nameOrPath, entries) {
+    const match = entries.find((e) => e.path === nameOrPath ||
+        basename(e.path) === nameOrPath ||
+        e.branch === nameOrPath ||
+        e.branch === `refs/heads/${nameOrPath}` ||
+        e.branch?.replace('refs/heads/', '') === nameOrPath);
+    if (!match) {
+        throw new Error(`No worktree matching "${nameOrPath}". Run \`wp worktree list\` to see available worktrees.`);
+    }
+    return match.path;
+}
+function gitBranchExists(repoRoot, branch) {
+    const result = spawnSync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branch}`], {
+        cwd: repoRoot,
+    });
+    return result.status === 0;
+}
+function listEntries(repoRoot) {
+    const raw = execFileSync('git', ['worktree', 'list', '--porcelain'], {
+        cwd: repoRoot,
+        encoding: 'utf-8',
+    });
+    return parseWorktreePorcelain(raw);
+}
+export function formatWorktreeList(entries, currentWorktreePath) {
+    if (entries.length === 0)
+        return ['No worktrees found.'];
+    const pathWidth = Math.max(...entries.map((e) => e.path.length), 4);
+    const branchLabels = entries.map((e) => e.branch?.replace('refs/heads/', '') ?? '(detached)');
+    const branchWidth = Math.max(...branchLabels.map((b) => b.length), 6);
+    const rows = [
+        `  ${'PATH'.padEnd(pathWidth)}  ${'BRANCH'.padEnd(branchWidth)}  HEAD`,
+        `  ${'-'.repeat(pathWidth)}  ${'-'.repeat(branchWidth)}  -------`,
+    ];
+    for (const [index, e] of entries.entries()) {
+        const marker = e.path === currentWorktreePath ? '* ' : '  ';
+        const branchShort = branchLabels[index] ?? '(detached)';
+        const headShort = e.head.slice(0, 7);
+        rows.push(`${marker}${e.path.padEnd(pathWidth)}  ${branchShort.padEnd(branchWidth)}  ${headShort}`);
+    }
+    return rows;
+}
+async function handleNew(branch, opts) {
+    const cwd = opts.cwd ?? process.cwd();
+    const repoRoot = getProjectRoot({ startDir: cwd });
+    const existingEntries = listEntries(repoRoot);
+    const target = resolveNewWorktreeTarget({
+        branch,
+        name: opts.name,
+        prefix: opts.prefix,
+        explicitPath: opts.path,
+        repoRoot,
+        existingEntries,
+        branchExists: (candidate) => gitBranchExists(repoRoot, candidate),
+        pathExists: existsSync,
+    });
+    if (opts.dryRun) {
+        console.log('[dry-run] Would create worktree:');
+        console.log(`  branch: ${target.branch}`);
+        console.log(`  path:   ${target.path}`);
+        console.log(`  base:   ${opts.base ?? 'HEAD'}`);
+        return;
+    }
+    const gitArgs = ['worktree', 'add', '-b', target.branch, target.path];
+    if (opts.base)
+        gitArgs.push(opts.base);
+    const addResult = spawnSync('git', gitArgs, { cwd: repoRoot, stdio: 'inherit' });
+    if (addResult.status !== 0) {
+        throw new Error('git worktree add failed');
+    }
+    const catalogDir = resolveCatalogDir();
+    scaffoldAgent({ catalogDir, repoRoot: target.path, options: {} });
+    runUnifiedSync({ catalogDir, consumerRoot: target.path });
+    console.log(`\nWorktree ready: ${target.path}`);
+    console.log(`  branch: ${target.branch}`);
+    console.log(`  cd ${target.path}`);
+}
+function handleList(opts) {
+    const cwd = opts.cwd ?? process.cwd();
+    const repoRoot = getProjectRoot({ startDir: cwd });
+    const entries = listEntries(repoRoot);
+    console.log(formatWorktreeList(entries, repoRoot).join('\n'));
+}
+function handleRemove(nameOrPath, opts) {
+    const cwd = opts.cwd ?? process.cwd();
+    const repoRoot = getProjectRoot({ startDir: cwd });
+    const entries = listEntries(repoRoot);
+    const resolved = resolveWorktreePath(nameOrPath, entries);
+    const gitArgs = ['worktree', 'remove', resolved];
+    if (opts.force)
+        gitArgs.push('--force');
+    const result = spawnSync('git', gitArgs, { cwd: repoRoot, stdio: 'inherit' });
+    if (result.status !== 0) {
+        throw new Error('git worktree remove failed');
+    }
+}
+export async function executeWorktreeSubcommand(subcommand, args, opts) {
+    switch (subcommand) {
+        case 'new': {
+            const branch = args[0];
+            await handleNew(branch ?? '', opts);
+            return;
+        }
+        case 'list': {
+            handleList(opts);
+            return;
+        }
+        case 'remove':
+        case 'rm': {
+            const nameOrPath = args[0];
+            if (!nameOrPath) {
+                throw new Error('Usage: wp worktree remove <branch-or-path> [--force]');
+            }
+            handleRemove(nameOrPath, opts);
+            return;
+        }
+        default: {
+            throw new Error(`Unknown worktree subcommand: "${subcommand}"\n\nUse one of: new, list, remove`);
+        }
+    }
+}
+//# sourceMappingURL=router-dispatch.js.map

package/dist/esm/cli/commands/worktree/router.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `wp worktree` command router.
+ *
+ * Mirrors the tech-debt router pattern:
+ * - router.ts        — registers the CAC command and wires options
+ * - router-dispatch.ts — dispatches subcommands
+ */
+import type { CAC } from 'cac';
+export declare function registerWorktreeRouter(cli: CAC): void;
+//# sourceMappingURL=router.d.ts.map

package/dist/esm/cli/commands/worktree/router.js

@@ -0,0 +1,34 @@
+import { executeWorktreeSubcommand } from './router-dispatch.js';
+const HELP_TEXT = [
+    'Usage: wp worktree <subcommand> [options]',
+    '',
+    'Subcommands:',
+    '  new [branch] [--base <ref>] [--path <dir>]   Create worktree and seed .agent/',
+    '  list                                          List worktrees',
+    '  remove <branch-or-path> [--force]             Remove a worktree',
+    '',
+    'Options:',
+    '  --name <name>       Human-friendly generated branch slug (new only)',
+    '  --prefix <prefix>   Prefix for generated branches (new only, default: agent)',
+    '  --dry-run           Print the resolved worktree target without writing',
+    '  --cwd <dir>         Repo root (default: process.cwd())',
+].join('\n');
+export function registerWorktreeRouter(cli) {
+    cli
+        .command('worktree [subcommand] [...args]', 'Git worktree management with .agent/ seeding (new, list, remove)')
+        .option('--base <ref>', 'Base ref for the new branch (new only, default: HEAD)')
+        .option('--path <dir>', 'Explicit filesystem path for the new worktree (new only)')
+        .option('--name <name>', 'Human-friendly generated branch slug (new only)')
+        .option('--prefix <prefix>', 'Prefix for generated branches (new only, default: agent)')
+        .option('--dry-run', 'Print the resolved worktree target without writing (new only)')
+        .option('--force', 'Force remove even with uncommitted changes (remove only)')
+        .option('--cwd <dir>', 'Repo root to operate from (default: process.cwd())')
+        .action(async (subcommand, args, options) => {
+        if (!subcommand) {
+            console.log(HELP_TEXT);
+            return;
+        }
+        await executeWorktreeSubcommand(subcommand, args, options);
+    });
+}
+//# sourceMappingURL=router.js.map

package/dist/esm/cli/utils.d.ts

@@ -0,0 +1,45 @@
+/**
+ * CLI-wide helper utilities.
+ *
+ * Inlined from webpresso/apps/cli-wp/src/cli-utils.ts (argv normalization,
+ * unknown-command formatting) and webpresso/packages/cli/cli-utils
+ * (getProjectRoot) so this package has no @webpresso/* runtime dependencies.
+ */
+/**
+ * Markers used to detect a project root, in priority order; first hit wins.
+ */
+export declare const PROJECT_ROOT_MARKERS: readonly [".webpressorc.json", "pnpm-workspace.yaml", "package.json", "webpresso/config.yaml"];
+interface GetProjectRootOptions {
+    /** Directory to start searching from (default: process.cwd()) */
+    startDir?: string;
+}
+/**
+ * Walks upward from startDir looking for any marker in
+ * `PROJECT_ROOT_MARKERS` (priority order). Throws if nothing is found.
+ */
+export declare function findProjectRoot(startDir: string): string;
+export declare function getProjectRoot(options?: GetProjectRootOptions): string;
+/**
+ * Normalize process.argv for cac compatibility.
+ *
+ * When invoked through a script-style wrapper that inserts `--` before
+ * `<args>`, the separator lands in argv[2] and prevents cac from seeing the
+ * command. Strip it when it appears immediately after the script path.
+ */
+export declare function normalizeArgv(argv: string[]): string[];
+/**
+ * Format error message for unknown commands with suggestions.
+ */
+export declare function formatUnknownCommandError(input: string | undefined, commands: readonly string[], binName?: string): string;
+/**
+ * Resolve the webpresso package.json and return its version.
+ *
+ * Caller must pass `import.meta.url` from a file that lives at
+ * `<packageRoot>/src/cli/cli.ts` (source) or `<packageRoot>/dist/cli.js`
+ * (bundled). We walk upward until we find a `package.json` whose `name`
+ * is `webpresso`, to be robust against both layouts without
+ * having to know how many `..` segments to append.
+ */
+export declare function readPackageVersion(metaUrl: string): string;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/esm/cli/utils.js

@@ -0,0 +1,156 @@
+/**
+ * CLI-wide helper utilities.
+ *
+ * Inlined from webpresso/apps/cli-wp/src/cli-utils.ts (argv normalization,
+ * unknown-command formatting) and webpresso/packages/cli/cli-utils
+ * (getProjectRoot) so this package has no @webpresso/* runtime dependencies.
+ */
+import { existsSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+// ---------------------------------------------------------------------------
+// Project root resolution
+// ---------------------------------------------------------------------------
+/**
+ * Webpresso framework layout marker — checked last so the webpresso repo
+ * itself resolves correctly when it has no `.webpressorc.json`. Generic
+ * consumers hit `package.json` first and never see this fallback.
+ */
+const CANONICAL_CONFIG_PATH = 'webpresso/config.yaml';
+/**
+ * Markers used to detect a project root, in priority order; first hit wins.
+ */
+export const PROJECT_ROOT_MARKERS = [
+    '.webpressorc.json',
+    'pnpm-workspace.yaml',
+    'package.json',
+    CANONICAL_CONFIG_PATH,
+];
+function findMarker(rootDir) {
+    for (const marker of PROJECT_ROOT_MARKERS) {
+        if (existsSync(path.join(rootDir, marker)))
+            return marker;
+    }
+    return null;
+}
+/**
+ * Walks upward from startDir looking for any marker in
+ * `PROJECT_ROOT_MARKERS` (priority order). Throws if nothing is found.
+ */
+export function findProjectRoot(startDir) {
+    let current = path.resolve(startDir);
+    for (;;) {
+        if (findMarker(current)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            throw new Error(`Could not find project root (looked for ${PROJECT_ROOT_MARKERS.join(', ')}). Started from: ${startDir}`);
+        }
+        current = parent;
+    }
+}
+export function getProjectRoot(options) {
+    return findProjectRoot(options?.startDir ?? process.cwd());
+}
+// ---------------------------------------------------------------------------
+// argv normalization
+// ---------------------------------------------------------------------------
+/**
+ * Normalize process.argv for cac compatibility.
+ *
+ * When invoked through a script-style wrapper that inserts `--` before
+ * `<args>`, the separator lands in argv[2] and prevents cac from seeing the
+ * command. Strip it when it appears immediately after the script path.
+ */
+export function normalizeArgv(argv) {
+    return argv.length >= 3 && argv[2] === '--'
+        ? [argv[0], argv[1], ...argv.slice(3)]
+        : [...argv];
+}
+// ---------------------------------------------------------------------------
+// Unknown-command formatting
+// ---------------------------------------------------------------------------
+function levenshtein(a, b) {
+    if (a === b)
+        return 0;
+    if (!a.length)
+        return b.length;
+    if (!b.length)
+        return a.length;
+    const rows = a.length + 1;
+    const cols = b.length + 1;
+    const dp = Array.from({ length: rows }, () => Array(cols).fill(0));
+    for (let i = 0; i < rows; i++)
+        dp[i][0] = i;
+    for (let j = 0; j < cols; j++)
+        dp[0][j] = j;
+    for (let i = 1; i < rows; i++) {
+        for (let j = 1; j < cols; j++) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        }
+    }
+    return dp[a.length][b.length];
+}
+function findClosestCommand(input, commands) {
+    const scored = commands
+        .map((cmd) => ({ cmd, distance: levenshtein(input, cmd) }))
+        .filter(({ distance, cmd }) => distance <= Math.max(2, Math.floor(cmd.length / 3)))
+        .toSorted((left, right) => left.distance - right.distance);
+    if (!scored.length)
+        return [];
+    const best = scored[0].distance;
+    return scored.filter((entry) => entry.distance === best).map((entry) => entry.cmd);
+}
+/**
+ * Format error message for unknown commands with suggestions.
+ */
+export function formatUnknownCommandError(input, commands, binName = 'wp') {
+    const actual = input ?? '';
+    const suggestions = findClosestCommand(actual, commands);
+    let msg = `Unknown command: ${actual}`;
+    if (suggestions.length === 1) {
+        msg += `\n\nDid you mean: ${binName} ${suggestions[0]}?`;
+    }
+    else if (suggestions.length > 1) {
+        msg += `\n\nDid you mean one of:\n${suggestions.map((s) => `  ${binName} ${s}`).join('\n')}?`;
+    }
+    msg += `\n\nRun ${binName} --help to see available commands.`;
+    return msg;
+}
+// ---------------------------------------------------------------------------
+// Package metadata (for --version)
+// ---------------------------------------------------------------------------
+/**
+ * Resolve the webpresso package.json and return its version.
+ *
+ * Caller must pass `import.meta.url` from a file that lives at
+ * `<packageRoot>/src/cli/cli.ts` (source) or `<packageRoot>/dist/cli.js`
+ * (bundled). We walk upward until we find a `package.json` whose `name`
+ * is `webpresso`, to be robust against both layouts without
+ * having to know how many `..` segments to append.
+ */
+export function readPackageVersion(metaUrl) {
+    const url = new URL(metaUrl);
+    let dir = path.dirname(url.pathname);
+    for (let i = 0; i < 6; i++) {
+        const candidate = path.join(dir, 'package.json');
+        if (existsSync(candidate)) {
+            try {
+                const parsed = JSON.parse(readFileSync(candidate, 'utf-8'));
+                if (parsed.name === 'webpresso') {
+                    return parsed.version ?? '0.0.0';
+                }
+            }
+            catch {
+                // keep walking
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return '0.0.0';
+}
+//# sourceMappingURL=utils.js.map