@10et/cli 1.0.0

package/packages/pi/extensions/onboarding-v2.ts

@@ -0,0 +1,374 @@
+/**
+ * Onboarding V2 — Cinematic boot sequence
+ *
+ * Visual-only startup overlay. Shows the SATOR square animation and
+ * live system probes, then dismisses. No project data — that comes
+ * from the startup briefing steer which fires after this overlay closes.
+ *
+ * Flow: SATOR square → system probes → project name → dismiss
+ *
+ * The header (header.ts) owns persistent identity. This overlay owns
+ * the first-impression cinematic moment. The startup briefing (steer)
+ * owns the data-rich greeting that follows.
+ *
+ * @purpose Cinematic boot overlay — SATOR square + system health probes
+ */
+
+import { existsSync, readFileSync, readdirSync } from "fs"
+import { join } from "path"
+import { execSync } from "child_process"
+import type { PiContext, PiTheme, JflConfig } from "./types.js"
+import { setHeaderHubStatus, setHeaderAutoCommit, refreshHeaderData } from "./header.js"
+
+// ─── Colors ──────────────────────────────────────────────────────────────────
+
+const GOLD = "warning"
+const DIM = "muted"
+const WARM = "text"
+const RED = "error"
+const GREEN = "success"
+
+// ─── Sator Square ────────────────────────────────────────────────────────────
+
+const SATOR = [
+  ["S","A","T","O","R"],
+  ["A","R","E","P","O"],
+  ["T","E","N","E","T"],
+  ["O","P","E","R","A"],
+  ["R","O","T","A","S"],
+]
+const TENET_ROW = 2
+
+// ─── Types ───────────────────────────────────────────────────────────────────
+
+interface Sys {
+  name: string
+  status: "wait" | "probe" | "ok" | "err"
+  detail: string
+}
+
+// ─── Probes ──────────────────────────────────────────────────────────────────
+
+async function probeHub(root: string): Promise<{ok: boolean; detail: string}> {
+  const port = readPort(root)
+  for (let i = 0; i < 4; i++) {
+    try {
+      const r = await fetch(`http://localhost:${port}/health`, { signal: AbortSignal.timeout(2000) })
+      if (r.ok) { const d = await r.json() as any; if (d.status === "ok") return {ok:true, detail:`:${port}`} }
+    } catch {}
+    if (i < 3) await sleep(700)
+  }
+  return {ok:false, detail:"offline"}
+}
+
+async function probeContext(root: string): Promise<{ok: boolean; detail: string}> {
+  const port = readPort(root), token = readToken(root)
+  for (let i = 0; i < 3; i++) {
+    try {
+      const r = await fetch(`http://localhost:${port}/api/context`, {
+        method: "POST",
+        headers: {"Content-Type":"application/json", ...(token ? {Authorization:`Bearer ${token}`} : {})},
+        body: JSON.stringify({maxItems:1}),
+        signal: AbortSignal.timeout(2000),
+      })
+      if (r.ok) return {ok:true, detail:"loaded"}
+    } catch {}
+    if (i < 2) await sleep(700)
+  }
+  return {ok:false, detail:"waiting…"}
+}
+
+async function probeMemory(root: string): Promise<{ok: boolean; detail: string}> {
+  const dir = join(root, ".jfl", "journal")
+  if (!existsSync(dir)) return {ok:false, detail:"none"}
+  try {
+    let n = 0
+    for (const f of readdirSync(dir).filter(f => f.endsWith(".jsonl")))
+      n += readFileSync(join(dir, f), "utf-8").trim().split("\n").filter(Boolean).length
+    return {ok:true, detail:`${n} entries`}
+  } catch { return {ok:false, detail:"err"} }
+}
+
+async function probeAutoCommit(): Promise<{ok: boolean; detail: string}> {
+  for (let i = 0; i < 4; i++) {
+    try {
+      if (execSync("ps aux", {timeout:2000, encoding:"utf-8", stdio:["pipe","pipe","ignore"]}).includes("auto-commit.sh"))
+        return {ok:true, detail:"watching"}
+    } catch {}
+    if (i < 3) await sleep(1000)
+  }
+  return {ok:false, detail:"–"}
+}
+
+async function probeEval(root: string): Promise<{ok: boolean; detail: string}> {
+  const p = join(root, ".jfl", "eval.jsonl")
+  if (!existsSync(p)) return {ok:false, detail:"—"}
+  try {
+    const lines = readFileSync(p, "utf-8").trim().split("\n").filter(Boolean)
+    for (let i = lines.length-1; i >= Math.max(0, lines.length-20); i--) {
+      try { const e = JSON.parse(lines[i]); const s = e.composite ?? e.score; if (s != null) return {ok:true, detail:Number(s).toFixed(2)} } catch {}
+    }
+    return {ok:true, detail:`${lines.length} runs`}
+  } catch { return {ok:false, detail:"err"} }
+}
+
+async function probeTraining(root: string): Promise<{ok: boolean; detail: string}> {
+  const p = join(root, ".jfl", "training-buffer.jsonl")
+  if (!existsSync(p)) return {ok:false, detail:"—"}
+  try {
+    return {ok:true, detail:`${readFileSync(p,"utf-8").trim().split("\n").filter(Boolean).length} tuples`}
+  } catch { return {ok:false, detail:"err"} }
+}
+
+function readPort(root: string): string {
+  const f = join(root, ".jfl", "context-hub.port")
+  return existsSync(f) ? readFileSync(f, "utf-8").trim() : "4360"
+}
+function readToken(root: string): string {
+  const f = join(root, ".jfl", "context-hub.token")
+  return existsSync(f) ? readFileSync(f, "utf-8").trim() : ""
+}
+function sleep(ms: number) { return new Promise(r => setTimeout(r, ms)) }
+
+// ─── Main ────────────────────────────────────────────────────────────────────
+
+export async function setupOnboarding(ctx: PiContext, config: JflConfig): Promise<void> {
+  const root = ctx.session.projectRoot
+  if (!ctx.ui.hasUI) return
+
+  const projectName = config.name ?? root.split("/").pop() ?? "TENET"
+  const branch = ctx.session.branch
+
+  const systems: Sys[] = [
+    {name:"Hub",         status:"wait", detail:""},
+    {name:"Context",     status:"wait", detail:""},
+    {name:"Memory",      status:"wait", detail:""},
+    {name:"Auto-commit", status:"wait", detail:""},
+    {name:"Eval",        status:"wait", detail:""},
+    {name:"Training",    status:"wait", detail:""},
+  ]
+
+  const probes = [
+    () => probeHub(root),
+    () => probeContext(root),
+    () => probeMemory(root),
+    () => probeAutoCommit(),
+    () => probeEval(root),
+    () => probeTraining(root),
+  ]
+
+  await ctx.ui.custom<void>((tui: any, theme: PiTheme, _kb: any, done: (r: void) => void) => {
+    let phase: "square"|"glow"|"systems"|"ready" = "square"
+    let sqProg = 0
+    let glow = false
+    let sysRevealed = 0
+    let readyTick = 0
+    let timer: ReturnType<typeof setTimeout>|null = null
+    let dead = false
+
+    // ── Timing ──
+    const SQ_MS    = 40       // per letter (faster)
+    const GLOW_MS  = 500      // hold after square
+    const GLW2SYS  = 300      // glow → systems
+    const SYS_MS   = 180      // per system row reveal
+    const SETTLE   = 150      // probe settle poll
+    const RDY_HOLD = 1200     // show ready then auto-dismiss
+
+    function tick(fn: () => void, ms: number) {
+      if (dead) return
+      timer = setTimeout(() => { if (!dead) { fn(); tui.requestRender() } }, ms)
+    }
+
+    // ── Color helpers ──
+    const g  = (s: string) => theme.fg(GOLD, s)
+    const d  = (s: string) => theme.fg(DIM, s)
+    const w  = (s: string) => theme.fg(WARM, s)
+    const gr = (s: string) => theme.fg(GREEN, s)
+    const rd = (s: string) => theme.fg(RED, s)
+
+    // ── ANSI helpers ──
+    function stripLen(s: string) { return s.replace(/\x1b\[[0-9;]*m/g, "").length }
+    function pad(line: string, width: number) {
+      return line + " ".repeat(Math.max(0, width - stripLen(line)))
+    }
+    function center(text: string, width: number) {
+      const vis = stripLen(text)
+      const left = Math.max(0, Math.floor((width - vis) / 2))
+      return " ".repeat(left) + text
+    }
+
+    // ── Phase: Square ──
+    function doSquare() {
+      if (sqProg < 25) { sqProg++; tick(doSquare, SQ_MS) }
+      else tick(() => { glow = true; phase = "glow"; tick(doSystems, GLW2SYS) }, GLOW_MS)
+    }
+
+    // ── Phase: Systems ──
+    function doSystems() {
+      phase = "systems"
+      // Fire all probes in parallel
+      systems.forEach((s, i) => {
+        s.status = "probe"
+        probes[i]().then(r => {
+          s.status = r.ok ? "ok" : "err"
+          s.detail = r.detail
+          // Feed results back to the persistent header
+          if (i === 0) setHeaderHubStatus(r.ok)       // Hub
+          if (i === 3) setHeaderAutoCommit(r.ok)       // Auto-commit
+          tui.requestRender()
+        }).catch(() => {
+          s.status = "err"
+          s.detail = "timeout"
+          tui.requestRender()
+        })
+      })
+      revealSys()
+    }
+
+    function revealSys() {
+      if (sysRevealed < systems.length) { sysRevealed++; tick(revealSys, SYS_MS) }
+      else waitProbes()
+    }
+
+    function waitProbes() {
+      if (systems.some(s => s.status === "probe")) tick(waitProbes, SETTLE)
+      else {
+        // Refresh header with final probe data
+        refreshHeaderData(root, config)
+        tick(doReady, 200)
+      }
+    }
+
+    // ── Phase: Ready ──
+    function doReady() {
+      phase = "ready"
+      readyTick = 0
+      tickReady()
+    }
+    function tickReady() {
+      if (readyTick < 3) { readyTick++; tick(tickReady, 250) }
+      else tick(() => { if (!dead) done(undefined) }, RDY_HOLD)
+    }
+
+    // Kick off
+    tick(doSquare, 100)
+
+    // ── Renderers ──
+
+    function renderSquare(W: number): string[] {
+      const out: string[] = []
+      const cw = 5 * 4 - 1 // "S   A   T   O   R"
+      const lp = " ".repeat(Math.max(0, Math.floor((W - cw) / 2)))
+      for (let r = 0; r < 5; r++) {
+        let line = ""
+        for (let c = 0; c < 5; c++) {
+          const idx = r * 5 + c
+          const ch = SATOR[r][c]
+          if (idx < sqProg) {
+            if (glow && r === TENET_ROW) line += theme.bold(g(ch))
+            else if (glow) line += d(ch)
+            else line += d(ch)
+          } else {
+            line += d("·")
+          }
+          if (c < 4) line += "   "
+        }
+        out.push(lp + line)
+        if (r < 4) out.push("") // spacing between rows
+      }
+      return out
+    }
+
+    function renderSystems(W: number): string[] {
+      const out: string[] = []
+      const inner = Math.min(W - 4, 48)
+      const lp = " ".repeat(Math.max(0, Math.floor((W - inner) / 2)))
+
+      for (let i = 0; i < Math.min(sysRevealed, systems.length); i++) {
+        const s = systems[i]
+        const nm = s.name.padEnd(13)
+        let icon: string, name: string, det: string
+        if (s.status === "ok")         { icon = gr("✓"); name = w(nm); det = d(s.detail) }
+        else if (s.status === "err")   { icon = rd("✗"); name = rd(nm); det = rd(s.detail) }
+        else if (s.status === "probe") { icon = d("◌"); name = d(nm); det = d("…") }
+        else                           { icon = d("○"); name = d(nm); det = d("") }
+        out.push(`${lp}  ${icon}  ${name} ${det}`)
+      }
+      return out
+    }
+
+    function renderReady(W: number): string[] {
+      const out: string[] = []
+      const sep = d(" · ")
+      out.push("")
+      if (readyTick >= 1) out.push(center(theme.bold(g(projectName.toUpperCase())), W))
+      if (readyTick >= 2) out.push(center(d(branch), W))
+      if (readyTick >= 3) {
+        // Count how many probes passed
+        const ok = systems.filter(s => s.status === "ok").length
+        const total = systems.length
+        const allGood = ok === total
+        const statusText = allGood
+          ? gr("all systems nominal")
+          : g(`${ok}/${total} systems`)
+        out.push(center(statusText, W))
+      }
+      return out
+    }
+
+    // ── Main render ──
+    return {
+      handleInput(key: string) {
+        if (key === "\x1b" || key === "q" || key === " " || key === "\r") {
+          if (timer) clearTimeout(timer)
+          dead = true
+          done(undefined)
+        }
+      },
+
+      render(width: number): string[] {
+        const W = width
+        const H = process.stdout?.rows || 40
+        const content: string[] = []
+
+        // Square
+        content.push(...renderSquare(W))
+        if (phase !== "square" && phase !== "glow") content.push("")
+
+        // Systems
+        if (phase === "systems" || phase === "ready") {
+          content.push(...renderSystems(W))
+        }
+
+        // Ready
+        if (phase === "ready") {
+          content.push(...renderReady(W))
+        }
+
+        // Skip hint (during animation only)
+        if (phase === "square" || phase === "glow" || phase === "systems") {
+          content.push("", center(d("press any key to skip"), W))
+        }
+
+        // Vertically center, fill everything with blanks (covers Pi startup)
+        const topPad = Math.max(1, Math.floor((H - content.length) / 2))
+        const out: string[] = []
+        for (let i = 0; i < topPad; i++) out.push(" ".repeat(W))
+        for (const line of content) out.push(pad(line, W))
+        while (out.length < H) out.push(" ".repeat(W))
+
+        return out
+      },
+
+      invalidate() {},
+    }
+  }, {
+    overlay: true,
+    overlayOptions: {
+      dismissOnEscape: false,
+      width: "100%",
+      height: "100%",
+      anchor: "top-left",
+    },
+  })
+}