askdb 1.0.0-beta.27 → 1.0.0-beta.30

package/dist/init.js

@@ -4,86 +4,241 @@ import { createRequire } from "node:module";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 const DEFAULT_CONFIG_PATH = "askdb.config.ts";
-/** Single template: only `askdb.config.ts` is written (kept in sync with the repo root `askdb.config.ts`). */
-const CONFIG_TEMPLATE = `import "dotenv/config";
-import { defineConfig, env, type AskDbConfig } from "@askdb/config";
-
-// \`dotenv/config\` loads a local \`.env\` when this module runs (missing file is OK).
-// CLIs call \`bootstrapAskDbEnv\`, which loads \`.env\` then evaluates this file and installs the AskDB runtime snapshot.
-// Use \`env("VAR")\` for every value read from the environment; \`flattenAskDbConfig\` applies defaults
-// for optional fields (see \`@askdb/config\` / \`defaults.ts\`).
-export default defineConfig({
-  ai: {
-    // openai | azure | foundry (foundry uses Azure-compatible env vars) | google
-    provider: "openai",
+// ---------------------------------------------------------------------------
+// Config rendering
+// ---------------------------------------------------------------------------
+/** AI provider defaults for key/model env vars */
+const AI_DEFAULTS = {
+    openai: { keyEnv: "OPENAI_API_KEY", modelEnv: "OPENAI_MODEL", modelField: "model" },
+    anthropic: { keyEnv: "ANTHROPIC_API_KEY", modelEnv: "ANTHROPIC_MODEL", modelField: "model" },
+    google: { keyEnv: "GOOGLE_GENERATIVE_AI_API_KEY", modelEnv: "GOOGLE_GENERATIVE_AI_MODEL", modelField: "model" },
+    azure: { keyEnv: "AZURE_OPENAI_API_KEY", modelEnv: "AZURE_OPENAI_DEPLOYMENT", modelField: "model" },
+    foundry: { keyEnv: "AZURE_OPENAI_API_KEY", modelEnv: "AZURE_OPENAI_DEPLOYMENT", modelField: "model" },
+};
+function renderAiSection(answers) {
+    const { aiProvider, aiKeyEnv, aiModelEnv } = answers;
+    const modelLine = aiModelEnv ? `\n        ${AI_DEFAULTS[aiProvider].modelField}: env("${aiModelEnv}"),` : "";
+    return `  ai: {
+    provider: "${aiProvider}",
     providerConfig: {
-      openai: {
-        // Live NL→SQL: set in \`.env\`, e.g. OPENAI_API_KEY=… (optional OPENAI_BASE_URL=…)
-        apiKey: env("OPENAI_API_KEY"),
-        model: env("OPENAI_MODEL"),
+      ${aiProvider}: {
+        apiKey: env("${aiKeyEnv}"),${modelLine}
       },
     },
-  },
-
-  introspection: {
-    // postgres | prisma | mysql | sqlite | sqlserver
+  },`;
+}
+function renderIntrospectionSection(answers) {
+    const { database, connectionEnv, sqliteFile, prismaSchema, schemaOut } = answers;
+    const outputDirLine = `\n    outputDir: "${schemaOut}",`;
+    switch (database) {
+        case "postgres":
+            return `  introspection: {
     provider: "postgres",
     providerConfig: {
       postgres: {
-        // Postgres URL for \`askdb introspect\` — maps to ASKDB_INTROSPECT_POSTGRES_URL
-        databaseUrl: env("DATABASE_URL"),
+        databaseUrl: env("${connectionEnv ?? "DATABASE_URL"}"),
       },
-    },
-    // Default Schema v2 output when you omit \`askdb introspect --out\` (maps to ASKDB_INTROSPECT_OUT)
-    outputDir: env("MY_INTROSPECT_OUTPUT_DIR"),
-  },
-
-  rag: {
-    // mock | openai | ai-sdk — optional: MY_RAG_EMBEDDER in \`.env\`
-    embedder: "openai",
-    embedderConfig: {
-      openai: {
-        model: env("ASKDB_RAG_EMBEDDER_MODEL"),
-        dimension: env("ASKDB_RAG_EMBEDDER_DIMENSIONS"),
-        apiKey: env("OPENAI_API_KEY"),
-        baseUrl: env("ASKDB_RAG_EMBEDDER_BASE_URL"),
+    },${outputDirLine}
+  },`;
+        case "mysql":
+            return `  introspection: {
+    provider: "mysql",
+    providerConfig: {
+      mysql: {
+        databaseUrl: env("${connectionEnv ?? "DATABASE_URL"}"),
       },
-    },
-    // file | memory | pgvector — optional: ASKDB_PGVECTOR_URL for pgvector (e.g. port 5434 fixture)
+    },${outputDirLine}
+  },`;
+        case "sqlite": {
+            const fileExpr = sqliteFile && !sqliteFile.startsWith("./") && !sqliteFile.startsWith("/")
+                ? `env("${sqliteFile}")`
+                : `env("SQLITE_FILE")`;
+            const resolvedFile = sqliteFile && (sqliteFile.startsWith("./") || sqliteFile.startsWith("/"))
+                ? `"${sqliteFile}"`
+                : fileExpr;
+            return `  introspection: {
+    provider: "sqlite",
+    providerConfig: {
+      sqlite: {
+        file: ${resolvedFile},
+      },
+    },${outputDirLine}
+  },`;
+        }
+        case "sqlserver":
+            return `  introspection: {
+    provider: "sqlserver",
+    providerConfig: {
+      sqlserver: {
+        databaseUrl: env("${connectionEnv ?? "SQLSERVER_URL"}"),
+      },
+    },${outputDirLine}
+  },`;
+        case "prisma": {
+            const schemaLine = prismaSchema ? `\n        schemaPath: "${prismaSchema}",` : "";
+            return `  introspection: {
+    provider: "prisma",
+    providerConfig: {
+      prisma: {${schemaLine}
+      },
+    },${outputDirLine}
+  },`;
+        }
+    }
+}
+function renderRagSection(answers) {
+    const { ragStore, pgvectorEnv } = answers;
+    switch (ragStore) {
+        case "file":
+            return `  rag: {
+    embedder: "mock",
+    embedderConfig: {},
     store: "file",
     storeConfig: {
       file: {},
+    },
+  },`;
+        case "memory":
+            return `  rag: {
+    embedder: "mock",
+    embedderConfig: {},
+    store: "memory",
+    storeConfig: {
       memory: {},
+    },
+  },`;
+        case "pgvector":
+            return `  rag: {
+    embedder: "mock",
+    embedderConfig: {},
+    store: "pgvector",
+    storeConfig: {
       pgvector: {
-        databaseUrl: env("ASKDB_PGVECTOR_URL"),
-        dimensions: env("ASKDB_RAG_EMBEDDER_DIMENSIONS"),
+        databaseUrl: env("${pgvectorEnv ?? "ASKDB_PGVECTOR_URL"}"),
       },
     },
-  },
-  logging: {
-    correlationId: env("ASKDB_CORRELATION_ID"),
-  },
-  dev: {
-    mockSql: env("ASKDB_MOCK_SQL"),
-  },
-  studio: {
-    listen: {
-      host: env("ASKDB_STUDIO_HOST"),
-      ...(env("ASKDB_STUDIO_PORT") ? { port: Number(env("ASKDB_STUDIO_PORT")) } : {}),
-    },
+  },`;
+    }
+}
+function renderStudioSection(answers) {
+    const { studioExecute } = answers;
+    if (!studioExecute.enabled)
+        return null;
+    const { provider } = studioExecute;
+    if (provider === "sqlite") {
+        const fileExpr = studioExecute.sqliteFile && (studioExecute.sqliteFile.startsWith("./") || studioExecute.sqliteFile.startsWith("/"))
+            ? `"${studioExecute.sqliteFile}"`
+            : `env("${studioExecute.sqliteFile ?? "SQLITE_FILE"}")`;
+        return `  studio: {
     execute: {
-      // Connection URL for the Studio playground query runner (maps to ASKDB_STUDIO_DATABASE_URL)
-      databaseUrl: env("DATABASE_URL"),
+      provider: "sqlite",
+      file: ${fileExpr},
     },
-  },
-  httpApi: {
-    listen: {
-      host: env("HOST"),
-      ...(env("PORT") ? { port: Number(env("PORT")) } : {}),
+  },`;
+    }
+    const urlEnv = studioExecute.connectionEnv ?? (provider === "sqlserver" ? "SQLSERVER_URL" : "DATABASE_URL");
+    return `  studio: {
+    execute: {
+      provider: "${provider}",
+      databaseUrl: env("${urlEnv}"),
     },
-  },
+  },`;
+}
+export function renderInitConfig(answers) {
+    const sections = [
+        renderAiSection(answers),
+        renderIntrospectionSection(answers),
+        renderRagSection(answers),
+    ];
+    const studio = renderStudioSection(answers);
+    if (studio)
+        sections.push(studio);
+    return `import dotenv from "dotenv";
+import { defineConfig, env, type AskDbConfig } from "@askdb/config";
+
+dotenv.config({ quiet: true });
+
+export default defineConfig({
+${sections.join("\n")}
 } satisfies AskDbConfig);
 `;
+}
+export function resolveDefaultInitAnswers(overrides = {}) {
+    const database = overrides.database ?? "postgres";
+    const aiProvider = overrides.aiProvider ?? "openai";
+    const aiDefaults = AI_DEFAULTS[aiProvider];
+    let connectionEnv = overrides.connectionEnv;
+    if (!connectionEnv) {
+        if (database === "sqlserver")
+            connectionEnv = "SQLSERVER_URL";
+        else if (database === "sqlite")
+            connectionEnv = undefined;
+        else
+            connectionEnv = "DATABASE_URL";
+    }
+    const studioEnabled = overrides.studioExecute ?? false;
+    let studioExecute;
+    if (studioEnabled) {
+        const execProvider = overrides.studioExecuteProvider ??
+            (database !== "prisma" ? database : "postgres");
+        studioExecute = {
+            enabled: true,
+            provider: execProvider,
+            connectionEnv: overrides.studioExecuteConnectionEnv ?? (execProvider === "sqlite" ? undefined : (execProvider === "sqlserver" ? "SQLSERVER_URL" : "DATABASE_URL")),
+            sqliteFile: overrides.studioExecuteSqliteFile ?? (execProvider === "sqlite" ? overrides.sqliteFile : undefined),
+        };
+    }
+    else {
+        studioExecute = { enabled: false };
+    }
+    return {
+        database,
+        connectionEnv,
+        sqliteFile: overrides.sqliteFile,
+        prismaSchema: overrides.prismaSchema,
+        schemaOut: overrides.schemaOut ?? "./askdb",
+        aiProvider,
+        aiKeyEnv: overrides.aiKeyEnv ?? aiDefaults.keyEnv,
+        aiModelEnv: overrides.aiModelEnv ?? aiDefaults.modelEnv,
+        ragStore: overrides.ragStore ?? "file",
+        pgvectorEnv: overrides.pgvectorEnv,
+        studioExecute,
+    };
+}
+/** Package maps — names come from an allowlist, not from user input */
+const DB_DRIVER_PACKAGES = {
+    postgres: "pg",
+    mysql: "mysql2",
+    sqlite: "better-sqlite3",
+    sqlserver: "mssql",
+};
+export function buildInitInstallPlan(answers, specs) {
+    const packages = [
+        `@askdb/config@${specs.configSpec}`,
+        `dotenv@${specs.dotenvSpec}`,
+    ];
+    const labels = ["@askdb/config", "dotenv"];
+    const driversNeeded = new Set();
+    // Live DB driver for introspection
+    if (answers.database !== "prisma") {
+        driversNeeded.add(answers.database);
+    }
+    // Live DB driver for Studio execute
+    if (answers.studioExecute.enabled) {
+        driversNeeded.add(answers.studioExecute.provider);
+    }
+    for (const db of driversNeeded) {
+        const pkg = DB_DRIVER_PACKAGES[db];
+        if (pkg) {
+            packages.push(pkg);
+            labels.push(pkg);
+        }
+    }
+    return { packages, labels };
+}
+// ---------------------------------------------------------------------------
+// Package manager detection
+// ---------------------------------------------------------------------------
 const require = createRequire(import.meta.url);
 /** Walk upward from `startDir` to find a directory containing `package.json`. */
 export function findNearestPackageJsonDir(startDir) {
@@ -145,7 +300,7 @@ export function resolveInitDepSpecs() {
             configSpec = "latest";
         }
     }
-    let dotenvSpec = "^16.6.1";
+    let dotenvSpec = "^17.4.2";
     try {
         const cfgPkgPath = require.resolve("@askdb/config/package.json");
         const cfg = JSON.parse(readFileSync(cfgPkgPath, "utf8"));
@@ -157,13 +312,7 @@ export function resolveInitDepSpecs() {
     }
     return { configSpec, dotenvSpec };
 }
-function formatDepArgs(specs) {
-    const configArg = `@askdb/config@${specs.configSpec}`;
-    const dotenvArg = `dotenv@${specs.dotenvSpec}`;
-    return [configArg, dotenvArg];
-}
-function runPackageManagerInstall(pm, packageDir, specs) {
-    const [c, d] = formatDepArgs(specs);
+function defaultInstaller(pm, packageDir, packages) {
     const env = { ...process.env, CI: process.env.CI ?? "true" };
     const win = process.platform === "win32";
     let cmd;
@@ -171,24 +320,389 @@ function runPackageManagerInstall(pm, packageDir, specs) {
     switch (pm) {
         case "pnpm":
             cmd = win ? "pnpm.CMD" : "pnpm";
-            args = ["add", c, d];
+            args = ["add", ...packages];
             break;
         case "yarn":
             cmd = win ? "yarn.cmd" : "yarn";
-            args = ["add", c, d];
+            args = ["add", ...packages];
             break;
         case "bun":
             cmd = win ? "bun.exe" : "bun";
-            args = ["add", c, d];
+            args = ["add", ...packages];
             break;
         default:
             cmd = win ? "npm.cmd" : "npm";
-            args = ["install", "--save", c, d];
+            args = ["install", "--save", ...packages];
     }
     const r = spawnSync(cmd, args, { cwd: packageDir, stdio: "inherit", env, shell: false });
     return r.status === 0;
 }
-export function runInitCli(argv) {
+function formatManualInstallCommand(pm, packages) {
+    const pkgList = packages.join(" ");
+    switch (pm) {
+        case "pnpm":
+            return `pnpm add ${pkgList}`;
+        case "yarn":
+            return `yarn add ${pkgList}`;
+        case "bun":
+            return `bun add ${pkgList}`;
+        default:
+            return `npm install --save ${pkgList}`;
+    }
+}
+const VALID_DATABASES = ["postgres", "mysql", "sqlite", "sqlserver", "prisma"];
+const VALID_AI_PROVIDERS = ["openai", "anthropic", "google", "azure", "foundry"];
+const VALID_RAG_STORES = ["file", "memory", "pgvector"];
+function parseOptions(argv) {
+    const opts = {
+        force: false,
+        path: DEFAULT_CONFIG_PATH,
+        skipInstall: false,
+        yes: false,
+        interactive: undefined,
+        noInteractive: false,
+    };
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        switch (arg) {
+            case "--force":
+            case "-f":
+                opts.force = true;
+                break;
+            case "--skip-install":
+                opts.skipInstall = true;
+                break;
+            case "--yes":
+            case "-y":
+                opts.yes = true;
+                break;
+            case "--interactive":
+                opts.interactive = true;
+                break;
+            case "--no-interactive":
+                opts.noInteractive = true;
+                break;
+            case "--studio-execute":
+                opts.studioExecute = true;
+                break;
+            case "--no-studio-execute":
+                opts.studioExecute = false;
+                break;
+            case "--path": {
+                const value = argv[++i];
+                if (!value || value.startsWith("--"))
+                    throw new Error(`${arg} requires a value.`);
+                opts.path = value;
+                break;
+            }
+            case "--database": {
+                const value = argv[++i];
+                if (!value || value.startsWith("--"))
+                    throw new Error(`${arg} requires a value.`);
+                if (!VALID_DATABASES.includes(value)) {
+                    throw new Error(`${arg}: invalid value "${value}". Allowed: ${VALID_DATABASES.join(", ")}.`);
+                }
+                opts.database = value;
+                break;
+            }
+            case "--connection-env": {
+                const value = argv[++i];
+                if (!value || value.startsWith("--"))
+                    throw new Error(`${arg} requires a value.`);
+                opts.connectionEnv = value;
+                break;
+            }
+            case "--sqlite-file": {
+                const value = argv[++i];
+                if (!value || value.startsWith("--"))
+                    throw new Error(`${arg} requires a value.`);
+                opts.sqliteFile = value;
+                break;
+            }
+            case "--prisma-schema": {
+                const value = argv[++i];
+                if (!value || value.startsWith("--"))
+                    throw new Error(`${arg} requires a value.`);
+                opts.prismaSchema = value;
+                break;
+            }
+            case "--schema-out": {
+                const value = argv[++i];
+                if (!value || value.startsWith("--"))
+                    throw new Error(`${arg} requires a value.`);
+                opts.schemaOut = value;
+                break;
+            }
+            case "--ai-provider": {
+                const value = argv[++i];
+                if (!value || value.startsWith("--"))
+                    throw new Error(`${arg} requires a value.`);
+                if (!VALID_AI_PROVIDERS.includes(value)) {
+                    throw new Error(`${arg}: invalid value "${value}". Allowed: ${VALID_AI_PROVIDERS.join(", ")}.`);
+                }
+                opts.aiProvider = value;
+                break;
+            }
+            case "--ai-key-env": {
+                const value = argv[++i];
+                if (!value || value.startsWith("--"))
+                    throw new Error(`${arg} requires a value.`);
+                opts.aiKeyEnv = value;
+                break;
+            }
+            case "--ai-model-env": {
+                const value = argv[++i];
+                if (!value || value.startsWith("--"))
+                    throw new Error(`${arg} requires a value.`);
+                opts.aiModelEnv = value;
+                break;
+            }
+            case "--rag-store": {
+                const value = argv[++i];
+                if (!value || value.startsWith("--"))
+                    throw new Error(`${arg} requires a value.`);
+                if (!VALID_RAG_STORES.includes(value)) {
+                    throw new Error(`${arg}: invalid value "${value}". Allowed: ${VALID_RAG_STORES.join(", ")}.`);
+                }
+                opts.ragStore = value;
+                break;
+            }
+            case "--pgvector-env": {
+                const value = argv[++i];
+                if (!value || value.startsWith("--"))
+                    throw new Error(`${arg} requires a value.`);
+                opts.pgvectorEnv = value;
+                break;
+            }
+            case "--help":
+            case "-h":
+                opts.path = "--help";
+                return opts;
+            default:
+                throw new Error(`Unknown option: ${arg}`);
+        }
+    }
+    // Conflict checks
+    if (opts.yes && opts.interactive) {
+        throw new Error("--yes and --interactive cannot be used together.");
+    }
+    if (opts.interactive && opts.noInteractive) {
+        throw new Error("--interactive and --no-interactive cannot be used together.");
+    }
+    return opts;
+}
+// ---------------------------------------------------------------------------
+// TTY wizard
+// ---------------------------------------------------------------------------
+const ENV_VAR_RE = /^[A-Z_][A-Z0-9_]*$/i;
+function validateEnvVar(value) {
+    if (!value.trim())
+        return "Cannot be empty.";
+    if (!ENV_VAR_RE.test(value.trim()))
+        return "Use only letters, digits, and underscores (e.g. DATABASE_URL).";
+    return true;
+}
+function validatePath(value) {
+    if (!value.trim())
+        return "Cannot be empty.";
+    return true;
+}
+async function runWizard(prompter) {
+    const database = await prompter.select({
+        message: "Database source",
+        choices: [
+            { name: "PostgreSQL", value: "postgres" },
+            { name: "MySQL", value: "mysql" },
+            { name: "SQLite", value: "sqlite" },
+            { name: "SQL Server", value: "sqlserver" },
+            { name: "Prisma (schema file, no live DB)", value: "prisma" },
+        ],
+        default: "postgres",
+    });
+    let connectionEnv;
+    let sqliteFile;
+    let prismaSchema;
+    if (database === "sqlite") {
+        const raw = await prompter.input({
+            message: "SQLite file path or env var name (e.g. ./data/app.db or SQLITE_FILE)",
+            default: "SQLITE_FILE",
+        });
+        const trimmed = raw.trim();
+        if (trimmed.startsWith("./") || trimmed.startsWith("/")) {
+            sqliteFile = trimmed;
+        }
+        else {
+            sqliteFile = trimmed;
+        }
+    }
+    else if (database === "prisma") {
+        prismaSchema = await prompter.input({
+            message: "Path to schema.prisma",
+            default: "./prisma/schema.prisma",
+            validate: validatePath,
+        });
+    }
+    else {
+        const defaultEnv = database === "sqlserver" ? "SQLSERVER_URL" : "DATABASE_URL";
+        connectionEnv = await prompter.input({
+            message: `Env var name for connection URL`,
+            default: defaultEnv,
+            validate: validateEnvVar,
+        });
+    }
+    const schemaOut = await prompter.input({
+        message: "Schema output directory",
+        default: "./askdb",
+        validate: validatePath,
+    });
+    const aiProvider = await prompter.select({
+        message: "AI provider",
+        choices: [
+            { name: "OpenAI", value: "openai" },
+            { name: "Anthropic", value: "anthropic" },
+            { name: "Google (Gemini)", value: "google" },
+            { name: "Azure OpenAI", value: "azure" },
+            { name: "Azure AI Foundry", value: "foundry" },
+        ],
+        default: "openai",
+    });
+    const aiKeyEnv = await prompter.input({
+        message: `Env var for ${aiProvider} API key`,
+        default: AI_DEFAULTS[aiProvider].keyEnv,
+        validate: validateEnvVar,
+    });
+    const aiModelEnv = await prompter.input({
+        message: `Env var for ${aiProvider} model (leave blank to use provider default)`,
+        default: AI_DEFAULTS[aiProvider].modelEnv,
+    });
+    const ragStore = await prompter.select({
+        message: "RAG store",
+        choices: [
+            { name: "File (default, no setup required)", value: "file" },
+            { name: "Memory (fast, non-persistent)", value: "memory" },
+            { name: "pgvector (Postgres vector store)", value: "pgvector" },
+        ],
+        default: "file",
+    });
+    let pgvectorEnv;
+    if (ragStore === "pgvector") {
+        pgvectorEnv = await prompter.input({
+            message: "Env var for pgvector connection URL",
+            default: "ASKDB_PGVECTOR_URL",
+            validate: validateEnvVar,
+        });
+    }
+    const studioExecuteDefault = database !== "prisma";
+    const enableStudioExecute = await prompter.confirm({
+        message: "Enable Studio execute (run queries from the browser playground)?",
+        default: studioExecuteDefault,
+    });
+    let studioExecute;
+    if (!enableStudioExecute) {
+        studioExecute = { enabled: false };
+    }
+    else if (database === "prisma") {
+        // Prisma: need to choose a live provider
+        const execProvider = await prompter.select({
+            message: "Studio execute needs a live database provider. Which one?",
+            choices: [
+                { name: "PostgreSQL", value: "postgres" },
+                { name: "MySQL", value: "mysql" },
+                { name: "SQLite", value: "sqlite" },
+                { name: "SQL Server", value: "sqlserver" },
+            ],
+            default: "postgres",
+        });
+        if (execProvider === "sqlite") {
+            const execSqliteFile = await prompter.input({
+                message: "SQLite file path or env var name for Studio execute",
+                default: "SQLITE_FILE",
+            });
+            studioExecute = {
+                enabled: true,
+                provider: "sqlite",
+                sqliteFile: execSqliteFile.trim(),
+            };
+        }
+        else {
+            const execEnv = execProvider === "sqlserver" ? "SQLSERVER_URL" : "DATABASE_URL";
+            const execConnEnv = await prompter.input({
+                message: `Env var for Studio execute connection URL`,
+                default: execEnv,
+                validate: validateEnvVar,
+            });
+            studioExecute = {
+                enabled: true,
+                provider: execProvider,
+                connectionEnv: execConnEnv,
+            };
+        }
+    }
+    else {
+        const execProvider = database;
+        if (execProvider === "sqlite") {
+            studioExecute = {
+                enabled: true,
+                provider: "sqlite",
+                sqliteFile: sqliteFile,
+            };
+        }
+        else {
+            studioExecute = {
+                enabled: true,
+                provider: execProvider,
+                connectionEnv: connectionEnv,
+            };
+        }
+    }
+    return {
+        database,
+        connectionEnv,
+        sqliteFile,
+        prismaSchema,
+        schemaOut,
+        aiProvider,
+        aiKeyEnv,
+        aiModelEnv: aiModelEnv.trim() || undefined,
+        ragStore,
+        pgvectorEnv,
+        studioExecute,
+    };
+}
+// ---------------------------------------------------------------------------
+// Real Inquirer prompter
+// ---------------------------------------------------------------------------
+async function buildInquirerPrompter() {
+    const { select, input, confirm } = await import("@inquirer/prompts");
+    return {
+        select: (opts) => select({ message: opts.message, choices: opts.choices, default: opts.default }),
+        input: (opts) => input({ message: opts.message, default: opts.default, validate: opts.validate }),
+        confirm: (opts) => confirm({ message: opts.message, default: opts.default }),
+    };
+}
+// ---------------------------------------------------------------------------
+// Next steps printer
+// ---------------------------------------------------------------------------
+function printNextSteps(answers) {
+    const lines = ["\nNext steps:"];
+    lines.push("  1. Set env vars to match the `env(\"...\")` calls in askdb.config.ts.");
+    if (answers.database !== "prisma") {
+        lines.push("  2. Introspect your database:  askdb introspect");
+    }
+    else {
+        lines.push("  2. Introspect your Prisma schema:  askdb introspect");
+    }
+    if (answers.studioExecute.enabled) {
+        lines.push("  3. Open Studio:  askdb studio");
+    }
+    lines.push(`  ${answers.studioExecute.enabled ? "4" : "3"}. Ask a question:  askdb ask --question "Which customers signed up last week?"`);
+    process.stdout.write(lines.join("\n") + "\n");
+}
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+export async function runInitCli(argv, _installer) {
+    const installer = _installer ?? defaultInstaller;
     let opts;
     try {
         opts = parseOptions(argv);
@@ -198,7 +712,7 @@ export function runInitCli(argv) {
         process.stderr.write(`${msg}\n`);
         return 1;
     }
-    if (opts.path === "--help" || opts.path === "-h") {
+    if (opts.path === "--help") {
         printHelp();
         return 0;
     }
@@ -209,101 +723,155 @@ export function runInitCli(argv) {
             `Use \`askdb init --force\` to overwrite.\n`);
         return 1;
     }
+    // Determine interactive mode
+    const isTTY = Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY);
+    const wantInteractive = opts.interactive === true || (!opts.yes && !opts.noInteractive && isTTY);
+    if (opts.interactive && !isTTY) {
+        process.stderr.write("--interactive requires stdin and stdout to be TTYs.\n");
+        return 1;
+    }
+    let answers;
+    if (wantInteractive) {
+        let prompter;
+        try {
+            prompter = await buildInquirerPrompter();
+        }
+        catch {
+            process.stderr.write("Failed to load @inquirer/prompts. Falling back to non-interactive mode.\n");
+            answers = resolveDefaultInitAnswers(optsToOverrides(opts));
+            return await finishInit(configTarget, answers, opts, installer);
+        }
+        let wizardResult;
+        try {
+            wizardResult = await runWizard(prompter);
+        }
+        catch {
+            process.stderr.write("\nSetup cancelled.\n");
+            return 1;
+        }
+        if (!wizardResult) {
+            process.stderr.write("\nSetup cancelled.\n");
+            return 1;
+        }
+        answers = wizardResult;
+        // Summary and confirmation
+        const specs = resolveInitDepSpecs();
+        const plan = buildInitInstallPlan(answers, specs);
+        process.stdout.write("\n--- Summary ---\n");
+        process.stdout.write(`  Config path:   ${configTarget}\n`);
+        process.stdout.write(`  Database:      ${answers.database}\n`);
+        process.stdout.write(`  AI provider:   ${answers.aiProvider}\n`);
+        process.stdout.write(`  RAG store:     ${answers.ragStore}\n`);
+        process.stdout.write(`  Studio execute: ${answers.studioExecute.enabled ? `enabled (${answers.studioExecute.provider})` : "disabled"}\n`);
+        if (!opts.skipInstall) {
+            process.stdout.write(`  Packages:      ${plan.labels.join(", ")}\n`);
+        }
+        process.stdout.write("---------------\n\n");
+        let confirmed;
+        try {
+            confirmed = await prompter.confirm({ message: "Write config and install packages?", default: true });
+        }
+        catch {
+            process.stderr.write("\nSetup cancelled.\n");
+            return 1;
+        }
+        if (!confirmed) {
+            process.stdout.write("Cancelled. No files written.\n");
+            return 1;
+        }
+    }
+    else {
+        answers = resolveDefaultInitAnswers(optsToOverrides(opts));
+    }
+    return await finishInit(configTarget, answers, opts, installer);
+}
+function optsToOverrides(opts) {
+    return {
+        database: opts.database,
+        connectionEnv: opts.connectionEnv,
+        sqliteFile: opts.sqliteFile,
+        prismaSchema: opts.prismaSchema,
+        schemaOut: opts.schemaOut,
+        aiProvider: opts.aiProvider,
+        aiKeyEnv: opts.aiKeyEnv,
+        aiModelEnv: opts.aiModelEnv,
+        ragStore: opts.ragStore,
+        pgvectorEnv: opts.pgvectorEnv,
+        studioExecute: opts.studioExecute,
+    };
+}
+async function finishInit(configTarget, answers, opts, installer) {
+    const configContent = renderInitConfig(answers);
     try {
-        writeFileSync(configTarget, CONFIG_TEMPLATE, { encoding: "utf8" });
+        writeFileSync(configTarget, configContent, { encoding: "utf8" });
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
-        process.stderr.write(`Failed to write init template: ${msg}\n`);
+        process.stderr.write(`Failed to write config: ${msg}\n`);
         return 1;
     }
     process.stdout.write(`Wrote:\n  - ${configTarget}\n`);
     if (!opts.skipInstall) {
         const pkgRoot = findNearestPackageJsonDir(process.cwd());
         const specs = resolveInitDepSpecs();
-        const [cArg, dArg] = formatDepArgs(specs);
+        const plan = buildInitInstallPlan(answers, specs);
         if (!pkgRoot) {
             process.stdout.write("\nNo package.json found in this directory or any parent directory.\n" +
                 "Install the template imports yourself (from a project with a package.json):\n" +
-                `  npm install --save ${cArg} ${dArg}\n\n`);
+                `  npm install --save ${plan.packages.join(" ")}\n\n`);
         }
         else if (isLikelyWorkspaceRoot(pkgRoot)) {
             process.stdout.write("\nSkipped automatic dependency install (workspace / monorepo root).\n" +
                 "Add these to the package that will load this config (or run `askdb init` from that package directory):\n" +
-                `  npm install --save ${cArg} ${dArg}\n\n`);
+                `  npm install --save ${plan.packages.join(" ")}\n\n`);
         }
         else {
             const pm = detectPackageManager(pkgRoot);
-            process.stdout.write(`\nInstalling template dependencies with ${pm} in ${pkgRoot} …\n`);
-            const ok = runPackageManagerInstall(pm, pkgRoot, specs);
+            process.stdout.write(`\nInstalling dependencies with ${pm} in ${pkgRoot} …\n`);
+            const ok = installer(pm, pkgRoot, plan.packages);
             if (!ok) {
-                process.stderr.write("Dependency install failed. The config file was written, but @askdb/config and dotenv are not installed yet.\n" +
+                process.stderr.write("Dependency install failed. The config file was written, but packages are not installed yet.\n" +
                     `  cd ${pkgRoot}\n` +
-                    `  ${formatManualInstallCommand(pm, specs)}\n`);
+                    `  ${formatManualInstallCommand(pm, plan.packages)}\n`);
                 return 1;
             }
-            process.stdout.write("Installed @askdb/config and dotenv.\n");
+            process.stdout.write(`Installed: ${plan.labels.join(", ")}.\n`);
         }
     }
-    process.stdout.write("\nNext steps:\n" +
-        "  1. Create a `.env` (optional) or export variables to match the `env(\"...\")` calls in this file — see the header comment for examples.\n" +
-        "  2. For live NL→SQL, set an OpenAI-compatible key (or use ASKDB_MOCK_SQL in tests).\n" +
-        "  3. For a Schema v2 directory from Postgres/Prisma: `askdb introspect ...` (see --help). With MY_INTROSPECT_OUTPUT_DIR / ASKDB_INTROSPECT_OUT you can omit `--out` when a default output dir is set.\n" +
-        "  4. With an existing schema artifact: `askdb ask --schema <path> --question \"...\"`.\n");
+    printNextSteps(answers);
     return 0;
 }
-function formatManualInstallCommand(pm, specs) {
-    const [c, d] = formatDepArgs(specs);
-    switch (pm) {
-        case "pnpm":
-            return `pnpm add ${c} ${d}`;
-        case "yarn":
-            return `yarn add ${c} ${d}`;
-        case "bun":
-            return `bun add ${c} ${d}`;
-        default:
-            return `npm install --save ${c} ${d}`;
-    }
-}
-function parseOptions(argv) {
-    const opts = { force: false, path: DEFAULT_CONFIG_PATH, skipInstall: false };
-    for (let i = 0; i < argv.length; i += 1) {
-        const arg = argv[i];
-        switch (arg) {
-            case "--force":
-            case "-f":
-                opts.force = true;
-                break;
-            case "--skip-install":
-                opts.skipInstall = true;
-                break;
-            case "--path": {
-                const value = argv[++i];
-                if (!value || value.startsWith("--")) {
-                    throw new Error(`${arg} requires a value.`);
-                }
-                opts.path = value;
-                break;
-            }
-            case "--help":
-            case "-h":
-                opts.path = "--help";
-                return opts;
-            default:
-                throw new Error(`Unknown option: ${arg}`);
-        }
-    }
-    return opts;
-}
 function printHelp() {
     process.stdout.write([
-        "askdb init - Create askdb.config.ts (nested defineConfig template with env() examples and .env guidance in comments)",
+        "askdb init - Create askdb.config.ts tailored to your database and AI provider",
         "",
         "Usage:",
-        "  askdb init                    Create ./askdb.config.ts (refuses to overwrite unless --force)",
+        "  askdb init                    Start wizard in a TTY, or use defaults in CI",
+        "  askdb init --yes              Accept defaults without prompts",
+        "  askdb init --no-interactive   Same as --yes",
         "  askdb init --force            Overwrite an existing askdb.config.ts",
-        "  askdb init --path <file>      Write the template to a custom file path",
-        "  askdb init --skip-install     Only write askdb.config.ts (do not install @askdb/config / dotenv)",
+        "  askdb init --path <file>      Write config to a custom file path",
+        "  askdb init --skip-install     Only write the file; do not install packages",
+        "",
+        "Database options:",
+        "  --database <db>               postgres|mysql|sqlite|sqlserver|prisma (default: postgres)",
+        "  --connection-env <name>       Env var name for connection URL",
+        "  --sqlite-file <path-or-env>   SQLite file path or env var name",
+        "  --prisma-schema <path>        Path to schema.prisma",
+        "  --schema-out <dir>            Schema output directory (default: ./askdb)",
+        "",
+        "AI options:",
+        "  --ai-provider <name>          openai|anthropic|google|azure|foundry (default: openai)",
+        "  --ai-key-env <name>           Env var name for API key",
+        "  --ai-model-env <name>         Env var name for model override",
+        "",
+        "RAG options:",
+        "  --rag-store <name>            file|memory|pgvector (default: file)",
+        "  --pgvector-env <name>         Env var name for pgvector URL",
+        "",
+        "Studio options:",
+        "  --studio-execute              Enable Studio execute (default: off)",
+        "  --no-studio-execute           Disable Studio execute",
         "",
     ].join("\n"));
 }