create-oke 0.9.0 → 0.10.0

package/src/ai-setup/recommend.ts

@@ -1,32 +1,21 @@
 /**
- * Smart local-model recommendations — machine-tier fit + use-case scoring.
+ * Machine fit helpers for local Ollama model picks.
  *
  * Catalog `ramGb` is the **recommended machine tier** for that model (not the
- * download size). A 24GB laptop must never be told it will "download a 24GB
- * model" — that number was machine RAM shown in the wrong place.
- *
- * Most dev machines are 8–16GB. Prefer picks that leave ~4GB for OS / IDE /
- * browser when several models fit.
+ * download size). Prefer picks that leave ~4GB for OS / IDE / browser.
  */
 
-import { CHAT_MODELS, VISION_MODELS, type CatalogModel } from "./catalog.ts";
+import {
+  CHAT_MODELS,
+  MODEL_TIERS,
+  type CatalogModel,
+  type ModelTier,
+  recommendForTier,
+} from "./catalog.ts";
 
 /** Reserved for OS + IDE + browser while the model runs. */
 export const OS_HEADROOM_GB = 4;
 
-/** What the developer mainly wants from the local model. */
-export type AiUseCase = "coding" | "general" | "reasoning" | "balanced";
-
-/** Speed vs quality preference. */
-export type AiPriority = "speed" | "balanced" | "quality";
-
-/** Answers from the short Ollama questionnaire. */
-export type AiNeeds = {
-  readonly useCase: AiUseCase;
-  readonly priority: AiPriority;
-  readonly wantVision: boolean;
-};
-
 /**
  * RAM left after reserving OS/IDE headroom.
  *
@@ -60,7 +49,6 @@ export function modelFitsComfortably(model: CatalogModel, totalRamGb: number | n
     return Boolean(model.recommended);
   }
   const smallest = [...CHAT_MODELS].sort((a, b) => a.ramGb - b.ramGb)[0]!;
-  // Always allow the entry-level model on machines that meet its tier.
   if (model.id === smallest.id) return model.ramGb <= totalRamGb;
   return model.ramGb + OS_HEADROOM_GB <= totalRamGb;
 }
@@ -101,103 +89,132 @@ export function comfortableChatModels(totalRamGb: number | null): readonly Catal
 }
 
 /**
- * Score a fitting chat model for the user's needs (higher = better).
+ * Suggest a tier for the machine's fit RAM budget.
  *
- * @param model - Candidate
- * @param needs - Questionnaire answers
- * @param totalRamGb - Machine RAM (tight-fit penalty)
+ * @param totalRamGb - Machine RAM
  */
-export function scoreChatModel(
-  model: CatalogModel,
-  needs: AiNeeds,
-  totalRamGb: number | null = null,
-): number {
-  let score = 0;
-  if (needs.priority === "speed") score += 100 - model.ramGb * 3;
-  else if (needs.priority === "quality") score += model.ramGb * 4;
-  else score += model.ramGb * 2;
-
-  if (needs.useCase === "coding") {
-    if (model.id.startsWith("qwen")) score += 40;
-    if (model.id.includes("deepseek")) score += 15;
-  } else if (needs.useCase === "reasoning") {
-    if (model.id.includes("deepseek") || model.id.includes("r1")) score += 45;
-    if (model.id.startsWith("qwen")) score += 20;
-  } else if (needs.useCase === "general") {
-    if (model.id.includes("llama") || model.id.includes("gemma")) score += 35;
-    if (model.id.startsWith("qwen")) score += 20;
-  } else {
-    if (model.recommended) score += 25;
-    if (model.id.startsWith("qwen3.5:9b")) score += 30;
-    if (model.id.startsWith("gemma")) score += 20;
-  }
-
-  // Prefer leaving OS/IDE headroom unless the user asked for max quality.
-  if (isTightFit(model, totalRamGb) && needs.priority !== "quality") {
-    score -= 35;
-  }
-  return score;
+export function suggestTierForRam(totalRamGb: number | null): ModelTier {
+  if (totalRamGb === null || !Number.isFinite(totalRamGb)) return "fast";
+  const budget = usableRamGb(totalRamGb);
+  if (budget >= 24) return "smart";
+  if (budget >= 8) return "balanced";
+  if (budget >= 4) return "fast";
+  return "ultra-fast";
 }
 
 /**
- * Pick the best chat model for RAM + needs.
+ * Recommend a chat model for host RAM (balanced default — no quiz).
  *
  * @param totalRamGb - Machine RAM
- * @param needs - Questionnaire (defaults to balanced/speed-friendly)
  */
-export function recommendChatForNeeds(
-  totalRamGb: number | null,
-  needs: AiNeeds = { useCase: "balanced", priority: "balanced", wantVision: false },
-): CatalogModel {
-  // Prefer comfortable pool; quality may still score a tight tier-fit higher.
-  const pool =
-    needs.priority === "quality"
-      ? fittingChatModels(totalRamGb)
-      : comfortableChatModels(totalRamGb);
-  let best = pool[0]!;
-  let bestScore = Number.NEGATIVE_INFINITY;
-  for (const m of pool) {
-    const s = scoreChatModel(m, needs, totalRamGb);
-    if (s > bestScore) {
-      best = m;
-      bestScore = s;
-    }
-  }
-  return best;
+export function recommendChatForNeeds(totalRamGb: number | null): CatalogModel {
+  return recommendForTier(suggestTierForRam(totalRamGb), totalRamGb);
 }
 
 /**
- * Vision model that fits; null if user skipped or none fit.
+ * Shared hardware lines for local AI banners.
  *
- * @param totalRamGb - Machine RAM
- * @param wantVision - From questionnaire
+ * @param machine - Detected hardware
  */
-export function recommendVisionForNeeds(
-  totalRamGb: number | null,
-  wantVision: boolean,
-): CatalogModel | null {
-  if (!wantVision) return null;
-  const fits = VISION_MODELS.filter((m) => modelFitsOnMachine(m, totalRamGb));
-  return fits.find((m) => m.recommended) ?? fits[0] ?? null;
+function formatMachineBannerLines(machine: {
+  readonly osName: string;
+  readonly cpuCount: number | null;
+  readonly ramGb: number | null;
+}): readonly string[] {
+  const ram =
+    machine.ramGb !== null && Number.isFinite(machine.ramGb)
+      ? `~${machine.ramGb}GB RAM`
+      : "RAM unknown";
+  const cpu =
+    machine.cpuCount !== null && Number.isFinite(machine.cpuCount) ? String(machine.cpuCount) : "?";
+  const fit =
+    machine.ramGb !== null && Number.isFinite(machine.ramGb)
+      ? `~${usableRamGb(machine.ramGb)}GB RAM`
+      : "unknown";
+  const sep = "  ·  ";
+  return [[`OS ${machine.osName}`, `CPU ${cpu}`, `RAM ${ram}`].join(sep), `Fit RAM ${fit}`];
 }
 
 /**
- * Human summary line for the recommendation panel.
+ * Ollama banner lines — OS · CPU · RAM · fit · detected · tiers.
  *
- * Separates **machine RAM** from **model tier** so "~24GB" is never read as
- * download size.
+ * @param machine - Detected hardware
+ * @param detectedIds - Installed model ids
+ */
+export function formatOllamaBanner(
+  machine: {
+    readonly osName: string;
+    readonly cpuCount: number | null;
+    readonly ramGb: number | null;
+  },
+  detectedIds: readonly string[],
+): string {
+  const sep = "  ·  ";
+  const lines = [
+    ...formatMachineBannerLines(machine),
+    "",
+    "Detected local models",
+    ...(detectedIds.length > 0 ? detectedIds.map((id) => id) : ["(none detected)"]),
+    "",
+    `Tiers${sep}${MODEL_TIERS.map((t) => t.label).join(sep)}`,
+  ];
+  return lines.join("\n");
+}
+
+/**
+ * llama.cpp banner — OS · CPU · RAM · fit · Docker Hub `ai/` source · tiers.
  *
- * @param totalRamGb - Machine RAM
- * @param chat - Chosen chat model
+ * @param machine - Detected hardware
  */
-export function formatMachineSummary(totalRamGb: number | null, chat: CatalogModel): string {
-  if (totalRamGb === null || !Number.isFinite(totalRamGb)) {
-    return `⭐ Suggested: ${chat.label} (≈${chat.ramGb}GB-class machine · not download size)`;
-  }
-  const budget = usableRamGb(totalRamGb);
-  const tight = isTightFit(chat, totalRamGb) ? " · tight on this machine" : "";
-  return [
-    `Your machine: ~${totalRamGb}GB RAM (keep ~${OS_HEADROOM_GB}GB free for OS/IDE → ~${budget}GB model budget)`,
-    `⭐ For you: ${chat.label} — ≈${chat.ramGb}GB-class (Ollama pull is usually much smaller than RAM)${tight}`,
-  ].join("\n");
+export function formatLlamaCppBanner(machine: {
+  readonly osName: string;
+  readonly cpuCount: number | null;
+  readonly ramGb: number | null;
+}): string {
+  const sep = "  ·  ";
+  const lines = [
+    ...formatMachineBannerLines(machine),
+    "",
+    "Model source",
+    "Docker Hub ai/ (curated) — pulled on first container start",
+    "",
+    `Tiers${sep}${MODEL_TIERS.map((t) => t.label).join(sep)}`,
+  ];
+  return lines.join("\n");
+}
+
+/** Model name column width (monospace CLI table). */
+const MODEL_COL_NAME = 26;
+/** RAM column width, right-aligned (`≈32GB`). */
+const MODEL_COL_RAM = 7;
+
+/**
+ * Clip or pad a cell for aligned CLI columns.
+ *
+ * @param value - Cell text
+ * @param width - Fixed width
+ */
+function clipPad(value: string, width: number): string {
+  if (value.length === width) return value;
+  if (value.length < width) return value.padEnd(width);
+  return `${value.slice(0, Math.max(0, width - 1))}…`;
+}
+
+/**
+ * Column header for the model pick list (aligns with {@link formatModelRow}).
+ */
+export function formatModelTableHeader(): string {
+  return `${clipPad("Model", MODEL_COL_NAME)}  ${"RAM".padStart(MODEL_COL_RAM)}  Caps`;
+}
+
+/**
+ * One model row as aligned columns: Model | RAM | Caps.
+ *
+ * @param model - Catalog entry
+ */
+export function formatModelRow(model: CatalogModel): string {
+  const name = clipPad(model.label, MODEL_COL_NAME);
+  const ram = `≈${model.ramGb}GB`.padStart(MODEL_COL_RAM);
+  const caps = model.modalities.join(" · ");
+  return `${name}  ${ram}  ${caps}`;
 }

package/src/cli.test.ts

@@ -200,7 +200,7 @@ describe("wizard ← Back", () => {
     const base = [{ value: "memory", label: "memory" }];
     expect(withBackOption(base, false)).toEqual(base);
     const withBack = withBackOption(base, true);
-    expect(withBack.at(-1)).toEqual({ value: WIZARD_BACK, label: "←  Back" });
+    expect(withBack.at(-1)).toEqual({ value: WIZARD_BACK, label: "Back" });
     expect(WIZARD_BACK).toBe("__back__");
   });
 });
@@ -536,6 +536,8 @@ describe("scaffold structure", () => {
         );
         expect(result.files).toContain(".gitignore");
         expect(result.files).toContain("README.md");
+        expect(result.files).toContain(".github/workflows/ci.yml");
+        expect(result.files).toContain("tsconfig.json");
         expect(result.sqlDriver).toBe("sqlite");
         expect(readFileSync(join(result.targetDir, "AGENTS.md"), "utf8")).toMatch(
           /one law|on\(Trigger\)/i,
@@ -544,13 +546,37 @@ describe("scaffold structure", () => {
         expect(readme).toMatch(/oke dev/);
         expect(readme).toMatch(new RegExp(`Notes \\(${id}\\)`, "i"));
         expect(readme).toMatch(/notes\.(create|attach|digest)|main\.health/);
+        expect(readme).toMatch(/scaffold|Included vs you build/i);
+        expect(readme).toMatch(/\.github\/workflows\/ci\.yml/);
         expect(readFileSync(join(result.targetDir, ".gitignore"), "utf8")).toMatch(/node_modules/);
+        const ciYml = readFileSync(join(result.targetDir, ".github/workflows/ci.yml"), "utf8");
+        expect(() => Bun.YAML.parse(ciYml)).not.toThrow();
+        const ci = Bun.YAML.parse(ciYml) as {
+          name?: string;
+          on?: unknown;
+          jobs?: { check?: { steps?: unknown[] } };
+        };
+        expect(ci.name).toBe("CI");
+        expect(ci.on).toBeTruthy();
+        expect(ci.jobs?.check).toBeTruthy();
+        expect(ciYml).toMatch(/bun run typecheck/);
+        expect(ciYml).toMatch(/bun test/);
+        const appTs = readFileSync(join(result.targetDir, "src/app.ts"), "utf8");
+        expect(appTs).not.toMatch(/Object\.assign/);
+        expect(appTs).not.toMatch(/env:\s*["']test["']/);
+        expect(appTs).toMatch(/stores:\s*\[/);
+        expect(appTs).toMatch(/oke\(\{[\s\S]*stores:/);
         const pkg = JSON.parse(readFileSync(join(result.targetDir, "package.json"), "utf8")) as {
           name: string;
           dependencies: { okengine: string };
+          scripts: { typecheck?: string; test?: string };
+          devDependencies: { typescript?: string };
         };
         expect(pkg.name).toBe(`app-${id}`);
         expect(pkg.dependencies.okengine).not.toMatch(/^file:\.\./);
+        expect(pkg.scripts.typecheck).toBe("tsc --noEmit");
+        expect(pkg.scripts.test).toBe("bun test");
+        expect(pkg.devDependencies.typescript).toBeTruthy();
       } finally {
         rmSync(dir, { recursive: true, force: true });
       }
@@ -566,17 +592,20 @@ describe("scaffold structure", () => {
         source: { kind: "template", id: "standard" },
       });
       for (const path of [
-        "src/gates.ts",
-        "src/vault.ts",
-        "src/channels.ts",
+        "src/core/gates.ts",
+        "src/core/vault.ts",
+        "src/core/channels.ts",
+        "src/core/store.ts",
+        "src/core/index.ts",
         "src/locales/en.ts",
         "src/locales/ar.ts",
         "src/flows/main/shapes.ts",
         "src/flows/main/signals.ts",
         "src/flows/notes/index.ts",
-        "src/core.ts",
-        "src/schema.decl.ts",
+        "src/db/schema.decl.ts",
+        "src/db/seed/index.ts",
         "src/app.ts",
+        ".vscode/settings.json",
       ]) {
         expect(result.files).toContain(path);
       }
@@ -604,7 +633,7 @@ describe("scaffold structure", () => {
       });
       expect(result.sqlDriver).toBe("postgres");
       // Abstract decl is dialect-agnostic — emit picks pgTable at sync time.
-      const decl = readFileSync(join(result.targetDir, "src/schema.decl.ts"), "utf8");
+      const decl = readFileSync(join(result.targetDir, "src/db/schema.decl.ts"), "utf8");
       expect(decl).toContain("store.schema.table(");
       expect(decl).not.toContain("sqliteTable");
       expect(decl).not.toContain("pgTable");

package/src/cli.ts

@@ -108,7 +108,7 @@ export function defaultsBranchOptions(
   const options: DefaultsBranchOption[] = [
     {
       value: "recommended",
-      label: "★  Yes, use recommended defaults",
+      label: "Yes, use recommended defaults",
       hint:
         template === "advanced"
           ? "Notes · docker-ready pins · .oke/mode docker"
@@ -118,13 +118,13 @@ export function defaultsBranchOptions(
   if (hasPreviousForTemplate) {
     options.push({
       value: "reuse",
-      label: "↻  No, reuse previous settings",
+      label: "No, reuse previous settings",
       hint: `~/.oke/create-defaults.json (${template})`,
     });
   }
   options.push({
     value: "customize",
-    label: "◆  No, customize settings",
+    label: "No, customize settings",
     hint:
       template === "standard"
         ? "local|docker · SQL · optional AI"
@@ -155,7 +155,7 @@ export type ScaffoldCallArgs = {
   readonly agentsMd: boolean;
   readonly sqlDriver: SqlDriverId;
   readonly createDefaults?: CreateDefaults;
-  /** Apply `src/ai.ts` + `.env.local` after scaffold (before install). */
+  /** Apply `src/core/ai.ts` + `.env.local` after scaffold (before install). */
   readonly aiApply?: AiSetupApplyInput | null;
 };
 
@@ -355,7 +355,8 @@ Template:
 ${templateLines}
 
 On a TTY: pick standard|advanced, then recommended defaults, customize
-(local or docker first; optional other side; saved to ~/.oke/create-defaults.json),
+(local or docker first; store.index with none; AI setup Recommended /
+Customize / Off; optional other side; saved to ~/.oke/create-defaults.json),
 or reuse when saved for that template. Non-TTY / --yes stay zero-prompt.
 `;
 }
@@ -398,7 +399,7 @@ export function scaffoldArgsFromCli(args: CliArgs): ScaffoldCallArgs {
     source: sourceFromArgs(args),
     agentsMd: args.agentsMd,
     sqlDriver: args.sqlDriver,
-    aiApply: args.ai === "force" ? nonInteractiveAiApply("ollama") : null,
+    aiApply: args.ai === "force" ? nonInteractiveAiApply("llama-cpp") : null,
   };
 }
 
@@ -512,7 +513,7 @@ export async function askInteractiveAnswers(
     message: "Starter template",
     options: TEMPLATES.map((id) => ({
       value: id,
-      label: id === "standard" ? "★  standard" : "◆  advanced",
+      label: id === "standard" ? "standard" : "advanced",
       hint: TEMPLATE_PURPOSES[id],
     })),
     initialValue: partial.template ?? DEFAULT_TEMPLATE,
@@ -604,7 +605,7 @@ export async function askInteractiveAnswers(
 }
 
 /**
- * Provider passed to `oke ai setup` — prefer Ollama when either env uses it.
+ * Provider passed to `oke ai setup` — prefer native Ollama when either env uses it.
  *
  * @param localProvider - Menu id chosen for local
  * @param pins - Resolved driver pins
@@ -612,9 +613,11 @@ export async function askInteractiveAnswers(
 export function aiSetupProviderFor(localProvider: string, pins: EnvDriverPins): string {
   if (localProvider === "ollama" || pins.local === "ollama") return "ollama";
   if (pins.docker === "ollama") return "ollama";
+  if (localProvider === "llama-cpp") return "llama-cpp";
+  if (localProvider === "vllm" || localProvider === "sglang") return localProvider;
   if (localProvider === "mock") {
     if (pins.docker === "anthropic") return "anthropic";
-    if (pins.docker === "openai-compatible") return "openai";
+    if (pins.docker === "openai-compatible") return "llama-cpp";
   }
   return localProvider;
 }
@@ -798,7 +801,7 @@ async function runScaffold(
     });
     if (spun) spun.stop("Scaffolded.");
 
-    // Models were chosen in the wizard — write env + src/ai.ts before install
+    // Models were chosen in the wizard — write env + src/core/ai.ts before install
     // so `--no-install` still gets a complete AI project. Preserve per-env
     // `drivers.ai` pins from customize; flatten only when pins were never written.
     if (runPostScaffold && aiApply) {
@@ -814,23 +817,25 @@ async function runScaffold(
     }
 
     if (runPostScaffold && install) {
-      const installSpun = interactive ? spinner() : undefined;
-      installSpun?.start("Installing dependencies…");
-      const installOk = await runCommand(["bun", "install"], targetDir);
+      // Inherit bun's progress — a silent spinner feels stuck on cold caches.
+      if (interactive) log.step("Installing dependencies…");
+      const installOk = await runCommand(["bun", "install"], targetDir, {
+        inherit: interactive,
+      });
       if (!installOk) {
-        installSpun?.stop("Install failed.");
+        if (interactive) log.error("Install failed.");
         cleanup();
         console.error("create-oke: bun install failed");
         return 1;
       }
-      installSpun?.stop("Installed.");
+      if (interactive) log.success("Installed.");
     }
 
     const message = nextStepsText(result);
     if (interactive) {
       note(
         [
-          `App      http://127.0.0.1:6530`,
+          `Backend  http://127.0.0.1:6530`,
           `Console  http://127.0.0.1:6533`,
           `MCP      http://127.0.0.1:6535`,
           `Docs     ${docsUrl("/docs")}`,

package/src/customize-flow.test.ts

@@ -3,8 +3,14 @@
  */
 
 import { describe, expect, test } from "bun:test";
-import { TEMPLATE_DOCKER_PROD, TEMPLATE_LOCAL, customizeFacetsFor } from "./drivers-catalog.ts";
-import { assembleDriverDefaults, pinsFromSides } from "./customize-flow.ts";
+import {
+  EMAIL_CHOICES,
+  INDEX_CHOICES,
+  TEMPLATE_DOCKER_PROD,
+  TEMPLATE_LOCAL,
+  customizeFacetsFor,
+} from "./drivers-catalog.ts";
+import { assembleDriverDefaults, pinsFromSides, recommendedAiApply } from "./customize-flow.ts";
 
 describe("customizeFacetsFor", () => {
   test("standard is lean (sql only)", () => {
@@ -16,7 +22,6 @@ describe("customizeFacetsFor", () => {
       "sql",
       "kv",
       "files",
-      "enableIndex",
       "index",
       "signal",
       "clock",
@@ -26,6 +31,35 @@ describe("customizeFacetsFor", () => {
   });
 });
 
+describe("catalog labels", () => {
+  test("store.index offers none before drivers", () => {
+    expect(INDEX_CHOICES.map((c) => c.value)).toEqual([
+      "none",
+      "memory",
+      "pgvector",
+      "libsql",
+      "meilisearch",
+    ]);
+  });
+
+  test("channel.email labels taqnyat-mail as taqnyat", () => {
+    const row = EMAIL_CHOICES.find((c) => c.value === "taqnyat-mail");
+    expect(row?.label).toBe("taqnyat");
+  });
+});
+
+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.baseUrl).toContain("8080");
+    expect(apply.image).toContain("llama.cpp");
+    expect(apply.image).not.toContain("latest");
+    expect(apply.visionModel).toBeNull();
+  });
+});
+
 describe("pinsFromSides", () => {
   test("prod copies docker", () => {
     expect(pinsFromSides("sqlite", "postgres", "memory")).toEqual({
@@ -38,7 +72,7 @@ describe("pinsFromSides", () => {
 });
 
 describe("assembleDriverDefaults", () => {
-  test("primary docker + decline other → local pins === template defaults", () => {
+  test("primary docker + skip other → local pins === template defaults", () => {
     const drivers = assembleDriverDefaults(
       "docker",
       { sql: "libsql", kv: "redis", files: "s3", signal: "nats" },
@@ -61,17 +95,13 @@ describe("assembleDriverDefaults", () => {
     expect(drivers.store.kv.docker).toBe(TEMPLATE_DOCKER_PROD.kv);
   });
 
-  test("index stays null unless enableIndex", () => {
-    const drivers = assembleDriverDefaults("local", { sql: "sqlite" }, null);
-    expect(drivers.store.index).toBeNull();
+  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();
   });
 
-  test("enableIndex on primary fills both columns", () => {
-    const drivers = assembleDriverDefaults(
-      "docker",
-      { enableIndex: true, index: "meilisearch" },
-      null,
-    );
+  test("index driver on primary fills both columns", () => {
+    const drivers = assembleDriverDefaults("docker", { index: "meilisearch" }, null);
     expect(drivers.store.index).toEqual({
       local: "memory",
       docker: "meilisearch",