create-oke 0.11.0 → 0.11.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-oke",
-  "version": "0.11.0",
+  "version": "0.11.2",
   "description": "Scaffold an okengine app — bunx create-oke@latest <name>",
   "license": "MIT",
   "repository": {

package/src/ai-setup/apply.ts

@@ -192,9 +192,27 @@ export function renderAiTs(input: AiSetupApplyInput): string {
   const lines = [
     `import { ai } from "okengine";`,
     ``,
+    `/** Cloud OpenAI-compatible binding (OpenAI / Groq / OpenRouter / …). */`,
     `export const smart = ai.model("smart", {`,
     `  provider: "${provider}",`,
-    `  model: process.env.OKE_AI_MODEL ?? "${chat}",`,
+    `  model: process.env.OKE_AI_CLOUD_MODEL ?? process.env.OKE_AI_MODEL ?? "${chat}",`,
+    `  baseUrl: process.env.OPENAI_BASE_URL?.trim() || "https://api.openai.com/v1",`,
+    `  ...(process.env.OPENAI_API_KEY?.trim()`,
+    `    ? { apiKey: process.env.OPENAI_API_KEY.trim() }`,
+    `    : {}),`,
+    `});`,
+    ``,
+    `/** Local inference binding (docker llama.cpp / Ollama via \`OKE_AI_URL\`). */`,
+    `export const local = ai.model("local", {`,
+    `  provider: "${provider === "ollama" ? "ollama" : "openai-compatible"}",`,
+    `  model: process.env.OKE_AI_LOCAL_MODEL ?? "${chat}",`,
+    `  ...(process.env.OKE_AI_URL?.trim() ? { baseUrl: process.env.OKE_AI_URL.trim() } : {}),`,
+    `});`,
+    ``,
+    `/** Advanced Notes summarize — used by \`notes.summarize\` via \`fx.ask\`. */`,
+    `export const summarizeNote = smart.prompt("summarize-note", {`,
+    `  via: ["smart", "local"],`,
+    `  timeout: "30s",`,
     `});`,
   ];
 
@@ -249,6 +267,10 @@ function writeAiModels(cwd: string, input: AiSetupApplyInput): string {
   if (existsSync(coreTsPath)) {
     const existing = readFileSync(coreTsPath, "utf8");
     if (hasAiModels(existing)) {
+      const withPrompt = ensureSummarizeNotePrompt(existing);
+      if (withPrompt !== existing) {
+        writeFileSync(coreTsPath, withPrompt, "utf8");
+      }
       return coreTsPath;
     }
     writeFileSync(coreTsPath, mergeAiIntoCore(existing, rendered), "utf8");
@@ -270,6 +292,44 @@ function hasAiModels(source: string): boolean {
   );
 }
 
+/**
+ * Append the advanced Notes `summarize-note` prompt when a `smart` model
+ * exists but the prompt was never declared (common after older `--ai` runs).
+ *
+ * @param source - Existing `src/core.ts` (or AI sidecar) source
+ */
+export function ensureSummarizeNotePrompt(source: string): string {
+  let next = source;
+  if (
+    !/\bai\.model\s*\(\s*["']local["']/.test(next) &&
+    /\bai\.model\s*\(\s*["']smart["']/.test(next)
+  ) {
+    next = `${next.trimEnd()}
+
+/** Local inference binding (docker llama.cpp / Ollama via \`OKE_AI_URL\`). */
+export const local = ai.model("local", {
+  provider: "openai-compatible",
+  model: process.env.OKE_AI_LOCAL_MODEL ?? "granite3.3:2b",
+  ...(process.env.OKE_AI_URL?.trim() ? { baseUrl: process.env.OKE_AI_URL.trim() } : {}),
+});
+`;
+  }
+  if (/summarize-note/.test(next) || /summarizeNote/.test(next)) {
+    return next;
+  }
+  if (!/\bai\.model\s*\(\s*["']smart["']/.test(next)) {
+    return next;
+  }
+  const prompt = `
+/** Advanced Notes summarize — used by \`notes.summarize\` via \`fx.ask\`. */
+export const summarizeNote = smart.prompt("summarize-note", {
+  via: ["smart", "local"],
+  timeout: "30s",
+});
+`;
+  return `${next.trimEnd()}\n${prompt}\n`;
+}
+
 /**
  * Merge rendered AI module into an existing `src/core.ts`.
  *

package/src/cli.test.ts

@@ -27,6 +27,7 @@ import {
   shouldPrompt,
   sourceFromArgs,
   withBackOption,
+  withLocalesPgDog,
   type InteractiveAnswers,
 } from "./cli.ts";
 import {
@@ -46,6 +47,55 @@ import {
   transformPackageJson,
 } from "./transform.ts";
 
+describe("withLocalesPgDog", () => {
+  test("updates session defaults (reuse / customize)", () => {
+    const session = recommendedDefaults("docker-ready", "advanced");
+    const next = withLocalesPgDog({
+      template: "advanced",
+      locales: ["ar"],
+      pgdog: true,
+      session,
+      previous: null,
+    });
+    expect(next.template).toBe("advanced");
+    expect(next.locales).toEqual(["ar"]);
+    expect(next.pgdog).toBe(true);
+    expect(next.drivers.store.sql.dev).toBe(session.drivers.store.sql.dev);
+  });
+
+  test("updates previous settings when recommended has no session", () => {
+    const previous = {
+      ...recommendedDefaults("docker-ready", "advanced"),
+      locales: [] as const,
+      pgdog: false,
+    };
+    const next = withLocalesPgDog({
+      template: "advanced",
+      locales: ["ar", "fr"],
+      pgdog: true,
+      session: undefined,
+      previous,
+    });
+    expect(next.locales).toEqual(["ar", "fr"]);
+    expect(next.pgdog).toBe(true);
+    expect(next.drivers).toEqual(previous.drivers);
+  });
+
+  test("falls back to recommended pins when nothing is saved", () => {
+    const next = withLocalesPgDog({
+      template: "standard",
+      locales: ["ar"],
+      pgdog: true,
+      session: undefined,
+      previous: null,
+    });
+    expect(next.template).toBe("standard");
+    expect(next.locales).toEqual(["ar"]);
+    expect(next.pgdog).toBe(true);
+    expect(next.profile).toBe("docker-ready");
+  });
+});
+
 describe("defaultsBranchOptions", () => {
   test("hides reuse when no previous settings exist", () => {
     const values = defaultsBranchOptions(false).map((o) => o.value);

package/src/cli.ts

@@ -39,6 +39,7 @@ import {
 } from "./ai-setup/from-pref.ts";
 import { askAiSetup } from "./ai-setup/prompts.ts";
 import { askCustomizeFlow } from "./customize-flow.ts";
+import { recommendedDefaults } from "./drivers-catalog.ts";
 import { parseExtraLocales } from "./locales.ts";
 import {
   scaffold,
@@ -406,8 +407,9 @@ ${templateLines}
 
 On a TTY: pick standard|advanced, then recommended defaults, customize
 (Docker-first facets; store.index with none; AI setup Recommended /
-Customize / Off; saved to ~/.oke/create-defaults.json),
-optional extra locales + PgDog pooling, or reuse when saved for that template.
+Customize / Off), optional extra locales + PgDog pooling, or reuse when
+saved for that template. Locales + PgDog (and customize pins) write to
+~/.oke/create-defaults.json on every TTY run.
 Non-TTY / --yes stay English-only / no PgDog unless --locales / --pgdog.
 `;
 }
@@ -528,6 +530,35 @@ export type CreateDefaultsIo = {
   readonly write: (defaults: CreateDefaults) => void;
 };
 
+/**
+ * Merge wizard locales / PgDog into a create-defaults document to persist.
+ *
+ * Prefer the in-session answers (customize / reuse), else same-template
+ * previous settings, else recommended pins for the template.
+ *
+ * @param input - Template, locales, pgdog, and optional session / previous docs
+ */
+export function withLocalesPgDog(input: {
+  readonly template: TemplateId;
+  readonly locales: readonly string[];
+  readonly pgdog: boolean;
+  readonly session: CreateDefaults | undefined;
+  readonly previous: CreateDefaults | null;
+}): CreateDefaults {
+  const { template, locales, pgdog, session, previous } = input;
+  const base =
+    session ??
+    (previous?.template === template ? previous : null) ??
+    recommendedDefaults("docker-ready", template);
+  return {
+    ...base,
+    template,
+    locales,
+    pgdog,
+    updatedAt: new Date().toISOString(),
+  };
+}
+
 /**
  * Collect interactive answers via `@clack/prompts`.
  *
@@ -664,16 +695,20 @@ export async function askInteractiveAnswers(
     }
   }
 
+  // Locales / PgDog are asked on every TTY run — always persist them so reuse
+  // (and recommended) keep the last answers in ~/.oke/create-defaults.json.
+  const persisted = withLocalesPgDog({
+    template,
+    locales,
+    pgdog,
+    session: createDefaults,
+    previous: io.read(),
+  });
   if (createDefaults) {
-    createDefaults = {
-      ...createDefaults,
-      locales,
-      pgdog,
-      updatedAt: new Date().toISOString(),
-    };
+    createDefaults = persisted;
   }
-  if (persistDefaults && createDefaults) {
-    io.write(createDefaults);
+  io.write(persisted);
+  if (persistDefaults) {
     note(`Saved globally for next projects → ${io.path}`, "Defaults");
   }
 

package/src/customize-flow.test.ts

@@ -48,13 +48,20 @@ describe("catalog labels", () => {
 
 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("granite3.3:2b");
-    expect(apply.baseUrl).toContain("8080");
-    expect(apply.image).toContain("llama.cpp");
-    expect(apply.image).not.toContain("latest");
-    expect(apply.visionModel).toBeNull();
+    const prev = process.env.OKE_AI_URL;
+    delete process.env.OKE_AI_URL;
+    try {
+      const apply = recommendedAiApply();
+      expect(apply.driver).toBe("openai-compatible");
+      expect(apply.chatModel).toBe("granite3.3:2b");
+      expect(apply.baseUrl).toContain("8080");
+      expect(apply.image).toContain("llama.cpp");
+      expect(apply.image).not.toContain("latest");
+      expect(apply.visionModel).toBeNull();
+    } finally {
+      if (prev !== undefined) process.env.OKE_AI_URL = prev;
+      else delete process.env.OKE_AI_URL;
+    }
   });
 });
 

package/templates/advanced/src/db/seed/index.ts

@@ -53,7 +53,7 @@ async function sampleNotes(fx: Fx) {
     {
       id: "sample-summarize",
       title: "Try summarize",
-      body: "POST /notes/:id/summarize uses fx.ask when AI is configured, else a local excerpt.",
+      body: "POST /notes/:id/summarize uses fx.ask with the prompt's via recovery chain.",
       archivedAt: null,
       createdAt: 4,
     },

package/templates/advanced/src/flows/notes/index.ts

@@ -14,12 +14,54 @@ import {
   NoteSummarizeIn,
   NoteSummarizeOut,
   NotFound,
+  Unavailable,
 } from "./shapes";
 import { noteCreated } from "./signals";
 
 import "./shapes";
 import "./signals";
 
+/**
+ * Pull a usable summary string from an `fx.ask` payload.
+ *
+ * @param out - Model output object
+ */
+function extractSummary(out: unknown): string {
+  if (typeof out === "string") return unwrapSummaryText(out);
+  if (!out || typeof out !== "object") return "";
+  const record = out as Record<string, unknown>;
+  if (typeof record.summary === "string") return record.summary.trim();
+  if (typeof record.text === "string") return unwrapSummaryText(record.text);
+  return "";
+}
+
+/**
+ * Local models sometimes return over-escaped JSON (`{\\"summary\\":...}`).
+ * Peel one or two JSON layers, then fall back to the raw text.
+ *
+ * @param text - Model text payload
+ */
+function unwrapSummaryText(text: string): string {
+  let current = text.trim();
+  for (let i = 0; i < 2; i++) {
+    if (!(current.startsWith("{") || current.startsWith('"'))) break;
+    try {
+      const parsed = JSON.parse(current) as unknown;
+      if (typeof parsed === "string") {
+        current = parsed.trim();
+        continue;
+      }
+      if (parsed && typeof parsed === "object" && "summary" in parsed) {
+        return String((parsed as { summary: unknown }).summary).trim();
+      }
+      break;
+    } catch {
+      break;
+    }
+  }
+  return current;
+}
+
 /** List active (non-archived) notes, newest first. */
 export const list = on(
   http.get("/notes").gate(gate.public),
@@ -162,32 +204,37 @@ export const digest = on(
 );
 
 /**
- * Summarize a note via AI when configured (`oke ai setup` / create-oke --ai).
- * Without an AI runtime, returns a local fallback excerpt.
+ * Summarize a note via the prompt's declared recovery chain.
+ * Exhausted / failed asks surface as Unavailable — never a body excerpt.
  */
 export const summarize = on(
   http.post("/notes/:id/summarize").gate(gate.public),
   flow("notes.summarize", {
     in: NoteSummarizeIn,
     out: NoteSummarizeOut,
-    errors: { NotFound },
+    errors: { NotFound, Unavailable },
     do: async (input, fx) => {
       const row = await fx.store(db).findById(notes, input.id);
       if (!row) return fail("NotFound", { id: input.id });
-      const body = String(row.body);
       try {
         const out = await fx.ask("summarize-note", {
+          instruction:
+            'Summarize this note in one or two sentences. Reply with JSON only: {"summary":"..."}',
           title: String(row.title),
-          body,
+          body: String(row.body),
         });
-        const summary =
-          typeof out === "object" && out !== null && "summary" in out
-            ? String((out as { summary: unknown }).summary)
-            : JSON.stringify(out);
-        return { id: input.id, summary, via: "ai" as const };
+        const summary = extractSummary(out);
+        const via = typeof out.via === "string" ? out.via.trim() : "";
+        if (!summary || !via) {
+          return fail("Unavailable", {
+            message: "AI service unavailable. Try again later.",
+          });
+        }
+        return { id: input.id, summary, via };
       } catch {
-        const summary = body.length > 160 ? `${body.slice(0, 157)}…` : body;
-        return { id: input.id, summary, via: "fallback" as const };
+        return fail("Unavailable", {
+          message: "AI service unavailable. Try again later.",
+        });
       }
     },
   }),

package/templates/advanced/src/flows/notes/shapes.ts

@@ -48,5 +48,11 @@ export const NoteSummarizeIn = z.object({
 export const NoteSummarizeOut = z.object({
   id: z.string(),
   summary: z.string(),
-  via: z.enum(["ai", "fallback"]),
+  /** Logical model name that answered (`smart`, `local`, …). */
+  via: z.string().min(1),
+});
+
+/** Both recovery links failed — no silent text excerpt. */
+export const Unavailable = z.object({
+  message: z.string(),
 });

package/templates/advanced/tests/advanced.test.ts

@@ -18,7 +18,7 @@ test("boots — health flow is named main.health", async () => {
   expect(data).toEqual({ ok: true });
 });
 
-test("notes create → attach → summarize fallback → archive", async () => {
+test("notes create → attach → summarize → archive", async () => {
   const created = await t.api.notes!.create!({
     title: "Advanced",
     body: "Body long enough to exercise attach and summarize paths in the advanced starter.",
@@ -32,10 +32,11 @@ test("notes create → attach → summarize fallback → archive", async () => {
   expect(attached.error).toBeNull();
   expect((attached.data as { key: string }).key).toBe(`notes/${id}/attachment.txt`);
 
+  t.ai.mock("summarize-note", { summary: "Advanced starter summary." });
   const summary = await t.api.notes!.summarize!({ id });
   expect(summary.error).toBeNull();
   const out = summary.data as { via: string; summary: string };
-  expect(out.via).toBe("fallback");
+  expect(out.via.length).toBeGreaterThan(0);
   expect(out.summary.length).toBeGreaterThan(0);
 
   const archived = await t.api.notes!.archive!({ id });