@illumiarq/lumis 1.2.8 → 1.2.9

package/dist/cli.js

@@ -1,421 +1,192 @@
-#!/usr/bin/env node
 /**
- * @illumiarq/lumis — extended CLI entry point.
+ * Host CLI entrypoint and command dispatcher.
  *
- * Intercepts LumiARQ-specific commands (serve / build / preview) and
- * delegates everything else to the base @lumiarq/lumis runCli().
+ * Commands are declared in a registry and resolved by longest prefix match,
+ * enabling subcommands with free-form trailing arguments (e.g. `intent <text>`).
  */
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { ui, writeError, writeLine } from './console.js';
-import { readStorageRoot } from './paths.js';
-import { serveApp } from './commands/serve.js';
-import { buildApp } from './commands/build.js';
-import { buildVercelFunction } from './commands/build-vercel-fn.js';
-import { previewApp } from './commands/preview.js';
-import { showInfo } from './commands/info.js';
-import { listModules } from './commands/module-list.js';
-import { generateKeys, rotateKeys } from './commands/keys.js';
-import { enableMaintenanceMode, disableMaintenanceMode } from './commands/maintenance.js';
-import { cacheConfig, cacheRoutes, cacheSearchIndex, cacheViews, checkRoutes, clearConfigCache, clearOptimizationCaches, clearRouteCache, clearSearchIndex, clearViews, installAuth, listRoutes, optimizeForProduction, publishConfig, publishStubs, runDatabaseCommand, scheduleList, scheduleRun, showResolvedConfig, workerList, workerStart, } from './commands/app-commands.js';
-const argv = process.argv.slice(2);
-const cmd = argv[0];
-async function main() {
-    if (argv.includes('--help') || cmd === 'help') {
-        return renderCombinedHelp();
-    }
-    // ── LumiARQ-specific commands ──────────────────────────────────────────────
-    if (cmd === 'serve') {
-        const port = parsePort(argv);
-        const host = parseHost(argv);
-        return serveApp({ ...(port !== undefined ? { port } : {}), ...(host ? { host } : {}) });
-    }
-    if (cmd === 'preview') {
-        const port = parsePort(argv);
-        const target = parsePreviewTarget(argv);
-        return previewApp({ ...(port !== undefined ? { port } : {}), ...(target ? { target } : {}) });
-    }
-    if (cmd === 'build') {
-        const target = parseTarget(argv);
-        return buildApp(target !== undefined ? { target } : {});
-    }
-    if (cmd === 'build:vercel') {
-        return buildApp({ target: 'vercel' });
-    }
-    if (cmd === 'build:vercel-fn') {
-        return buildVercelFunction();
-    }
-    if (cmd === 'info') {
-        return showInfo();
-    }
-    if (cmd === 'health') {
-        runHealthPreChecks();
-        const { runCli } = await import('@lumiarq/lumis');
-        return runCli(['doctor', ...argv.slice(1)]);
-    }
-    if (cmd === 'module:list') {
-        return listModules();
-    }
-    if (cmd === 'key:generate') {
-        return generateKeys();
-    }
-    if (cmd === 'key:rotate') {
-        return rotateKeys();
-    }
-    if (cmd === 'config:show') {
-        const configName = argv[1];
-        if (!configName) {
-            writeError(ui.fail('Usage: lumis config:show <name> [--json]'));
-            return 1;
-        }
-        return showResolvedConfig(configName);
-    }
-    if (cmd === 'config:cache') {
-        return cacheConfig();
-    }
-    if (cmd === 'config:clear') {
-        return clearConfigCache();
-    }
-    if (cmd?.startsWith('db:')) {
-        return await runDatabaseCommand(cmd, argv.slice(1));
-    }
-    if (cmd === 'route:list') {
-        return listRoutes();
-    }
-    if (cmd === 'route:check') {
-        return checkRoutes();
-    }
-    if (cmd === 'route:cache') {
-        return cacheRoutes();
-    }
-    if (cmd === 'route:clear') {
-        return clearRouteCache();
-    }
-    if (cmd === 'view:cache') {
-        return cacheViews();
-    }
-    if (cmd === 'view:clear') {
-        return clearViews();
-    }
-    if (cmd === 'search:index') {
-        return cacheSearchIndex();
-    }
-    if (cmd === 'search:clear') {
-        return clearSearchIndex();
-    }
-    if (cmd === 'optimize') {
-        return optimizeForProduction();
-    }
-    if (cmd === 'optimize:clear') {
-        return clearOptimizationCaches();
-    }
-    if (cmd === 'down') {
-        const message = parseStringFlag(argv, '--message');
-        const secret = parseStringFlag(argv, '--secret');
-        const allowedIps = parseRepeatedFlag(argv, '--allow');
-        return enableMaintenanceMode({
-            ...(message ? { message } : {}),
-            ...(secret ? { secret } : {}),
-            ...(allowedIps.length > 0 ? { allowedIps } : {}),
-        });
-    }
-    if (cmd === 'up') {
-        return disableMaintenanceMode();
-    }
-    if (cmd === 'stub:publish') {
-        return publishStubs({ all: argv.includes('--all'), iam: argv.includes('--iam') });
-    }
-    if (cmd === 'auth:install') {
-        const uiFramework = parseStringFlag(argv, '--ui');
-        return installAuth({
-            iam: argv.includes('--iam'),
-            ...(uiFramework ? { ui: uiFramework } : {}),
-        });
-    }
-    if (cmd === 'publish') {
-        const subCmd = argv[1];
-        if (subCmd === 'config') {
-            const configName = argv[2] ?? 'list';
-            return publishConfig(configName, argv.includes('--force'));
-        }
-        if (subCmd === 'stub' || subCmd === 'stubs') {
-            return publishStubs({ all: argv.includes('--all'), iam: argv.includes('--iam') });
-        }
-        writeError(ui.fail(`Unknown publish subcommand: "${subCmd}". Try: publish config <name>`));
-        return 1;
-    }
-    if (cmd === 'worker:start') {
-        return workerStart(argv.includes('--dev'));
-    }
-    if (cmd === 'worker:list') {
-        return workerList();
-    }
-    if (cmd === 'schedule:list') {
-        return scheduleList();
-    }
-    if (cmd === 'schedule:run') {
-        return scheduleRun(argv[1] ?? '');
-    }
-    const projectCommandExit = await runProjectCommandDirect(argv);
-    if (projectCommandExit !== null) {
-        return projectCommandExit;
+import { executeIntentCommand } from './commands/intent.command.js';
+import { executeIrRebuildCommand } from './commands/ir-rebuild.command.js';
+import { executeIrShowCommand } from './commands/ir-show.command.js';
+import { executeMakeCommand } from './commands/make.command.js';
+import { executeCommandsListCommand, executeCommandsRunCommand } from './commands/commands.command.js';
+import { executeDoctorCommand } from './commands/doctor.command.js';
+import { executeInitCommand } from './commands/init.command.js';
+import { executeUseCommand } from './commands/use.command.js';
+import { ansi } from './output/ansi.js';
+import { executePackDetectCommand, executePackListCommand } from './commands/pack.command.js';
+import { executeRuntimeRunCommand, executeRuntimeTranscriptsListCommand, executeRuntimeTranscriptsPruneCommand, executeRuntimeTranscriptsShowCommand, } from './commands/runtime.command.js';
+import { createCommandContext } from './commands/runtime.js';
+import { executeTinkerCommand } from './commands/tinker.command.js';
+import { executeTinkerEvalCommand } from './commands/tinker-eval.command.js';
+import { runInteractiveLauncher } from './launcher.js';
+import { pathToFileURL } from 'node:url';
+const COMMANDS = [
+    { path: ['use'], description: 'Set preferred AI runtime', handler: executeUseCommand },
+    { path: ['pack', 'list'], description: 'List built-in packs', handler: executePackListCommand },
+    { path: ['pack', 'detect'], description: 'Detect best pack for project', handler: executePackDetectCommand },
+    { path: ['commands', 'list'], description: 'List pack and project commands', handler: executeCommandsListCommand },
+    { path: ['commands', 'run'], description: 'Run a pack or project command', handler: executeCommandsRunCommand },
+    { path: ['doctor'], description: 'Run Lumis diagnostics for this project', handler: executeDoctorCommand },
+    { path: ['init'], description: 'Initialize Lumis in this project', handler: executeInitCommand },
+    { path: ['make'], description: 'Create artifacts from intent', handler: executeMakeCommand },
+    { path: ['intent'], description: 'Parse and inspect intent', handler: executeIntentCommand },
+    { path: ['ir', 'show'], description: 'Show current IR', handler: executeIrShowCommand },
+    { path: ['ir', 'rebuild'], description: 'Rebuild project IR', handler: executeIrRebuildCommand },
+    { path: ['runtime', 'run'], description: 'Run runtime profile tasks', handler: executeRuntimeRunCommand },
+    { path: ['runtime', 'transcripts', 'list'], description: 'List runtime transcripts', handler: executeRuntimeTranscriptsListCommand },
+    { path: ['runtime', 'transcripts', 'show'], description: 'Show runtime transcript details', handler: executeRuntimeTranscriptsShowCommand },
+    { path: ['runtime', 'transcripts', 'prune'], description: 'Prune runtime transcripts', handler: executeRuntimeTranscriptsPruneCommand },
+    { path: ['tinker', 'eval'], description: 'Run Tinker evaluation harness', handler: executeTinkerEvalCommand },
+    { path: ['tinker'], description: 'Run interactive tinker mode', handler: executeTinkerCommand },
+];
+function createTraceListener() {
+    if (process.env.LUMIS_TRACE !== '1') {
+        return undefined;
     }
-    // ── Delegate to base @lumiarq/lumis (lazy import avoids auto-run side effect)
-    const { runCli } = await import('@lumiarq/lumis');
-    return runCli(argv);
+    return async (event) => {
+        const payload = {
+            type: event.type,
+            name: event.name,
+            status: event.status,
+            ...(event.message ? { message: event.message } : {}),
+            ...(event.context ? { context: event.context } : {}),
+        };
+        process.stderr.write(`[lumis-trace] ${JSON.stringify(payload)}\n`);
+    };
 }
-async function renderCombinedHelp() {
-    renderWrapperHelp();
-    writeLine(ui.section('Base Lumis Commands'));
-    const { runCli } = await import('@lumiarq/lumis');
-    return runCli(['--help']);
+async function emitTrace(onTrace, event) {
+    if (!onTrace)
+        return;
+    await onTrace(event);
 }
-function renderWrapperHelp() {
-    writeLine();
-    writeLine(ui.section('LumiARQ CLI'));
-    writeLine(`  ${ui.dim('Wrapper commands are shown first; core Lumis commands remain available underneath.')}`);
-    writeLine();
-    writeLine(`  ${ui.bold('Runtime')}`);
-    writeLine('    lumis serve [--port|-p <port>] [--host|-H <host>]');
-    writeLine('    lumis build [--target|--to|--t|-t <node|static|cloudflare|vercel>]');
-    writeLine('    lumis build:vercel');
-    writeLine('    lumis preview [--target|--to|--t|-t <node|static|cloudflare>]');
-    writeLine();
-    writeLine(`  ${ui.bold('App')}`);
-    writeLine('    lumis info');
-    writeLine('    lumis health');
-    writeLine('    lumis module:list');
-    writeLine('    lumis config:show <name>');
-    writeLine('    lumis config:cache | config:clear');
-    writeLine('    lumis route:list | route:check | route:cache | route:clear');
-    writeLine('    lumis view:cache | view:clear');
-    writeLine('    lumis search:index | search:clear');
-    writeLine('    lumis optimize | optimize:clear');
-    writeLine('    lumis key:generate | key:rotate');
-    writeLine('    lumis down [--message <text>] [--secret <token>] [--allow <ip>]');
-    writeLine('    lumis up');
-    writeLine('    lumis auth:install [--iam] [--ui react]');
-    writeLine('    lumis stub:publish [--all|--iam]');
-    writeLine();
-    writeLine(`  ${ui.bold('Database')}`);
-    writeLine('    lumis db:generate | db:migrate');
-    writeLine('    lumis db:ping        — verify DB connection and diagnose failures');
-    writeLine('    lumis db:seed');
-    writeLine('    lumis db:fresh       — migrate + seed (destructive)');
-    writeLine('    lumis db:reset       — drop all tables + migrate');
-    writeLine('    lumis db:studio      — open drizzle-kit studio');
-    writeLine();
-    writeLine(`  ${ui.bold('Config')}`);
-    writeLine('    lumis publish config <name>  — mail | queue | cache | storage | session | security | logging | auth');
-    writeLine('    lumis publish config all     — publish every config file');
-    writeLine('    lumis publish config list    — show available configs');
-    writeLine();
-    writeLine(`  ${ui.bold('Workers & Scheduling')}`);
-    writeLine('    lumis worker:start [--dev]   — start background worker process');
-    writeLine('    lumis worker:list            — list registered workers + scheduled jobs');
-    writeLine('    lumis schedule:list          — list all cron jobs');
-    writeLine('    lumis schedule:run <name>    — run a specific cron job immediately');
-    writeLine();
-    writeLine(`  ${ui.bold('Core Lumis')}`);
-    writeLine('    lumis doctor | init | make | intent | ir:* | runtime:* | tinker');
-    writeLine();
-    writeLine(`  ${ui.bold('Project Commands')}`);
-    writeLine('    lumis <your:command>          — run projectCommands entries directly');
-    writeLine('    lumis commands run project <name>');
-    writeLine();
+function formatUsage() {
+    const lines = [
+        ansi.label('Core CLI'),
+        `  ${ansi.dim('Prompt -> Plan -> Confirm -> Execute -> Verified Result')}`,
+        '',
+        `${ansi.bold('Usage')}:`,
+        `  ${ansi.cyan('lumis --help')}`,
+    ];
+    for (const command of COMMANDS) {
+        lines.push(`  ${ansi.cyan(`lumis ${command.path.join(' ')}`)}  ${ansi.dim(`# ${command.description}`)}`);
+    }
+    return `${lines.join('\n')}\n`;
 }
-const BASE_COMMAND_ROOTS = new Set([
-    'use',
-    'pack',
-    'commands',
-    'doctor',
-    'init',
-    'make',
-    'intent',
-    'ir',
-    'runtime',
-    'tinker',
-]);
-async function runProjectCommandDirect(args) {
-    const candidate = args[0];
-    if (!candidate) {
-        return null;
-    }
-    if (BASE_COMMAND_ROOTS.has(candidate)) {
-        return null;
-    }
-    const { runCli } = await import('@lumiarq/lumis');
-    let stdout = '';
-    let stderr = '';
-    const listExit = await runCli(['commands', 'list', '--json'], {
-        write: (chunk) => {
-            stdout += chunk;
-        },
-        writeError: (chunk) => {
-            stderr += chunk;
-        },
-    });
-    if (listExit !== 0 || stderr.trim().length > 0) {
-        return null;
-    }
-    let commands = [];
-    try {
-        commands = JSON.parse(stdout);
-    }
-    catch {
-        return null;
-    }
-    const exists = commands.some((entry) => entry.source === 'project' && entry.name === candidate);
-    if (!exists) {
+/**
+ * Resolve command using longest prefix semantics.
+ *
+ * Example:
+ * - argv: ['intent', 'create', 'record']
+ * - match: ['intent'] with args ['create', 'record']
+ *
+ * @param argv - Raw command tokens after the executable name.
+ * @returns Matched command and trailing arguments, or null when no command matches.
+ */
+function matchCommand(argv) {
+    const matches = COMMANDS.filter((command) => {
+        if (command.path.length > argv.length) {
+            return false;
+        }
+        return command.path.every((segment, index) => segment === argv[index]);
+    }).sort((left, right) => right.path.length - left.path.length);
+    const command = matches[0];
+    if (!command) {
         return null;
     }
-    return runCli(['commands', 'run', 'project', candidate, ...args.slice(1)]);
+    return {
+        command,
+        args: argv.slice(command.path.length),
+    };
 }
-function runHealthPreChecks() {
-    const cwd = process.cwd();
-    const checks = [];
-    // Required bootstrap files
-    checks.push({
-        label: 'bootstrap/entry.ts present',
-        pass: existsSync(join(cwd, 'bootstrap', 'entry.ts')),
-        fix: 'bootstrap/entry.ts is missing — this is the HTTP server entrypoint.',
-    });
-    checks.push({
-        label: 'bootstrap/providers.ts present',
-        pass: existsSync(join(cwd, 'bootstrap', 'providers.ts')),
-        fix: "bootstrap/providers.ts is missing — service container won't boot.",
-    });
-    checks.push({
-        label: 'config/app.ts present',
-        pass: existsSync(join(cwd, 'config', 'app.ts')),
-        fix: 'config/app.ts is missing — run: lumis publish config app',
-    });
-    checks.push({
-        label: '@types/node installed',
-        pass: existsSync(join(cwd, 'node_modules', '@types', 'node')) ||
-            existsSync(join(cwd, '..', 'node_modules', '@types', 'node')),
-        fix: 'Install @types/node: pnpm add -D @types/node',
-    });
-    // Warn if queue driver isn't stub but worker.ts is missing
-    const queueConfigPath = join(cwd, 'config', 'queue.ts');
-    if (existsSync(queueConfigPath)) {
-        const queueSrc = readFileSync(queueConfigPath, 'utf8');
-        const usesBullmq = queueSrc.includes("'bullmq'") || queueSrc.includes('"bullmq"');
-        if (usesBullmq) {
-            checks.push({
-                label: 'bootstrap/worker.ts present (queue driver: bullmq)',
-                pass: existsSync(join(cwd, 'bootstrap', 'worker.ts')),
-                fix: "Queue driver is 'bullmq' but bootstrap/worker.ts is missing. Create it to process queued jobs.",
+/**
+ * Execute the host CLI command flow.
+ *
+ * @param argv - CLI arguments excluding the node/script prefix.
+ * @param options - Optional execution overrides for project root and output writers.
+ * @returns Exit code (0 success, non-zero failure).
+ */
+export async function runCli(argv, options = {}) {
+    const write = options.write ?? ((message) => process.stdout.write(message));
+    const writeError = options.writeError ?? ((message) => process.stderr.write(message));
+    const onTrace = createTraceListener();
+    const stdin = options.stdin ?? process.stdin;
+    const stdout = options.stdout ?? process.stdout;
+    const interactiveMode = options.interactiveMode ?? 'auto';
+    const shouldRunInteractiveMenu = argv.length === 0 &&
+        !argv.includes('--help') &&
+        (interactiveMode === 'on' ||
+            (interactiveMode === 'auto' && process.env.CI !== 'true' && process.env.LUMIS_NO_TUI !== '1' && stdin.isTTY && stdout.isTTY));
+    if (shouldRunInteractiveMenu) {
+        await emitTrace(onTrace, {
+            type: 'command-dispatch',
+            status: 'start',
+            name: 'interactive-launcher',
+            context: { mode: interactiveMode },
+        });
+        const launcherResult = await runInteractiveLauncher({
+            projectRoot: options.projectRoot ?? process.cwd(),
+            write,
+            stdin,
+            stdout,
+        });
+        if (launcherResult.kind === 'exit') {
+            await emitTrace(onTrace, {
+                type: 'command-dispatch',
+                status: launcherResult.code === 0 ? 'success' : 'failure',
+                name: 'interactive-launcher',
+                context: { exitCode: launcherResult.code },
             });
+            return launcherResult.code;
         }
-    }
-    // Stale route loader warning
-    const routesLoader = join(cwd, readStorageRoot(cwd), 'framework', 'cache', 'routes.loader.ts');
-    if (existsSync(routesLoader)) {
-        const loaderMtime = statSync(routesLoader).mtimeMs;
-        const routesRoot = join(cwd, 'src', 'modules');
-        let stale = false;
-        if (existsSync(routesRoot)) {
-            const stack = [routesRoot];
-            while (stack.length > 0) {
-                const dir = stack.pop();
-                for (const entry of readdirSync(dir, { withFileTypes: true })) {
-                    if (entry.isDirectory()) {
-                        stack.push(join(dir, entry.name));
-                        continue;
-                    }
-                    if (/\/http\/routes\/.+\.(ts|js)$/.test(join(dir, entry.name))) {
-                        if (statSync(join(dir, entry.name)).mtimeMs > loaderMtime) {
-                            stale = true;
-                            break;
-                        }
-                    }
-                }
-                if (stale)
-                    break;
-            }
-        }
-        checks.push({
-            label: 'route cache is fresh',
-            pass: !stale,
-            fix: 'Route files have changed since last cache. Run: lumis route:cache',
+        argv = launcherResult.argv;
+    }
+    if (argv.includes('--help') || argv.length === 0) {
+        await emitTrace(onTrace, {
+            type: 'command-dispatch',
+            status: 'info',
+            name: 'help',
+            context: { argvLength: argv.length },
         });
+        write(formatUsage());
+        return 0;
+    }
+    const matched = matchCommand(argv);
+    if (!matched) {
+        await emitTrace(onTrace, {
+            type: 'command-dispatch',
+            status: 'failure',
+            name: 'unknown-command',
+            message: argv.join(' '),
+        });
+        writeError(`${ansi.fail(`Unknown command: ${argv.join(' ')}`)}\n`);
+        write(formatUsage());
+        return 1;
     }
-    const warnings = checks.filter((c) => !c.pass);
-    if (warnings.length > 0) {
-        writeLine();
-        writeLine(ui.section('Health Pre-checks'));
-        for (const w of warnings) {
-            writeLine(`  ${ui.warn(w.label)}`);
-            if (w.fix)
-                writeLine(`    ${ui.dim(w.fix)}`);
-        }
-        writeLine();
-    }
-}
-function parsePort(args) {
-    const idx = args.findIndex((a) => a === '--port' || a === '-p');
-    const inline = args.find((a) => a.startsWith('--port='));
-    const raw = inline ? inline.split('=')[1] : idx !== -1 ? args[idx + 1] : undefined;
-    if (raw)
-        return parseInt(raw, 10);
-    return undefined;
-}
-function parseHost(args) {
-    const idx = args.findIndex((a) => a === '--host' || a === '-H');
-    const inline = args.find((a) => a.startsWith('--host='));
-    if (inline)
-        return inline.split('=')[1];
-    if (idx !== -1)
-        return args[idx + 1];
-    return undefined;
-}
-function parseTarget(args) {
-    const idx = args.findIndex((a) => a === '--target' || a === '--to' || a === '--t' || a === '-t');
-    const inline = args.find((a) => a.startsWith('--target=') || a.startsWith('--to=') || a.startsWith('--t='));
-    if (inline) {
-        const val = inline.slice(inline.indexOf('=') + 1);
-        if (val === 'node' || val === 'static' || val === 'cloudflare' || val === 'vercel')
-            return val;
-    }
-    if (idx !== -1) {
-        const val = args[idx + 1];
-        if (val === 'node' || val === 'static' || val === 'cloudflare' || val === 'vercel')
-            return val;
-    }
-    return undefined;
-}
-function parsePreviewTarget(args) {
-    const target = parseTarget(args);
-    if (target === 'vercel') {
-        writeError(ui.fail('`preview` does not support target "vercel". Use: lumis build --target vercel'));
-        return undefined;
-    }
-    return target;
+    await emitTrace(onTrace, {
+        type: 'command-dispatch',
+        status: 'start',
+        name: matched.command.path.join(' '),
+        context: { args: matched.args },
+    });
+    const context = await createCommandContext({
+        argv,
+        commandPath: matched.command.path,
+        commandArgs: matched.args,
+        projectRoot: options.projectRoot ?? process.cwd(),
+        write,
+        writeError,
+        ...(onTrace ? { onTrace } : {}),
+    });
+    return matched.command.handler(context);
 }
-function parseStringFlag(args, flag) {
-    const index = args.findIndex((value) => value === flag);
-    const inline = args.find((value) => value.startsWith(`${flag}=`));
-    if (inline) {
-        return inline.slice(flag.length + 1);
-    }
-    if (index !== -1) {
-        return args[index + 1];
+function isMainModule() {
+    const argv1 = process.argv[1];
+    if (!argv1) {
+        return false;
     }
-    return undefined;
+    return import.meta.url === pathToFileURL(argv1).href;
 }
-function parseRepeatedFlag(args, flag) {
-    const values = [];
-    for (let index = 0; index < args.length; index += 1) {
-        const token = args[index];
-        if (token === flag && args[index + 1]) {
-            values.push(args[index + 1]);
-        }
-        if (token?.startsWith(`${flag}=`)) {
-            values.push(token.slice(flag.length + 1));
-        }
-    }
-    return values;
+if (isMainModule()) {
+    void runCli(process.argv.slice(2));
 }
-main().then((code) => process.exit(code));
 //# sourceMappingURL=cli.js.map