create-oke 0.6.0 → 0.7.0

package/src/customize-flow.ts

@@ -0,0 +1,432 @@
+/**
+ * Customize wizard — pick local|docker first, walk facets for that side,
+ * then ask whether to customize the other (defaults if no).
+ */
+
+import { confirm, isCancel } from "@clack/prompts";
+import { toCreateDefaults, type CreateDefaults, type EnvDriverPins } from "./create-defaults.ts";
+import {
+  CLOCK_CHOICES,
+  EMAIL_CHOICES,
+  FILES_CHOICES,
+  INDEX_CHOICES,
+  KV_CHOICES,
+  SIGNAL_CHOICES,
+  SQL_CHOICES,
+  TEMPLATE_DOCKER_PROD,
+  TEMPLATE_LOCAL,
+  TEMPLATE_TEST,
+  VAULT_CHOICES,
+  AI_PROVIDERS,
+  aiDriverForProvider,
+  customizeFacetsFor,
+  pinsDockerReady,
+  pinsLocalOnly,
+  type AiProviderId,
+  type CustomizeFacetId,
+  type DriverChoice,
+} from "./drivers-catalog.ts";
+import type { AiSetupApplyInput } from "./ai-setup/apply.ts";
+import { aiPrefWithModels } from "./ai-setup/from-pref.ts";
+import { askAiSetup } from "./ai-setup/prompts.ts";
+import type { TemplateId } from "./templates.ts";
+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. */
+export type SidePins = {
+  sql?: string;
+  kv?: string;
+  files?: string;
+  index?: string | null;
+  signal?: string;
+  clock?: string;
+  vault?: string;
+  email?: string;
+  enableIndex?: boolean;
+};
+
+/**
+ * Merge primary + other side into full {@link EnvDriverPins}.
+ *
+ * @param local - Local driver
+ * @param docker - Docker driver (copied to prod)
+ * @param test - Test pin
+ */
+export function pinsFromSides(local: string, docker: string, test: string): EnvDriverPins {
+  return { local, docker, test, prod: docker };
+}
+
+/**
+ * Fill missing side from template 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
+ */
+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 enableIndex = Boolean(
+    (side === "local" ? picked.enableIndex : other?.enableIndex) ||
+    (side === "docker" ? picked.enableIndex : other?.enableIndex),
+  );
+  const indexLocal = localSrc.index;
+  const indexDocker = dockerSrc.index;
+  const index =
+    enableIndex || indexLocal != null || indexDocker != null
+      ? pinsFromSides(
+          typeof indexLocal === "string" ? indexLocal : "memory",
+          typeof indexDocker === "string" ? indexDocker : "meilisearch",
+          "memory",
+        )
+      : 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,
+    ),
+    channel: {
+      email: pinsFromSides(
+        localSrc.email ?? TEMPLATE_LOCAL.email,
+        dockerSrc.email ?? TEMPLATE_DOCKER_PROD.email,
+        TEMPLATE_TEST.email,
+      ),
+    },
+    ai: null,
+  };
+}
+
+/**
+ * Customize drivers for one template.
+ *
+ * @param template - Starter id (filters facets)
+ */
+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);
+  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";
+
+  // AI — after env passes
+  let aiPins: EnvDriverPins | null = null;
+  let aiPref: CreateDefaults["ai"] = { enabled: false, provider: null, driver: null };
+  let aiApply: AiSetupApplyInput | null = null;
+
+  const wantAi = await selectWithBack(
+    "Configure AI?",
+    [
+      { value: "yes", label: "✓  Yes" },
+      { value: "no", label: "✗  No" },
+    ],
+    "no",
+    { allowBack: true },
+  );
+  if (wantAi === null) return null;
+  if (wantAi !== WIZARD_BACK && wantAi === "yes") {
+    const options = AI_PROVIDERS.map((p) => ({ value: p.value, label: p.label }));
+    const localProviderValue = await selectWithBack(
+      alsoOther || primary === "local" ? "AI Provider — local" : "AI Provider",
+      options,
+      "ollama",
+      { allowBack: true },
+    );
+    if (localProviderValue === null) return null;
+    if (localProviderValue !== WIZARD_BACK) {
+      const localProvider = localProviderValue as AiProviderId;
+      const localDriver = aiDriverForProvider(localProvider);
+      let dockerDriver = localDriver === "mock" ? "mock" : localDriver;
+
+      if (primary === "docker" || alsoOther) {
+        const dockerProviderValue = await selectWithBack(
+          "AI Provider — docker",
+          options,
+          "ollama",
+          {
+            allowBack: true,
+          },
+        );
+        if (dockerProviderValue === null) return null;
+        if (dockerProviderValue !== WIZARD_BACK) {
+          dockerDriver = aiDriverForProvider(dockerProviderValue);
+          if (dockerDriver === "mock") dockerDriver = "mock";
+        }
+      }
+
+      aiPins =
+        primary === "local" && !alsoOther
+          ? pinsLocalOnly(localDriver, dockerDriver, "mock")
+          : pinsDockerReady(localDriver, dockerDriver, "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 = picked;
+      } else {
+        aiApply = { driver: "mock" };
+      }
+
+      aiPref = aiPrefWithModels(
+        {
+          enabled: true,
+          provider: setupProvider,
+          driver: aiPins.local,
+        },
+        aiApply,
+      );
+    }
+  }
+
+  return toCreateDefaults({
+    template,
+    profile,
+    drivers: { ...drivers, ai: aiPins },
+    ai: aiPref,
+  });
+}
+
+/**
+ * Walk facet prompts for one env side.
+ *
+ * @param facets - Facet ids for the template
+ * @param side - local or docker
+ */
+async function walkFacetsForSide(
+  facets: readonly CustomizeFacetId[],
+  side: CustomizeSide,
+): Promise<SidePins | WizardBack | null> {
+  const out: SidePins = {};
+  let i = 0;
+  while (i < facets.length) {
+    const facet = facets[i]!;
+    if (facet === "index" && !out.enableIndex) {
+      out.index = null;
+      i++;
+      continue;
+    }
+    const result = await askOneFacet(facet, side, out);
+    if (result === null) return null;
+    if (result === WIZARD_BACK) {
+      if (i === 0) return WIZARD_BACK;
+      i--;
+      while (i > 0 && facets[i] === "index" && !out.enableIndex) i--;
+      continue;
+    }
+    i++;
+  }
+  return out;
+}
+
+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,
+      );
+      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,
+      );
+      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,
+      );
+      if (v === null || v === WIZARD_BACK) return v;
+      state.files = v;
+      return true;
+    }
+    case "enableIndex": {
+      const value = await selectWithBack(
+        `Enable store.index (search)? — ${suffix}`,
+        [
+          { value: "yes", label: "✓  Yes" },
+          { value: "no", label: "✗  No" },
+        ],
+        state.enableIndex ? "yes" : "no",
+        { allowBack: true },
+      );
+      if (value === null) return null;
+      if (value === WIZARD_BACK) return WIZARD_BACK;
+      state.enableIndex = value === "yes";
+      if (!state.enableIndex) state.index = null;
+      return true;
+    }
+    case "index": {
+      const v = await askSideChoice(
+        `store.index — ${suffix}`,
+        INDEX_CHOICES,
+        side === "local" ? "memory" : "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,
+      );
+      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,
+      );
+      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,
+      );
+      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,
+      );
+      if (v === null || v === WIZARD_BACK) return v;
+      state.email = v;
+      return true;
+    }
+    default:
+      return null;
+  }
+}
+
+async function askSideChoice(
+  label: string,
+  choices: readonly DriverChoice[],
+  recommended: string,
+): Promise<string | WizardBack | null> {
+  return selectWithBack(
+    label,
+    choices.map((c) => ({
+      value: c.value,
+      label: c.label,
+      hint: c.value === recommended ? "recommended" : undefined,
+    })),
+    recommended,
+    { allowBack: true },
+  );
+}

package/src/drivers-catalog.ts

@@ -0,0 +1,217 @@
+/**
+ * Boot-implemented driver choices offered by the create-oke customize wizard.
+ *
+ * Never lists ids that fail loud at boot (signal postgres/nats, clock postgres,
+ * ai bedrock/vertex).
+ */
+
+import type { CreateDefaults, CreateProfile, EnvDriverPins } from "./create-defaults.ts";
+import type { TemplateId } from "./templates.ts";
+
+/** One selectable driver option. */
+export type DriverChoice = {
+  readonly value: string;
+  readonly label: string;
+};
+
+/** Standard template docker/prod pins (unchanged for local-only profile). */
+export const TEMPLATE_DOCKER_PROD = {
+  sql: "postgres",
+  kv: "redis",
+  files: "s3",
+  signal: "redis",
+  clock: "file",
+  vault: "openbao",
+  email: "smtp",
+} as const;
+
+/** Standard template local defaults. */
+export const TEMPLATE_LOCAL = {
+  sql: "sqlite",
+  kv: "memory",
+  files: "fs",
+  signal: "memory",
+  clock: "memory",
+  vault: "env",
+  email: "console",
+} as const;
+
+/** Test-column defaults (always applied). */
+export const TEMPLATE_TEST = {
+  sql: "memory",
+  kv: "memory",
+  files: "memory",
+  signal: "memory",
+  clock: "frozen",
+  vault: "memory",
+  email: "console",
+} as const;
+
+export const SQL_CHOICES: readonly DriverChoice[] = [
+  { value: "sqlite", label: "sqlite" },
+  { value: "postgres", label: "postgres" },
+  { value: "libsql", label: "libsql" },
+  { value: "pglite", label: "pglite" },
+  { value: "memory", label: "memory" },
+];
+
+export const KV_CHOICES: readonly DriverChoice[] = [
+  { value: "memory", label: "memory" },
+  { value: "redis", label: "redis" },
+];
+
+export const FILES_CHOICES: readonly DriverChoice[] = [
+  { value: "fs", label: "fs" },
+  { value: "s3", label: "s3" },
+  { value: "memory", label: "memory" },
+];
+
+export const INDEX_CHOICES: readonly DriverChoice[] = [
+  { value: "memory", label: "memory" },
+  { value: "pgvector", label: "pgvector" },
+  { value: "libsql", label: "libsql" },
+  { value: "meilisearch", label: "meilisearch" },
+];
+
+export const SIGNAL_CHOICES: readonly DriverChoice[] = [
+  { value: "memory", label: "memory" },
+  { value: "redis", label: "redis" },
+];
+
+export const CLOCK_CHOICES: readonly DriverChoice[] = [
+  { value: "memory", label: "memory" },
+  { value: "file", label: "file" },
+  { value: "frozen", label: "frozen" },
+];
+
+export const VAULT_CHOICES: readonly DriverChoice[] = [
+  { value: "env", label: "env" },
+  { value: "openbao", label: "openbao" },
+  { value: "managed", label: "managed" },
+  { value: "memory", label: "memory" },
+];
+
+export const EMAIL_CHOICES: readonly DriverChoice[] = [
+  { value: "console", label: "console" },
+  { value: "smtp", label: "smtp" },
+  { value: "resend", label: "resend" },
+  { value: "sndr", label: "sndr" },
+];
+
+/** AI menu providers → protocol driver. */
+export const AI_PROVIDERS = [
+  { value: "ollama", label: "◎  Ollama (Local)", driver: "ollama" },
+  { value: "openai", label: "◈  OpenAI", driver: "openai-compatible" },
+  { value: "anthropic", label: "◉  Anthropic", driver: "anthropic" },
+  { value: "gemini", label: "◇  Gemini", driver: "openai-compatible" },
+  { value: "lmstudio", label: "▣  LM Studio", driver: "openai-compatible" },
+  { value: "openrouter", label: "⇄  OpenRouter", driver: "openai-compatible" },
+  { value: "custom", label: "⋯  Custom OpenAI Compatible", driver: "openai-compatible" },
+  { value: "mock", label: "◌  Mock (dev only)", driver: "mock" },
+] as const;
+
+export type AiProviderId = (typeof AI_PROVIDERS)[number]["value"];
+
+/**
+ * Build env pins for local-only: user local + template docker/prod + test.
+ *
+ * @param local - Chosen local driver
+ * @param dockerProd - Template docker/prod pin for this facet
+ * @param test - Test pin
+ */
+export function pinsLocalOnly(local: string, dockerProd: string, test: string): EnvDriverPins {
+  return { local, docker: dockerProd, test, prod: dockerProd };
+}
+
+/**
+ * Build env pins when the user chose both columns (docker-ready).
+ *
+ * @param local - Local driver
+ * @param docker - Docker driver (also copied to prod)
+ * @param test - Test pin
+ */
+export function pinsDockerReady(local: string, docker: string, test: string): EnvDriverPins {
+  return { local, docker, test, prod: docker };
+}
+
+/**
+ * Default recommended create-defaults (matches template driver maps).
+ *
+ * @param profile - Profile assumption
+ * @param template - Starter id
+ */
+export function recommendedDefaults(
+  profile: CreateProfile = "docker-ready",
+  template: TemplateId = "standard",
+): CreateDefaults {
+  const store = {
+    sql: pinsLocalOnly(TEMPLATE_LOCAL.sql, TEMPLATE_DOCKER_PROD.sql, TEMPLATE_TEST.sql),
+    kv: pinsLocalOnly(TEMPLATE_LOCAL.kv, TEMPLATE_DOCKER_PROD.kv, TEMPLATE_TEST.kv),
+    files: pinsLocalOnly(TEMPLATE_LOCAL.files, TEMPLATE_DOCKER_PROD.files, TEMPLATE_TEST.files),
+    index: null as EnvDriverPins | null,
+  };
+  return {
+    version: 1,
+    template,
+    profile,
+    drivers: {
+      store,
+      signal: pinsLocalOnly(
+        TEMPLATE_LOCAL.signal,
+        TEMPLATE_DOCKER_PROD.signal,
+        TEMPLATE_TEST.signal,
+      ),
+      clock: pinsLocalOnly(TEMPLATE_LOCAL.clock, TEMPLATE_DOCKER_PROD.clock, TEMPLATE_TEST.clock),
+      vault: pinsLocalOnly(TEMPLATE_LOCAL.vault, TEMPLATE_DOCKER_PROD.vault, TEMPLATE_TEST.vault),
+      channel: {
+        email: pinsLocalOnly(TEMPLATE_LOCAL.email, TEMPLATE_DOCKER_PROD.email, TEMPLATE_TEST.email),
+      },
+      ai: null,
+    },
+    ai: { enabled: false, provider: null, driver: null },
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+/** Driver facet ids walked during customize (env columns only). */
+export type CustomizeFacetId =
+  | "sql"
+  | "kv"
+  | "files"
+  | "enableIndex"
+  | "index"
+  | "signal"
+  | "clock"
+  | "vault"
+  | "email";
+
+/**
+ * Facets shown for a template (AI is asked after both env passes).
+ *
+ * @param template - Starter id
+ */
+export function customizeFacetsFor(template: TemplateId): readonly CustomizeFacetId[] {
+  if (template === "standard") return ["sql"];
+  return ["sql", "kv", "files", "enableIndex", "index", "signal", "clock", "vault", "email"];
+}
+
+/**
+ * Resolve protocol driver for an AI provider menu id.
+ *
+ * @param provider - Menu value
+ */
+export function aiDriverForProvider(provider: string): string {
+  const hit = AI_PROVIDERS.find((p) => p.value === provider);
+  return hit?.driver ?? "mock";
+}
+
+/** Default image pins keyed by role (standard template). */
+export const DEFAULT_IMAGES: Readonly<Record<string, string>> = {
+  "store.sql": "postgres:18-alpine",
+  "store.kv": "redis:8-alpine",
+  "store.files": "rustfs/rustfs:1.0.0-beta.11",
+  "channel.email": "axllent/mailpit:v1.22.3",
+  vault: "openbao/openbao:2.6.1",
+  "store.index": "getmeili/meilisearch:v1.37",
+  ai: "ollama/ollama:latest",
+};