sdd-cli 0.1.23 → 0.1.25

package/dist/commands/hello.js

@@ -1,7 +1,11 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runHello = runHello;
 const intent_1 = require("../router/intent");
+const path_1 = __importDefault(require("path"));
 const index_1 = require("../workspace/index");
 const prompt_1 = require("../ui/prompt");
 const prompt_packs_1 = require("../router/prompt-packs");
@@ -15,6 +19,8 @@ const route_1 = require("./route");
 const test_plan_1 = require("./test-plan");
 const local_metrics_1 = require("../telemetry/local-metrics");
 const errors_1 = require("../errors");
+const ai_autopilot_1 = require("./ai-autopilot");
+const app_lifecycle_1 = require("./app-lifecycle");
 const autopilot_checkpoint_1 = require("./autopilot-checkpoint");
 function printStep(step, description) {
     console.log(`${step}: ${description}`);
@@ -120,6 +126,7 @@ async function runHello(input, runQuestions) {
     const autoGuidedMode = !shouldRunQuestions && (runtimeFlags.nonInteractive || hasDirectIntent);
     const dryRun = runtimeFlags.dryRun;
     const beginnerMode = runtimeFlags.beginner;
+    const provider = runtimeFlags.provider;
     console.log("Hello from sdd-cli.");
     console.log(`Workspace: ${workspace.root}`);
     if (beginnerMode) {
@@ -127,6 +134,7 @@ async function runHello(input, runQuestions) {
     }
     if (autoGuidedMode) {
         printWhy("Auto-guided mode active: using current workspace defaults.");
+        printWhy(`AI provider preference: ${provider ?? "gemini"}`);
     }
     else {
         const useWorkspace = await (0, prompt_1.confirm)("Use this workspace path? (y/n) ");
@@ -288,7 +296,7 @@ async function runHello(input, runQuestions) {
                 fromStep = candidate;
             }
         }
-        const draft = buildAutopilotDraft(text, intent.flow, intent.domain);
+        const draft = (0, ai_autopilot_1.enrichDraftWithAI)(text, intent.flow, intent.domain, buildAutopilotDraft(text, intent.flow, intent.domain), provider);
         draft.project_name = activeProject;
         let reqId = checkpoint?.reqId ?? "";
         const startStep = fromStep ?? "create";
@@ -389,6 +397,50 @@ async function runHello(input, runQuestions) {
                     return;
                 }
                 (0, autopilot_checkpoint_1.clearCheckpoint)(activeProject);
+                const projectRoot = path_1.default.resolve(finished.doneDir, "..", "..", "..");
+                const codeBootstrap = (0, ai_autopilot_1.bootstrapProjectCode)(projectRoot, activeProject, text, provider);
+                if (!codeBootstrap.generated) {
+                    printWhy(`Code generation blocked: ${codeBootstrap.reason || "provider did not return valid files"}.`);
+                    printWhy("No template fallback was applied. Re-run with clearer prompt or improve provider response contract.");
+                    printRecoveryNext(activeProject, "finish", text);
+                    return;
+                }
+                printWhy(`Code scaffold ready at: ${codeBootstrap.outputDir} (${codeBootstrap.fileCount} files)`);
+                if (codeBootstrap.reason) {
+                    printWhy(`Code scaffold note: ${codeBootstrap.reason}`);
+                }
+                let lifecycle = (0, app_lifecycle_1.runAppLifecycle)(projectRoot, activeProject, {
+                    goalText: text,
+                    intentSignals: intent.signals
+                });
+                lifecycle.summary.forEach((line) => printWhy(`Lifecycle: ${line}`));
+                const lifecycleDisabled = process.env.SDD_DISABLE_APP_LIFECYCLE === "1";
+                if (!lifecycleDisabled && !lifecycle.qualityPassed) {
+                    const appDir = path_1.default.join(projectRoot, "generated-app");
+                    const parsedAttempts = Number.parseInt(process.env.SDD_AI_REPAIR_MAX_ATTEMPTS ?? "", 10);
+                    const maxRepairAttempts = Number.isFinite(parsedAttempts) && parsedAttempts > 0 ? parsedAttempts : 6;
+                    printWhy("Quality gates failed. Attempting AI repair iterations.");
+                    lifecycle.qualityDiagnostics.forEach((issue) => printWhy(`Quality issue: ${issue}`));
+                    for (let attempt = 1; attempt <= maxRepairAttempts && !lifecycle.qualityPassed; attempt += 1) {
+                        const repair = (0, ai_autopilot_1.improveGeneratedApp)(appDir, text, provider, lifecycle.qualityDiagnostics);
+                        if (repair.attempted && repair.applied) {
+                            printWhy(`AI repair attempt ${attempt} applied (${repair.fileCount} files). Re-running lifecycle checks.`);
+                            lifecycle = (0, app_lifecycle_1.runAppLifecycle)(projectRoot, activeProject, {
+                                goalText: text,
+                                intentSignals: intent.signals
+                            });
+                            lifecycle.summary.forEach((line) => printWhy(`Lifecycle (retry ${attempt}): ${line}`));
+                        }
+                        else {
+                            printWhy(`AI repair attempt ${attempt} skipped: ${repair.reason || "unknown reason"}`);
+                        }
+                    }
+                    if (!lifecycle.qualityPassed) {
+                        printWhy("Quality still failing after AI repair attempts. Stopping without template fallback.");
+                        printRecoveryNext(activeProject, "finish", text);
+                        return;
+                    }
+                }
                 (0, local_metrics_1.recordActivationMetric)("completed", {
                     project: activeProject,
                     reqId

package/dist/commands/suite.d.ts

@@ -0,0 +1 @@
+export declare function runSuite(initialInput?: string): Promise<void>;

package/dist/commands/suite.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSuite = runSuite;
+const prompt_1 = require("../ui/prompt");
+const flags_1 = require("../context/flags");
+const hello_1 = require("./hello");
+function inferAppType(text) {
+    const lower = text.toLowerCase();
+    if (/\bdesktop\b|\bwindows\b|\belectron\b/.test(lower)) {
+        return "desktop";
+    }
+    if (/\bweb\b|\bbrowser\b|\bsite\b|\bfrontend\b/.test(lower)) {
+        return "web";
+    }
+    return undefined;
+}
+function inferStack(text) {
+    const lower = text.toLowerCase();
+    if (/\btypescript\b|\bts\b/.test(lower)) {
+        return "typescript";
+    }
+    if (/\bjavascript\b|\bjs\b/.test(lower)) {
+        return "javascript";
+    }
+    return undefined;
+}
+async function resolveBlockers(input) {
+    const flags = (0, flags_1.getFlags)();
+    const nonInteractive = flags.nonInteractive;
+    const inferredType = inferAppType(input);
+    const inferredStack = inferStack(input);
+    let appType = inferredType;
+    let stack = inferredStack;
+    if (!appType) {
+        if (nonInteractive) {
+            appType = "web";
+        }
+        else {
+            const answer = (await (0, prompt_1.ask)("Blocker: app type? (web/desktop) ")).trim().toLowerCase();
+            appType = answer === "desktop" ? "desktop" : "web";
+        }
+    }
+    if (!stack) {
+        if (nonInteractive) {
+            stack = "javascript";
+        }
+        else {
+            const answer = (await (0, prompt_1.ask)("Blocker: stack? (javascript/typescript) ")).trim().toLowerCase();
+            stack = answer === "typescript" ? "typescript" : "javascript";
+        }
+    }
+    return { appType, stack };
+}
+function enrichIntent(intent, context) {
+    return `${intent}. Build target: ${context.appType}. Preferred stack: ${context.stack}. Finish complete delivery including tests and deployment notes.`;
+}
+async function runSuite(initialInput) {
+    const startedNonInteractive = (0, flags_1.getFlags)().nonInteractive;
+    console.log("SDD Suite started. Type 'exit' to close.");
+    let current = (initialInput ?? "").trim();
+    while (true) {
+        if (!current) {
+            if (startedNonInteractive) {
+                console.log("Suite finished.");
+                return;
+            }
+            current = (await (0, prompt_1.ask)("suite> ")).trim();
+        }
+        if (!current) {
+            continue;
+        }
+        if (current.toLowerCase() === "exit" || current.toLowerCase() === "quit") {
+            console.log("Suite finished.");
+            return;
+        }
+        const context = await resolveBlockers(current);
+        const enriched = enrichIntent(current, context);
+        await (0, hello_1.runHello)(enriched, false);
+        console.log("Suite task completed. Enter next instruction or 'exit'.");
+        current = "";
+    }
+}

package/dist/config/index.d.ts

@@ -0,0 +1,23 @@
+export type SddModeDefault = "guided" | "non-interactive" | "beginner";
+export type SddProviderDefault = "gemini" | "codex" | "auto";
+export type SddConfig = {
+    workspace: {
+        default_root: string;
+    };
+    ai: {
+        preferred_cli: SddProviderDefault;
+        model: string;
+    };
+    mode: {
+        default: SddModeDefault;
+    };
+    git: {
+        publish_enabled: boolean;
+    };
+};
+export declare function configPath(): string;
+export declare function defaultConfig(): SddConfig;
+export declare function loadConfig(): SddConfig;
+export declare function saveConfig(config: SddConfig): string;
+export declare function ensureConfig(): SddConfig;
+export declare function updateConfigValue(key: string, value: string): SddConfig | null;

package/dist/config/index.js

@@ -0,0 +1,209 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configPath = configPath;
+exports.defaultConfig = defaultConfig;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+exports.ensureConfig = ensureConfig;
+exports.updateConfigValue = updateConfigValue;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+function homeDocumentsDir() {
+    const home = os_1.default.homedir();
+    return path_1.default.join(home, "Documents");
+}
+function inferUserName(home) {
+    const normalized = home.replace(/\\/g, "/").split("/").filter((part) => part.length > 0);
+    return normalized.length > 0 ? normalized[normalized.length - 1] : "user";
+}
+function configPath() {
+    const override = process.env.SDD_CONFIG_PATH?.trim();
+    if (override) {
+        return path_1.default.resolve(override);
+    }
+    const root = process.env.APPDATA
+        ? path_1.default.join(process.env.APPDATA, "sdd-cli")
+        : path_1.default.join(os_1.default.homedir(), ".config", "sdd-cli");
+    return path_1.default.join(root, "config.yml");
+}
+function defaultConfig() {
+    return {
+        workspace: {
+            default_root: path_1.default.join(homeDocumentsDir(), "sdd-tool-projects")
+        },
+        ai: {
+            preferred_cli: "gemini",
+            model: "gemini-2.5-flash-lite"
+        },
+        mode: {
+            default: "guided"
+        },
+        git: {
+            publish_enabled: false
+        }
+    };
+}
+function normalizeProvider(value) {
+    const clean = value.trim().toLowerCase();
+    if (clean === "codex" || clean === "auto" || clean === "gemini") {
+        return clean;
+    }
+    return "gemini";
+}
+function normalizeMode(value) {
+    const clean = value.trim().toLowerCase();
+    if (clean === "non-interactive") {
+        return "non-interactive";
+    }
+    if (clean === "beginner") {
+        return "beginner";
+    }
+    return "guided";
+}
+function expandRoot(value) {
+    let out = value.trim();
+    const home = os_1.default.homedir();
+    const user = inferUserName(home);
+    out = out.replace(/\{\{user\}\}/gi, user);
+    out = out.replace(/\{\{home\}\}/gi, home);
+    if (out.startsWith("~/")) {
+        out = path_1.default.join(home, out.slice(2));
+    }
+    return path_1.default.resolve(out);
+}
+function parseSimpleYaml(raw) {
+    const result = {};
+    let section = "";
+    const lines = raw.split(/\r?\n/);
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith("#")) {
+            continue;
+        }
+        const sectionMatch = /^([a-zA-Z_][a-zA-Z0-9_-]*):\s*$/.exec(trimmed);
+        if (sectionMatch) {
+            section = sectionMatch[1];
+            continue;
+        }
+        const valueMatch = /^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(.+)\s*$/.exec(trimmed);
+        if (!valueMatch || !section) {
+            continue;
+        }
+        const key = valueMatch[1];
+        const value = valueMatch[2].replace(/^["']|["']$/g, "");
+        if (section === "workspace" && key === "default_root") {
+            result.workspace = { default_root: value };
+        }
+        else if (section === "ai" && key === "preferred_cli") {
+            result.ai = { ...(result.ai ?? { model: defaultConfig().ai.model }), preferred_cli: normalizeProvider(value) };
+        }
+        else if (section === "ai" && key === "model") {
+            result.ai = { ...(result.ai ?? { preferred_cli: defaultConfig().ai.preferred_cli }), model: value.trim() };
+        }
+        else if (section === "mode" && key === "default") {
+            result.mode = { default: normalizeMode(value) };
+        }
+        else if (section === "git" && key === "publish_enabled") {
+            result.git = { publish_enabled: value.trim().toLowerCase() === "true" };
+        }
+    }
+    return result;
+}
+function renderYaml(config) {
+    return [
+        "# sdd-cli configuration",
+        "# You can use {{user}} or {{home}} in workspace.default_root",
+        "workspace:",
+        `  default_root: ${config.workspace.default_root}`,
+        "ai:",
+        `  preferred_cli: ${config.ai.preferred_cli}`,
+        `  model: ${config.ai.model}`,
+        "mode:",
+        `  default: ${config.mode.default}`,
+        "git:",
+        `  publish_enabled: ${config.git.publish_enabled ? "true" : "false"}`,
+        ""
+    ].join("\n");
+}
+function mergeConfig(base, input) {
+    const root = input.workspace?.default_root ? expandRoot(input.workspace.default_root) : base.workspace.default_root;
+    return {
+        workspace: {
+            default_root: root
+        },
+        ai: {
+            preferred_cli: input.ai?.preferred_cli ? normalizeProvider(input.ai.preferred_cli) : base.ai.preferred_cli,
+            model: typeof input.ai?.model === "string" && input.ai.model.trim() ? input.ai.model.trim() : base.ai.model
+        },
+        mode: {
+            default: input.mode?.default ? normalizeMode(input.mode.default) : base.mode.default
+        },
+        git: {
+            publish_enabled: typeof input.git?.publish_enabled === "boolean" ? input.git.publish_enabled : base.git.publish_enabled
+        }
+    };
+}
+function loadConfig() {
+    const defaults = defaultConfig();
+    const file = configPath();
+    if (!fs_1.default.existsSync(file)) {
+        return defaults;
+    }
+    try {
+        const raw = fs_1.default.readFileSync(file, "utf-8");
+        return mergeConfig(defaults, parseSimpleYaml(raw));
+    }
+    catch {
+        return defaults;
+    }
+}
+function saveConfig(config) {
+    const file = configPath();
+    fs_1.default.mkdirSync(path_1.default.dirname(file), { recursive: true });
+    fs_1.default.writeFileSync(file, renderYaml(config), "utf-8");
+    return file;
+}
+function ensureConfig() {
+    const existing = loadConfig();
+    const file = configPath();
+    if (!fs_1.default.existsSync(file)) {
+        saveConfig(existing);
+    }
+    fs_1.default.mkdirSync(existing.workspace.default_root, { recursive: true });
+    return existing;
+}
+function updateConfigValue(key, value) {
+    const current = ensureConfig();
+    const next = {
+        workspace: { ...current.workspace },
+        ai: { ...current.ai },
+        mode: { ...current.mode },
+        git: { ...current.git }
+    };
+    const normalized = key.trim().toLowerCase();
+    if (normalized === "workspace.default_root") {
+        next.workspace.default_root = expandRoot(value);
+    }
+    else if (normalized === "ai.preferred_cli") {
+        next.ai.preferred_cli = normalizeProvider(value);
+    }
+    else if (normalized === "ai.model") {
+        next.ai.model = value.trim() || next.ai.model;
+    }
+    else if (normalized === "mode.default") {
+        next.mode.default = normalizeMode(value);
+    }
+    else if (normalized === "git.publish_enabled") {
+        next.git.publish_enabled = value.trim().toLowerCase() === "true";
+    }
+    else {
+        return null;
+    }
+    saveConfig(next);
+    fs_1.default.mkdirSync(next.workspace.default_root, { recursive: true });
+    return next;
+}

package/dist/context/flags.d.ts

@@ -10,6 +10,8 @@ export type RuntimeFlags = {
     output?: string;
     scope?: string;
     metricsLocal?: boolean;
+    provider?: string;
+    model?: string;
 };
 export declare function setFlags(next: Partial<RuntimeFlags>): void;
 export declare function getFlags(): RuntimeFlags;

package/dist/context/flags.js

@@ -13,7 +13,9 @@ const flags = {
     project: undefined,
     output: undefined,
     scope: undefined,
-    metricsLocal: false
+    metricsLocal: false,
+    provider: process.env.SDD_AI_PROVIDER_DEFAULT ?? "gemini",
+    model: process.env.SDD_AI_MODEL_DEFAULT
 };
 function setFlags(next) {
     if ("approve" in next) {
@@ -49,6 +51,12 @@ function setFlags(next) {
     if ("metricsLocal" in next) {
         flags.metricsLocal = Boolean(next.metricsLocal);
     }
+    if ("provider" in next) {
+        flags.provider = typeof next.provider === "string" ? next.provider : flags.provider;
+    }
+    if ("model" in next) {
+        flags.model = typeof next.model === "string" ? next.model : flags.model;
+    }
 }
 function getFlags() {
     return { ...flags };

package/dist/providers/codex.d.ts

@@ -1,7 +1,5 @@
-export type CodexResult = {
-    ok: boolean;
-    output: string;
-    error?: string;
-};
+import { AIProvider, ProviderResult } from "./types";
+export type CodexResult = ProviderResult;
 export declare function codexVersion(): CodexResult;
 export declare function codexExec(prompt: string): CodexResult;
+export declare const codexProvider: AIProvider;

package/dist/providers/codex.js

@@ -1,19 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.codexProvider = void 0;
 exports.codexVersion = codexVersion;
 exports.codexExec = codexExec;
 const child_process_1 = require("child_process");
+function resolveCommand(input) {
+    if (process.platform !== "win32") {
+        return input;
+    }
+    const looksLikePath = input.includes("\\") || input.includes("/");
+    const hasExt = /\.[A-Za-z0-9]+$/.test(input);
+    if (!looksLikePath && !hasExt) {
+        return `${input}.cmd`;
+    }
+    return input;
+}
 function codexVersion() {
-    const result = (0, child_process_1.spawnSync)("codex", ["--version"], { encoding: "utf-8" });
+    const command = resolveCommand(process.env.SDD_CODEX_BIN?.trim() || "codex");
+    const useShell = process.platform === "win32" && command.toLowerCase().endsWith(".cmd");
+    const result = (0, child_process_1.spawnSync)(command, ["--version"], {
+        encoding: "utf-8",
+        shell: useShell
+    });
     if (result.status !== 0) {
         return { ok: false, output: "", error: result.stderr || "codex not available" };
     }
     return { ok: true, output: result.stdout.trim() };
 }
 function codexExec(prompt) {
-    const result = (0, child_process_1.spawnSync)("codex", ["exec", prompt], { encoding: "utf-8" });
+    const command = resolveCommand(process.env.SDD_CODEX_BIN?.trim() || "codex");
+    const useShell = process.platform === "win32" && command.toLowerCase().endsWith(".cmd");
+    const result = useShell
+        ? (0, child_process_1.spawnSync)(`${command} exec "${prompt.replace(/"/g, "\"\"")}"`, {
+            encoding: "utf-8",
+            shell: true
+        })
+        : (0, child_process_1.spawnSync)(command, ["exec", prompt], {
+            encoding: "utf-8"
+        });
     if (result.status !== 0) {
         return { ok: false, output: result.stdout || "", error: result.stderr || "codex exec failed" };
     }
     return { ok: true, output: result.stdout.trim() };
 }
+exports.codexProvider = {
+    id: "codex",
+    label: "Codex",
+    version: codexVersion,
+    exec: codexExec
+};

package/dist/providers/gemini.d.ts

@@ -0,0 +1,5 @@
+import { AIProvider, ProviderResult } from "./types";
+export type GeminiResult = ProviderResult;
+export declare function geminiVersion(): GeminiResult;
+export declare function geminiExec(prompt: string): GeminiResult;
+export declare const geminiProvider: AIProvider;

package/dist/providers/gemini.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geminiProvider = void 0;
+exports.geminiVersion = geminiVersion;
+exports.geminiExec = geminiExec;
+const child_process_1 = require("child_process");
+function resolveCommand(input) {
+    if (process.platform !== "win32") {
+        return input;
+    }
+    const looksLikePath = input.includes("\\") || input.includes("/");
+    const hasExt = /\.[A-Za-z0-9]+$/.test(input);
+    if (!looksLikePath && !hasExt) {
+        return `${input}.cmd`;
+    }
+    return input;
+}
+function geminiVersion() {
+    const command = resolveCommand(process.env.SDD_GEMINI_BIN?.trim() || "gemini");
+    const useShell = process.platform === "win32" && command.toLowerCase().endsWith(".cmd");
+    const result = (0, child_process_1.spawnSync)(command, ["--version"], {
+        encoding: "utf-8",
+        shell: useShell
+    });
+    if (result.status !== 0) {
+        return { ok: false, output: "", error: result.stderr || "gemini not available" };
+    }
+    return { ok: true, output: result.stdout.trim() };
+}
+function geminiExec(prompt) {
+    const command = resolveCommand(process.env.SDD_GEMINI_BIN?.trim() || "gemini");
+    const model = process.env.SDD_GEMINI_MODEL?.trim();
+    const useShell = process.platform === "win32" && command.toLowerCase().endsWith(".cmd");
+    const normalizedPrompt = prompt.replace(/\r?\n/g, "\\n");
+    const env = {
+        ...process.env,
+        NO_COLOR: "1"
+    };
+    const modelArgs = model ? ["-m", model] : [];
+    const runPrimary = (withModel) => useShell
+        ? (0, child_process_1.spawnSync)(`${command} ${withModel && model ? `-m "${model.replace(/"/g, "\"\"")}" ` : ""}--prompt "${normalizedPrompt.replace(/"/g, "\"\"")}" --output-format json`, {
+            encoding: "utf-8",
+            shell: true,
+            env
+        })
+        : (0, child_process_1.spawnSync)(command, [...(withModel ? modelArgs : []), "--prompt", normalizedPrompt, "--output-format", "json"], {
+            encoding: "utf-8",
+            shell: false,
+            env
+        });
+    const runFallback = (withModel) => useShell
+        ? (0, child_process_1.spawnSync)(`${command} ${withModel && model ? `-m "${model.replace(/"/g, "\"\"")}" ` : ""}--prompt "${normalizedPrompt.replace(/"/g, "\"\"")}"`, {
+            encoding: "utf-8",
+            shell: true,
+            env
+        })
+        : (0, child_process_1.spawnSync)(command, [...(withModel ? modelArgs : []), "--prompt", normalizedPrompt], {
+            encoding: "utf-8",
+            shell: false,
+            env
+        });
+    let result = runPrimary(true);
+    if (result.status !== 0 && model) {
+        result = runPrimary(false);
+    }
+    if (result.status !== 0) {
+        result = runFallback(true);
+    }
+    if (result.status !== 0 && model) {
+        result = runFallback(false);
+    }
+    if (result.status !== 0) {
+        return { ok: false, output: result.stdout || "", error: result.stderr || "gemini exec failed" };
+    }
+    return { ok: true, output: result.stdout.trim() };
+}
+exports.geminiProvider = {
+    id: "gemini",
+    label: "Gemini",
+    version: geminiVersion,
+    exec: geminiExec
+};

package/dist/providers/index.d.ts

@@ -0,0 +1,16 @@
+import { AIProvider, ProviderId, ProviderPreference } from "./types";
+export declare function defaultProviderPreference(): ProviderPreference;
+export declare function parseProviderPreference(input?: string): ProviderPreference | null;
+export declare function listProviders(): AIProvider[];
+export type ProviderResolution = {
+    ok: true;
+    provider: AIProvider;
+    selected: ProviderId;
+    requested: ProviderPreference;
+} | {
+    ok: false;
+    requested: string;
+    reason: "invalid" | "unavailable";
+    details: string;
+};
+export declare function resolveProvider(requested?: string): ProviderResolution;