@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.18

package/dist/src/cli/prompt-utils.js

@@ -0,0 +1,155 @@
+/**
+ * Shared interactive-prompt utilities.
+ *
+ * Every readline-based prompt in the CLI MUST go through these helpers so
+ * the CLI can never hang indefinitely on a detached or unresponsive terminal.
+ * All helpers apply a hard timeout (default 60s, overridable via
+ * AIWG_PROMPT_TIMEOUT_MS) after which the prompt resolves to the supplied
+ * fallback and a visible warning is emitted.
+ *
+ * The underlying setTimeout is `.unref()`'d so a user pressing Ctrl-C mid-prompt
+ * does not keep the event loop alive for the remaining wait window.
+ *
+ * Phase 1 of the CLI Stabilization Epic (#918). Phase 3 (#920) will migrate
+ * these helpers to @clack/prompts with AbortSignal support; this file is the
+ * interim abstraction that makes both call-site cleanup and that future
+ * migration mechanical.
+ */
+import readline from 'readline';
+import * as ui from './ui.js';
+/**
+ * Resolve the prompt timeout from env. Falsy / non-numeric / non-positive
+ * values fall back to 60 seconds.
+ */
+export function promptTimeoutMs() {
+    const raw = process.env['AIWG_PROMPT_TIMEOUT_MS'];
+    const n = raw ? parseInt(raw, 10) : NaN;
+    return Number.isFinite(n) && n > 0 ? n : 60_000;
+}
+/**
+ * Create a readline interface bound to process stdio. Callers must always
+ * `rl.close()` when done.
+ */
+export function createPromptInterface() {
+    return readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+}
+/**
+ * Ask a single question with a hard timeout. On timeout, resolves to `fallback`
+ * and emits a warn-level UI message describing what default was used.
+ *
+ * The timeout timer is `.unref()`'d so the event loop can exit cleanly when
+ * the caller closes the readline interface (e.g. on Ctrl-C).
+ *
+ * Do NOT call this from multiple sites on the same readline interface
+ * concurrently — each readline interface should own exactly one in-flight
+ * prompt at a time.
+ */
+export function askWithTimeout(rl, prompt, parse, fallback, fallbackLabel, timeoutMs = promptTimeoutMs(), signal) {
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            ui.warn(`  No input within ${Math.round(timeoutMs / 1000)}s — using default: ${fallbackLabel}`);
+            cleanup();
+            resolve(fallback);
+        }, timeoutMs);
+        // Ensure the timer does not block the event loop if the readline interface
+        // is closed (e.g. user hits Ctrl-C). The callback only fires if the timer
+        // is still live and the event loop has other work.
+        timer.unref?.();
+        // Integrate with the HandlerContext.signal plumbed through in Phase 3
+        // (#920). When Ctrl-C aborts the top-level AbortController, the prompt
+        // rejects cleanly, closes the readline, and clears the timeout — no
+        // orphaned input reader, no pending timer.
+        const onAbort = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            try {
+                rl.close();
+            }
+            catch { /* already closed */ }
+            reject(signal.reason ?? new Error('Aborted'));
+        };
+        const cleanup = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener('abort', onAbort);
+        };
+        if (signal?.aborted) {
+            // Fire synchronously so the caller's try/catch sees the reject without
+            // awaiting a tick.
+            onAbort();
+            return;
+        }
+        signal?.addEventListener('abort', onAbort, { once: true });
+        rl.question(prompt, (answer) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(parse(answer));
+        });
+    });
+}
+/**
+ * Prompt for a trimmed string with timeout and default. Honors `signal` from
+ * the HandlerContext (Phase 3 #920) so Ctrl-C cancels the prompt cleanly.
+ */
+export async function askString(rl, prompt, fallback = '', signal) {
+    return askWithTimeout(rl, prompt, (a) => a.trim(), fallback, fallback || '(empty)', promptTimeoutMs(), signal);
+}
+/**
+ * Prompt for a yes/no answer with timeout and default. Answers starting with
+ * 'y' (case-insensitive) are considered yes; everything else is no. On
+ * timeout, returns `defaultValue`.
+ */
+export async function askYesNo(rl, question, defaultValue = false, signal) {
+    return askWithTimeout(rl, question, (a) => a.trim().toLowerCase().startsWith('y'), defaultValue, defaultValue ? 'yes' : 'no', promptTimeoutMs(), signal);
+}
+/**
+ * Prompt for a numeric selection from a list. Returns the selected item, or
+ * `fallback` on timeout / invalid input. If `fallback` is undefined, returns
+ * `options[0]`.
+ */
+export async function askChoice(rl, prompt, options, fallback, signal) {
+    const pick = fallback ?? options[0];
+    const label = fallback !== undefined ? String(fallback) : String(pick);
+    return askWithTimeout(rl, prompt, (answer) => {
+        const idx = parseInt(answer.trim(), 10) - 1;
+        if (!isNaN(idx) && idx >= 0 && idx < options.length)
+            return options[idx];
+        return pick;
+    }, pick, label, promptTimeoutMs(), signal);
+}
+/**
+ * Prompt for a labeled selection from a list of options. Renders each option
+ * as a numbered line before asking. Users can respond by number (1-based) or
+ * by matching the exact `label`. On timeout or invalid input, returns
+ * `fallback`.
+ *
+ * This replaces the hand-rolled number-or-name logic sprinkled across
+ * `init.ts` (provider selection) and `use.ts` (topology profile picker).
+ * POC for the prompt-library spike (#926).
+ */
+export async function listSelect(rl, prompt, options, fallback, signal) {
+    if (options.length === 0)
+        return fallback;
+    options.forEach((opt, i) => console.log(`  ${i + 1}. ${opt.label}`));
+    return askWithTimeout(rl, prompt, (answer) => {
+        const trimmed = answer.trim();
+        if (!trimmed)
+            return fallback;
+        const idx = parseInt(trimmed, 10) - 1;
+        if (!isNaN(idx) && idx >= 0 && idx < options.length)
+            return options[idx].value;
+        const match = options.find(o => o.label === trimmed);
+        return match?.value ?? fallback;
+    }, fallback, String(fallback), promptTimeoutMs(), signal);
+}
+//# sourceMappingURL=prompt-utils.js.map

package/dist/src/cli/provider-deployment-plan.js

@@ -0,0 +1,126 @@
+const DEFAULT_PROVIDER = 'claude';
+function normalizeUnique(values) {
+    const seen = new Set();
+    for (const value of values ?? []) {
+        const normalized = value.trim();
+        if (normalized.length > 0)
+            seen.add(normalized);
+    }
+    return [...seen].sort((a, b) => a.localeCompare(b));
+}
+function deployedProviders(installed) {
+    const providers = new Set();
+    for (const entry of Object.values(installed ?? {})) {
+        for (const provider of Object.keys(entry.deployedTo ?? {})) {
+            if (provider.trim().length > 0)
+                providers.add(provider);
+        }
+    }
+    return [...providers].sort((a, b) => a.localeCompare(b));
+}
+function projectCandidates(request) {
+    const requested = normalizeUnique(request.requestedProviders);
+    if (requested.length > 0)
+        return requested;
+    const supported = normalizeUnique(request.supportedProviders);
+    if (request.mode === 'use' && supported.length > 0)
+        return supported;
+    const configured = normalizeUnique(request.projectConfig?.providers);
+    if (request.mode === 'use' && configured.length > 0)
+        return configured;
+    const installed = deployedProviders(request.projectConfig?.installed);
+    if (installed.length > 0)
+        return installed;
+    return request.mode === 'use' ? [DEFAULT_PROVIDER] : [];
+}
+function globalCandidates(request) {
+    const requested = normalizeUnique(request.requestedProviders);
+    if (requested.length > 0)
+        return requested;
+    const supported = normalizeUnique(request.supportedProviders);
+    if (request.mode === 'use' && supported.length > 0)
+        return supported;
+    const installed = deployedProviders(request.userRegistry?.installed);
+    if (installed.length > 0)
+        return installed;
+    return request.mode === 'use' ? [DEFAULT_PROVIDER] : [];
+}
+function scopesFor(scope) {
+    if (scope === 'both')
+        return ['project', 'global'];
+    return [scope];
+}
+function planScope(request, scope) {
+    const candidates = scope === 'project' ? projectCandidates(request) : globalCandidates(request);
+    const installed = scope === 'project'
+        ? deployedProviders(request.projectConfig?.installed)
+        : deployedProviders(request.userRegistry?.installed);
+    const installedSet = new Set(installed);
+    const bundles = normalizeUnique(request.bundles);
+    return candidates.map((provider) => {
+        const hasProvider = installedSet.has(provider);
+        if (request.mode === 'use') {
+            return {
+                scope,
+                provider,
+                action: hasProvider ? 'updated' : 'added',
+                reason: hasProvider
+                    ? 'provider already has an AIWG deployment in this scope'
+                    : 'use mode expands the selected scope to this provider',
+                bundles,
+            };
+        }
+        if (!hasProvider) {
+            return {
+                scope,
+                provider,
+                action: 'skipped',
+                reason: 'refresh/update mode only acts on providers already installed in this scope',
+                bundles,
+            };
+        }
+        return {
+            scope,
+            provider,
+            action: 'refreshed',
+            reason: 'provider already has an AIWG deployment in this scope',
+            bundles,
+        };
+    });
+}
+export function buildProviderDeploymentPlan(request) {
+    const dryRun = request.dryRun ?? false;
+    const interactive = request.interactive ?? false;
+    const mode = request.mode;
+    const items = scopesFor(request.scope).flatMap((scope) => planScope(request, scope));
+    return {
+        mode,
+        scope: request.scope,
+        dryRun,
+        interactive,
+        upgrade: {
+            action: mode === 'use' ? 'check' : 'skip',
+            reason: mode === 'use'
+                ? 'use mode performs stale-installed CLI preflight before provider deployment'
+                : 'refresh/update mode preserves the existing provider footprint',
+        },
+        items,
+    };
+}
+export function renderProviderDeploymentPlan(plan) {
+    const header = `${plan.dryRun ? '[dry-run] ' : ''}Provider ${plan.mode} plan (${plan.scope})`;
+    const lines = [
+        header,
+        `Upgrade preflight: ${plan.upgrade.action} - ${plan.upgrade.reason}`,
+    ];
+    if (plan.items.length === 0) {
+        lines.push('No provider deployments selected.');
+        return lines.join('\n');
+    }
+    for (const item of plan.items) {
+        const bundleText = item.bundles.length > 0 ? ` bundles=${item.bundles.join(',')}` : '';
+        lines.push(`- ${item.scope}:${item.provider} ${item.action} - ${item.reason}${bundleText}`);
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=provider-deployment-plan.js.map

package/dist/src/cli/provider-resolution.js

@@ -0,0 +1,119 @@
+import { readFileSync } from 'node:fs';
+import { readAiwgConfig } from '../config/aiwg-config.js';
+import { getProviderDefinition, listProviderDefinitions, normalizeProviderDefinitionId, } from '../providers/provider-definitions.js';
+export function normalizeProviderId(provider) {
+    return normalizeProviderDefinitionId(provider);
+}
+export function capabilityProviderId(provider) {
+    if (!provider)
+        return null;
+    const definition = getProviderDefinition(provider);
+    return definition?.detection.capabilityId ?? provider;
+}
+function uniqueProviders(providers) {
+    const result = [];
+    for (const provider of providers) {
+        const normalized = normalizeProviderId(provider);
+        if (normalized && !result.includes(normalized))
+            result.push(normalized);
+    }
+    return result;
+}
+function detectProviderFromRuntimeEnv(env) {
+    const definitions = [...listProviderDefinitions()].sort((a, b) => (a.detection.runtimeEnvPriority ?? Number.MAX_SAFE_INTEGER) - (b.detection.runtimeEnvPriority ?? Number.MAX_SAFE_INTEGER));
+    for (const definition of definitions) {
+        if (definition.detection.env.some((marker) => Boolean(env[marker])))
+            return definition.id;
+    }
+    return null;
+}
+function commandMatchesProviderMarker(command, marker) {
+    const escaped = marker.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    if (marker.includes('/') || marker.includes('@'))
+        return command.includes(marker);
+    return new RegExp(`(?:^|[/\\s])${escaped}(?:$|[\\s/])`).test(command);
+}
+export function commandLooksLikeProvider(command) {
+    const lower = command.toLowerCase();
+    for (const definition of listProviderDefinitions()) {
+        if (definition.detection.process.some((marker) => commandMatchesProviderMarker(lower, marker))) {
+            return definition.id;
+        }
+    }
+    return null;
+}
+export function detectProviderFromProcessTree(pid = process.pid) {
+    let current = pid;
+    const seen = new Set();
+    for (let depth = 0; depth < 12 && current > 1 && !seen.has(current); depth += 1) {
+        seen.add(current);
+        try {
+            const stat = readFileSync(`/proc/${current}/stat`, 'utf8');
+            const end = stat.lastIndexOf(')');
+            const fields = stat.slice(end + 2).split(' ');
+            const ppid = Number(fields[1]);
+            const cmdline = readFileSync(`/proc/${current}/cmdline`, 'utf8').replace(/\0/g, ' ');
+            const provider = commandLooksLikeProvider(cmdline);
+            if (provider)
+                return provider;
+            current = Number.isFinite(ppid) ? ppid : 0;
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+export async function resolveActiveProvider(options) {
+    const env = options.env ?? process.env;
+    const explicit = normalizeProviderId(options.explicitProvider);
+    if (explicit) {
+        return { provider: explicit, source: 'explicit', candidates: [explicit], reason: '--provider supplied' };
+    }
+    const envProvider = normalizeProviderId(env.AIWG_PROVIDER ?? env.CLAUDECODE_PROVIDER);
+    if (envProvider) {
+        return { provider: envProvider, source: 'env', candidates: [envProvider], reason: 'explicit provider environment variable' };
+    }
+    const runtimeProvider = detectProviderFromRuntimeEnv(env);
+    if (runtimeProvider) {
+        return { provider: runtimeProvider, source: 'runtime-env', candidates: [runtimeProvider], reason: 'runtime environment marker' };
+    }
+    const testProcessProvider = normalizeProviderId(env.AIWG_TEST_PROCESS_PROVIDER);
+    if (testProcessProvider) {
+        return { provider: testProcessProvider, source: 'process', candidates: [testProcessProvider], reason: 'provider process ancestry' };
+    }
+    if (options.detectProcess !== false && env.AIWG_DISABLE_PROCESS_PROVIDER_DETECTION !== '1') {
+        const processProvider = detectProviderFromProcessTree();
+        if (processProvider) {
+            return { provider: processProvider, source: 'process', candidates: [processProvider], reason: 'provider process ancestry' };
+        }
+    }
+    try {
+        const config = await readAiwgConfig(options.cwd);
+        const configured = uniqueProviders(config?.providers ?? []);
+        if (configured.length === 1) {
+            return { provider: configured[0], source: 'config', candidates: configured, reason: '.aiwg/aiwg.config providers' };
+        }
+        if (configured.length > 1) {
+            return { provider: null, source: 'ambiguous', candidates: configured, reason: 'multiple configured providers' };
+        }
+        const deployed = uniqueProviders(Object.values(config?.installed ?? {}).flatMap((entry) => Object.keys(entry.deployedTo ?? {})));
+        if (deployed.length === 1) {
+            return { provider: deployed[0], source: 'deployment', candidates: deployed, reason: 'single deployed provider' };
+        }
+        if (deployed.length > 1) {
+            return { provider: null, source: 'ambiguous', candidates: deployed, reason: 'multiple deployed providers' };
+        }
+    }
+    catch {
+        // Missing or malformed project config is not fatal for provider detection.
+    }
+    const fallback = options.defaultProvider ?? null;
+    return {
+        provider: fallback,
+        source: fallback ? 'default' : 'ambiguous',
+        candidates: fallback ? [fallback] : [],
+        reason: fallback ? 'default provider' : 'no provider signal found',
+    };
+}
+//# sourceMappingURL=provider-resolution.js.map