create-oke 0.10.3 → 0.11.0

package/src/customize-flow.test.ts

@@ -1,13 +1,12 @@
 /**
- * Unit tests for local|docker customize assembly (no Clack prompts).
+ * Unit tests for Docker-first customize assembly (no Clack prompts).
  */
 
 import { describe, expect, test } from "bun:test";
 import {
   EMAIL_CHOICES,
   INDEX_CHOICES,
-  TEMPLATE_DOCKER_PROD,
-  TEMPLATE_LOCAL,
+  TEMPLATE_DEV,
   customizeFacetsFor,
 } from "./drivers-catalog.ts";
 import { assembleDriverDefaults, pinsFromSides, recommendedAiApply } from "./customize-flow.ts";
@@ -37,7 +36,6 @@ describe("catalog labels", () => {
       "none",
       "memory",
       "pgvector",
-      "libsql",
       "meilisearch",
     ]);
   });
@@ -52,7 +50,7 @@ describe("recommendedAiApply", () => {
   test("returns llama.cpp (openai-compatible) with curated ai/ model", () => {
     const apply = recommendedAiApply();
     expect(apply.driver).toBe("openai-compatible");
-    expect(apply.chatModel).toBe("smollm2");
+    expect(apply.chatModel).toBe("granite3.3:2b");
     expect(apply.baseUrl).toContain("8080");
     expect(apply.image).toContain("llama.cpp");
     expect(apply.image).not.toContain("latest");
@@ -61,50 +59,47 @@ describe("recommendedAiApply", () => {
 });
 
 describe("pinsFromSides", () => {
-  test("prod copies docker", () => {
-    expect(pinsFromSides("sqlite", "postgres", "memory")).toEqual({
-      local: "sqlite",
-      docker: "postgres",
-      test: "memory",
+  test("prod mirrors dev by default", () => {
+    expect(pinsFromSides("postgres", "pglite")).toEqual({
+      dev: "postgres",
+      test: "pglite",
       prod: "postgres",
     });
   });
 });
 
 describe("assembleDriverDefaults", () => {
-  test("primary docker + skip other → local pins === template defaults", () => {
-    const drivers = assembleDriverDefaults(
-      "docker",
-      { sql: "libsql", kv: "redis", files: "s3", signal: "nats" },
-      null,
-    );
-    expect(drivers.store.sql.docker).toBe("libsql");
-    expect(drivers.store.sql.local).toBe(TEMPLATE_LOCAL.sql);
-    expect(drivers.store.kv.local).toBe(TEMPLATE_LOCAL.kv);
-    expect(drivers.signal.local).toBe(TEMPLATE_LOCAL.signal);
-    expect(drivers.store.sql.prod).toBe("libsql");
+  test("picked sql + defaults for unpicked facets", () => {
+    const drivers = assembleDriverDefaults({
+      sql: "postgres",
+      kv: "redis",
+      files: "s3",
+      signal: "redis",
+    });
+    expect(drivers.store.sql.dev).toBe("postgres");
+    expect(drivers.store.sql.test).toBe("pglite");
+    expect(drivers.store.sql.prod).toBe("postgres");
+    expect(drivers.store.kv.dev).toBe("redis");
+    expect(drivers.signal.dev).toBe("redis");
+    expect(drivers.vault.dev).toBe(TEMPLATE_DEV.vault);
   });
 
-  test("primary local + customize docker → both sides set", () => {
-    const drivers = assembleDriverDefaults("local", { sql: "pglite" }, { sql: "postgres" });
-    expect(drivers.store.sql.local).toBe("pglite");
-    expect(drivers.store.sql.docker).toBe("postgres");
-    expect(drivers.store.sql.prod).toBe("postgres");
-    // Unpicked facets fall back to catalog defaults.
-    expect(drivers.store.kv.local).toBe(TEMPLATE_LOCAL.kv);
-    expect(drivers.store.kv.docker).toBe(TEMPLATE_DOCKER_PROD.kv);
+  test("empty pick → template Docker-first defaults", () => {
+    const drivers = assembleDriverDefaults({});
+    expect(drivers.store.sql.dev).toBe(TEMPLATE_DEV.sql);
+    expect(drivers.store.kv.dev).toBe(TEMPLATE_DEV.kv);
+    expect(drivers.store.sql.test).toBe("pglite");
   });
 
   test("index stays null for none / unset", () => {
-    expect(assembleDriverDefaults("local", { sql: "sqlite" }, null).store.index).toBeNull();
-    expect(assembleDriverDefaults("docker", { index: "none" }, null).store.index).toBeNull();
+    expect(assembleDriverDefaults({ sql: "postgres" }).store.index).toBeNull();
+    expect(assembleDriverDefaults({ index: "none" }).store.index).toBeNull();
   });
 
-  test("index driver on primary fills both columns", () => {
-    const drivers = assembleDriverDefaults("docker", { index: "meilisearch" }, null);
+  test("index driver fills both runtime columns", () => {
+    const drivers = assembleDriverDefaults({ index: "meilisearch" });
     expect(drivers.store.index).toEqual({
-      local: "memory",
-      docker: "meilisearch",
+      dev: "meilisearch",
       test: "memory",
       prod: "meilisearch",
     });

package/src/customize-flow.ts

@@ -1,9 +1,7 @@
 /**
- * Customize wizard — pick local|docker first, walk facets for that side,
- * then ask whether to customize the other (defaults if no).
+ * Customize wizard — walk Docker-first facets once, assemble `{ dev, test, prod }`.
  */
 
-import { confirm, isCancel } from "@clack/prompts";
 import { toCreateDefaults, type CreateDefaults, type EnvDriverPins } from "./create-defaults.ts";
 import {
   CLOCK_CHOICES,
@@ -13,8 +11,7 @@ import {
   KV_CHOICES,
   SIGNAL_CHOICES,
   SQL_CHOICES,
-  TEMPLATE_DOCKER_PROD,
-  TEMPLATE_LOCAL,
+  TEMPLATE_DEV,
   TEMPLATE_TEST,
   VAULT_CHOICES,
   AI_PROVIDERS,
@@ -25,7 +22,7 @@ import {
   aiDriverForProvider,
   customizeFacetsFor,
   pinsDockerReady,
-  pinsLocalOnly,
+  pinsEnv,
   type AiProviderId,
   type CustomizeFacetId,
   type DriverChoice,
@@ -39,10 +36,7 @@ import { WIZARD_BACK, selectWithBack, type WizardBack } from "./wizard-select.ts
 export type { WizardBack };
 export { WIZARD_BACK };
 
-/** Dev env column being customized. */
-export type CustomizeSide = "local" | "docker";
-
-/** Partial pins accumulated per side before merge. */
+/** Partial pins accumulated before merge. */
 export type SidePins = {
   sql?: string;
   kv?: string;
@@ -56,14 +50,14 @@ export type SidePins = {
 };
 
 /**
- * Merge primary + other side into full {@link EnvDriverPins}.
+ * Assemble `{ dev, test, prod }` pins (prod mirrors dev).
  *
- * @param local - Local driver
- * @param docker - Docker driver (copied to prod)
+ * @param dev - Dev driver
  * @param test - Test pin
+ * @param prod - Prod pin (defaults to `dev`)
  */
-export function pinsFromSides(local: string, docker: string, test: string): EnvDriverPins {
-  return { local, docker, test, prod: docker };
+export function pinsFromSides(dev: string, test: string, prod: string = dev): EnvDriverPins {
+  return pinsEnv(dev, test, prod);
 }
 
 /**
@@ -76,69 +70,25 @@ function indexEnabled(value: string | null | undefined): value is string {
 }
 
 /**
- * Fill missing side from template defaults.
+ * Fill missing facets from template Docker-first defaults.
  *
- * @param side - Side that was customized
- * @param picked - Values chosen for that side
- * @param other - Optional values if the user also customized the other side
+ * @param picked - Values chosen during customize
  */
-export function assembleDriverDefaults(
-  side: CustomizeSide,
-  picked: SidePins,
-  other: SidePins | null,
-): CreateDefaults["drivers"] {
-  const localSrc = side === "local" ? picked : (other ?? {});
-  const dockerSrc = side === "docker" ? picked : (other ?? {});
-
-  const sql = pinsFromSides(
-    localSrc.sql ?? TEMPLATE_LOCAL.sql,
-    dockerSrc.sql ?? TEMPLATE_DOCKER_PROD.sql,
-    TEMPLATE_TEST.sql,
-  );
-  const kv = pinsFromSides(
-    localSrc.kv ?? TEMPLATE_LOCAL.kv,
-    dockerSrc.kv ?? TEMPLATE_DOCKER_PROD.kv,
-    TEMPLATE_TEST.kv,
-  );
-  const files = pinsFromSides(
-    localSrc.files ?? TEMPLATE_LOCAL.files,
-    dockerSrc.files ?? TEMPLATE_DOCKER_PROD.files,
-    TEMPLATE_TEST.files,
-  );
-  const indexLocal = localSrc.index;
-  const indexDocker = dockerSrc.index;
-  const index =
-    indexEnabled(indexLocal) || indexEnabled(indexDocker)
-      ? pinsFromSides(
-          indexEnabled(indexLocal) ? indexLocal : "memory",
-          indexEnabled(indexDocker) ? indexDocker : "meilisearch",
-          "memory",
-        )
-      : null;
+export function assembleDriverDefaults(picked: SidePins): CreateDefaults["drivers"] {
+  const sql = pinsFromSides(picked.sql ?? TEMPLATE_DEV.sql, TEMPLATE_TEST.sql);
+  const kv = pinsFromSides(picked.kv ?? TEMPLATE_DEV.kv, TEMPLATE_TEST.kv);
+  const files = pinsFromSides(picked.files ?? TEMPLATE_DEV.files, TEMPLATE_TEST.files);
+  const index = indexEnabled(picked.index)
+    ? pinsFromSides(picked.index, "memory", picked.index)
+    : null;
 
   return {
     store: { sql, kv, files, index },
-    signal: pinsFromSides(
-      localSrc.signal ?? TEMPLATE_LOCAL.signal,
-      dockerSrc.signal ?? TEMPLATE_DOCKER_PROD.signal,
-      TEMPLATE_TEST.signal,
-    ),
-    clock: pinsFromSides(
-      localSrc.clock ?? TEMPLATE_LOCAL.clock,
-      dockerSrc.clock ?? TEMPLATE_DOCKER_PROD.clock,
-      TEMPLATE_TEST.clock,
-    ),
-    vault: pinsFromSides(
-      localSrc.vault ?? TEMPLATE_LOCAL.vault,
-      dockerSrc.vault ?? TEMPLATE_DOCKER_PROD.vault,
-      TEMPLATE_TEST.vault,
-    ),
+    signal: pinsFromSides(picked.signal ?? TEMPLATE_DEV.signal, TEMPLATE_TEST.signal),
+    clock: pinsFromSides(picked.clock ?? TEMPLATE_DEV.clock, TEMPLATE_TEST.clock),
+    vault: pinsFromSides(picked.vault ?? TEMPLATE_DEV.vault, TEMPLATE_TEST.vault),
     channel: {
-      email: pinsFromSides(
-        localSrc.email ?? TEMPLATE_LOCAL.email,
-        dockerSrc.email ?? TEMPLATE_DOCKER_PROD.email,
-        TEMPLATE_TEST.email,
-      ),
+      email: pinsFromSides(picked.email ?? TEMPLATE_DEV.email, TEMPLATE_TEST.email),
     },
     ai: null,
   };
@@ -146,13 +96,13 @@ export function assembleDriverDefaults(
 
 /**
  * Balanced llama.cpp defaults for "AI setup → Recommended" (no quiz).
- * Lightest local footprint; curated Docker Hub `ai/` model via docker-repo.
+ * openai-compatible + curated Docker Hub `ai/` model (`granite3.3:2b`).
  */
 export function recommendedAiApply(): AiSetupApplyInput {
   return {
     driver: "openai-compatible",
     baseUrl: process.env.OKE_AI_URL ?? "http://127.0.0.1:8080/v1",
-    chatModel: "smollm2",
+    chatModel: "granite3.3:2b",
     visionModel: null,
     embedModel: null,
     image: LLAMA_CPP_IMAGE,
@@ -201,56 +151,14 @@ export function withLocalAiImage(input: AiSetupApplyInput, provider: string): Ai
 export async function askCustomizeFlow(
   template: TemplateId,
 ): Promise<CreateDefaults | WizardBack | null> {
-  const primaryValue = await selectWithBack(
-    "Customize drivers for",
-    [
-      {
-        value: "local",
-        label: "Local",
-        hint: "oke mode local — sqlite / memory / fs …",
-      },
-      {
-        value: "docker",
-        label: "Docker",
-        hint: "oke mode docker — postgres / redis / s3 …",
-      },
-    ],
-    template === "advanced" ? "docker" : "local",
-    { allowBack: true },
-  );
-  if (primaryValue === null) return null;
-  if (primaryValue === WIZARD_BACK) return WIZARD_BACK;
-  const primary = primaryValue as CustomizeSide;
-
   const facets = customizeFacetsFor(template);
-  const primaryPins = await walkFacetsForSide(facets, primary);
+  const primaryPins = await walkFacets(facets);
   if (primaryPins === null) return null;
   if (primaryPins === WIZARD_BACK) return WIZARD_BACK;
 
-  const otherSide: CustomizeSide = primary === "local" ? "docker" : "local";
-  const alsoOther = await confirm({
-    message:
-      otherSide === "local" ? "Also customize local drivers?" : "Also customize docker drivers?",
-    initialValue: false,
-  });
-  if (isCancel(alsoOther)) return null;
-
-  let otherPins: SidePins | null = null;
-  if (alsoOther) {
-    const walked = await walkFacetsForSide(facets, otherSide);
-    if (walked === null) return null;
-    if (walked === WIZARD_BACK) {
-      // Back from other side → treat as "no, use defaults"
-      otherPins = null;
-    } else {
-      otherPins = walked;
-    }
-  }
-
-  const drivers = assembleDriverDefaults(primary, primaryPins, otherPins);
-  const profile = primary === "docker" ? "docker-ready" : "local-only";
+  const drivers = assembleDriverDefaults(primaryPins);
 
-  // AI — after env passes
+  // AI — after env pass
   let aiPins: EnvDriverPins | null = null;
   let aiPref: CreateDefaults["ai"] = { enabled: false, provider: null, driver: null };
   let aiApply: AiSetupApplyInput | null = null;
@@ -262,7 +170,7 @@ export async function askCustomizeFlow(
         {
           value: "recommended",
           label: "Recommended",
-          hint: "llama.cpp · lightest local footprint",
+          hint: "llama.cpp · openai-compatible · granite3.3:2b",
         },
         {
           value: "customize",
@@ -280,15 +188,11 @@ export async function askCustomizeFlow(
     );
     if (aiSetup === null) return null;
     if (aiSetup === WIZARD_BACK) {
-      // Back from AI → leave AI off (same as Off) and finish customize.
       break;
     }
     if (aiSetup === "off") break;
     if (aiSetup === "recommended") {
-      aiPins =
-        primary === "local" && !alsoOther
-          ? pinsLocalOnly("openai-compatible", "openai-compatible", "mock")
-          : pinsDockerReady("openai-compatible", "openai-compatible", "mock");
+      aiPins = pinsDockerReady("openai-compatible", "mock");
       aiApply = recommendedAiApply();
       aiPref = aiPrefWithModels(
         {
@@ -301,91 +205,60 @@ export async function askCustomizeFlow(
       break;
     }
 
-    // customize — local provider, optional docker provider, then model wizard
     const options = AI_PROVIDERS.map((p) => ({ value: p.value, label: p.label }));
-    providers: for (;;) {
-      const askDockerAi = primary === "docker" || alsoOther;
-      const localProviderValue = await selectWithBack(
-        askDockerAi || primary === "local" ? "AI Provider — local" : "AI Provider",
-        options,
-        "llama-cpp",
-        { allowBack: true },
-      );
-      if (localProviderValue === null) return null;
-      if (localProviderValue === WIZARD_BACK) continue aiSetup;
-
-      const localProvider = localProviderValue as AiProviderId;
-      const localDriver = aiDriverForProvider(localProvider);
-      let dockerDriver = localDriver === "mock" ? "mock" : localDriver;
-      let dockerProvider: AiProviderId = localProvider;
-
-      if (askDockerAi) {
-        const dockerProviderValue = await selectWithBack(
-          "AI Provider — docker",
-          options,
-          "llama-cpp",
-          { allowBack: true },
-        );
-        if (dockerProviderValue === null) return null;
-        if (dockerProviderValue === WIZARD_BACK) continue providers;
-        dockerProvider = dockerProviderValue as AiProviderId;
-        dockerDriver = aiDriverForProvider(dockerProvider);
-        if (dockerDriver === "mock") dockerDriver = "mock";
-      }
+    const providerValue = await selectWithBack("AI Provider", options, "llama-cpp", {
+      allowBack: true,
+    });
+    if (providerValue === null) return null;
+    if (providerValue === WIZARD_BACK) continue;
 
-      aiPins =
-        primary === "local" && !alsoOther
-          ? pinsLocalOnly(localDriver, dockerDriver, "mock")
-          : pinsDockerReady(localDriver, dockerDriver, "mock");
+    const provider = providerValue as AiProviderId;
+    const driver = aiDriverForProvider(provider);
+    aiPins = pinsDockerReady(driver, "mock");
 
-      const setupProvider =
-        localProvider === "ollama" || aiPins.local === "ollama" || aiPins.docker === "ollama"
-          ? "ollama"
-          : localProvider;
-
-      if (setupProvider !== "mock") {
-        const picked = await askAiSetup({ provider: setupProvider });
-        if (picked === null) return null;
-        aiApply = withLocalAiImage(picked, askDockerAi ? dockerProvider : localProvider);
-      } else {
-        aiApply = { driver: "mock" };
-      }
-
-      aiPref = aiPrefWithModels(
-        {
-          enabled: true,
-          provider: setupProvider,
-          driver: aiPins.local,
-        },
-        aiApply,
-      );
-      break aiSetup;
+    if (provider !== "mock") {
+      const picked = await askAiSetup({ provider });
+      if (picked === null) return null;
+      aiApply = withLocalAiImage(picked, provider);
+    } else {
+      aiApply = { driver: "mock" };
     }
+
+    aiPref = aiPrefWithModels(
+      {
+        enabled: true,
+        provider,
+        driver: aiPins.dev,
+      },
+      aiApply,
+    );
+    break;
   }
 
   return toCreateDefaults({
     template,
-    profile,
+    profile: "docker-ready",
     drivers: { ...drivers, ai: aiPins },
     ai: aiPref,
+    // Locales / PgDog are asked once in the main wizard (not per customize pass).
+    locales: [],
+    pgdog: false,
   });
 }
 
 /**
- * Walk facet prompts for one env side.
+ * Walk facet prompts for the Docker-first runtime.
  *
  * @param facets - Facet ids for the template
- * @param side - local or docker
  */
-async function walkFacetsForSide(
+async function walkFacets(
   facets: readonly CustomizeFacetId[],
-  side: CustomizeSide,
 ): Promise<SidePins | WizardBack | null> {
   const out: SidePins = {};
   let i = 0;
   while (i < facets.length) {
     const facet = facets[i]!;
-    const result = await askOneFacet(facet, side, out);
+    const result = await askOneFacet(facet, out);
     if (result === null) return null;
     if (result === WIZARD_BACK) {
       if (i === 0) return WIZARD_BACK;
@@ -399,87 +272,53 @@ async function walkFacetsForSide(
 
 async function askOneFacet(
   facet: CustomizeFacetId,
-  side: CustomizeSide,
   state: SidePins,
 ): Promise<true | WizardBack | null> {
-  const suffix = side === "local" ? "local" : "docker";
   switch (facet) {
     case "sql": {
-      const v = await askSideChoice(
-        `store.sql — ${suffix}`,
-        SQL_CHOICES,
-        side === "local" ? TEMPLATE_LOCAL.sql : TEMPLATE_DOCKER_PROD.sql,
-      );
+      const v = await askSideChoice("store.sql — dev/prod", SQL_CHOICES, TEMPLATE_DEV.sql);
       if (v === null || v === WIZARD_BACK) return v;
       state.sql = v;
       return true;
     }
     case "kv": {
-      const v = await askSideChoice(
-        `store.kv — ${suffix}`,
-        KV_CHOICES,
-        side === "local" ? TEMPLATE_LOCAL.kv : TEMPLATE_DOCKER_PROD.kv,
-      );
+      const v = await askSideChoice("store.kv — dev/prod", KV_CHOICES, TEMPLATE_DEV.kv);
       if (v === null || v === WIZARD_BACK) return v;
       state.kv = v;
       return true;
     }
     case "files": {
-      const v = await askSideChoice(
-        `store.files — ${suffix}`,
-        FILES_CHOICES,
-        side === "local" ? TEMPLATE_LOCAL.files : TEMPLATE_DOCKER_PROD.files,
-      );
+      const v = await askSideChoice("store.files — dev/prod", FILES_CHOICES, TEMPLATE_DEV.files);
       if (v === null || v === WIZARD_BACK) return v;
       state.files = v;
       return true;
     }
     case "index": {
-      const v = await askSideChoice(
-        `store.index — ${suffix}`,
-        INDEX_CHOICES,
-        side === "local" ? "none" : "meilisearch",
-      );
+      const v = await askSideChoice("store.index — dev/prod", INDEX_CHOICES, "meilisearch");
       if (v === null || v === WIZARD_BACK) return v;
       state.index = v;
       return true;
     }
     case "signal": {
-      const v = await askSideChoice(
-        `signal — ${suffix}`,
-        SIGNAL_CHOICES,
-        side === "local" ? TEMPLATE_LOCAL.signal : TEMPLATE_DOCKER_PROD.signal,
-      );
+      const v = await askSideChoice("signal — dev/prod", SIGNAL_CHOICES, TEMPLATE_DEV.signal);
       if (v === null || v === WIZARD_BACK) return v;
       state.signal = v;
       return true;
     }
     case "clock": {
-      const v = await askSideChoice(
-        `clock — ${suffix}`,
-        CLOCK_CHOICES,
-        side === "local" ? TEMPLATE_LOCAL.clock : TEMPLATE_DOCKER_PROD.clock,
-      );
+      const v = await askSideChoice("clock — dev/prod", CLOCK_CHOICES, TEMPLATE_DEV.clock);
       if (v === null || v === WIZARD_BACK) return v;
       state.clock = v;
       return true;
     }
     case "vault": {
-      const v = await askSideChoice(
-        `vault — ${suffix}`,
-        VAULT_CHOICES,
-        side === "local" ? TEMPLATE_LOCAL.vault : TEMPLATE_DOCKER_PROD.vault,
-      );
+      const v = await askSideChoice("vault — dev/prod", VAULT_CHOICES, TEMPLATE_DEV.vault);
       if (v === null || v === WIZARD_BACK) return v;
       state.vault = v;
       return true;
     }
     case "email": {
-      const v = await askSideChoice(
-        `channel.email — ${suffix}`,
-        EMAIL_CHOICES,
-        side === "local" ? TEMPLATE_LOCAL.email : TEMPLATE_DOCKER_PROD.email,
-      );
+      const v = await askSideChoice("channel.email — dev/prod", EMAIL_CHOICES, TEMPLATE_DEV.email);
       if (v === null || v === WIZARD_BACK) return v;
       state.email = v;
       return true;