jeo-code 0.4.6 → 0.4.8

package/src/tui/components/todo-card.ts

@@ -1,4 +1,6 @@
 import chalk from "chalk";
+import { padLineTo } from "./layout";
+import { visibleWidth } from "./color";
 
 export interface TodoCardItem {
   title: string;
@@ -8,40 +10,69 @@ export interface TodoCardItem {
 export interface TodoCardOptions {
   unicode?: boolean;
   color?: boolean;
+  /** Faint card background tint painter — gives the card a panel look so it reads
+   *  as a distinct block. Identity when absent (or colorless). */
+  fill?: (s: string) => string;
+  /** Muted foreground painter for secondary text (done/pending labels, count,
+   *  tree connectors). Replaces `chalk.dim`, which washes out on dark terminals. */
+  muted?: (s: string) => string;
+  /** Accent painter for the in_progress (active) item — the theme's highlight hue,
+   *  applied bold. Defaults to cyan so the active row matches the rest of the theme
+   *  instead of a hardcoded color that clashes on warm/green/red palettes. */
+  accent?: (s: string) => string;
+  /** Panel width: lines pad to this so the fill spans a clean rectangle. Clamped
+   *  to [20,120]; defaults to the longest content row + 2. */
+  width?: number;
 }
 
 /**
  * jeo-ref "Todo Write" scrollback card: a ✓-led header with a tree-connector
  * checklist — done items get ☑ + strikethrough, the active item highlights,
- * pending stays dim. Pure `string[]`; the caller flushes it into the ledger so
- * the plan's evolution (items checking off turn by turn) reads as transcript
- * history, exactly like the reference TUI.
+ * pending stays muted. A faint background tint (when a `fill` painter is given)
+ * makes the whole block read as a panel; secondary text uses a real muted hue
+ * instead of ANSI dim so completed rows stay legible. Pure `string[]`; the caller
+ * flushes it into the ledger so the plan's evolution reads as transcript history.
  */
 export function formatTodoWriteCard(items: TodoCardItem[], opts: TodoCardOptions = {}): string[] {
   if (items.length === 0) return [];
   const unicode = opts.unicode !== false;
   const color = opts.color !== false;
+  const fill = opts.fill ?? ((s: string) => s);
+  const muted = color ? (opts.muted ?? chalk.dim) : (s: string) => s;
+  const active = color ? (opts.accent ? (s: string) => chalk.bold(opts.accent!(s)) : chalk.cyan.bold) : (s: string) => s;
   const check = unicode ? "✓" : "v";
   const boxDone = unicode ? "☑" : "[x]";
   const boxOpen = unicode ? "☐" : "[ ]";
   const tee = unicode ? "├─" : "|-";
   const ell = unicode ? "└─" : "`-";
   const count = `${items.length} task${items.length === 1 ? "" : "s"}`;
-  const head = color
-    ? `${chalk.green(check)} ${chalk.bold("Todo Write")} ${chalk.dim(count)}`
-    : `${check} Todo Write ${count}`;
-  const lines = [head];
+
+  const rows: string[] = [];
+  rows.push(
+    color
+      ? `${chalk.green(check)} ${chalk.bold("Todo Write")} ${muted(count)}`
+      : `${check} Todo Write ${count}`,
+  );
   items.forEach((item, i) => {
-    const conn = i === items.length - 1 ? ell : tee;
+    const conn = color ? muted(i === items.length - 1 ? ell : tee) : i === items.length - 1 ? ell : tee;
     if (item.status === "done") {
       const box = color ? chalk.green(boxDone) : boxDone;
-      const label = color ? chalk.dim.strikethrough(item.title) : item.title;
-      lines.push(`  ${conn} ${box} ${label}`);
+      const label = color ? chalk.strikethrough(muted(item.title)) : item.title;
+      rows.push(`  ${conn} ${box} ${label}`);
     } else if (item.status === "in_progress") {
-      lines.push(`  ${conn} ${boxOpen} ${color ? chalk.cyan.bold(item.title) : item.title}`);
+      rows.push(`  ${conn} ${boxOpen} ${active(item.title)}`);
     } else {
-      lines.push(`  ${conn} ${boxOpen} ${color ? chalk.dim(item.title) : item.title}`);
+      rows.push(`  ${conn} ${boxOpen} ${color ? muted(item.title) : item.title}`);
     }
   });
-  return lines;
+
+  // Panel: pad each row (with a 1-col left gutter) to a common width and tint the
+  // whole rectangle — only when the caller opts in via `fill`/`width`; otherwise the
+  // bare tree-checklist rows return unchanged (back-compat). visibleWidth ignores
+  // ANSI, and every painter above closes with a TARGETED reset (never `\x1b[0m`), so
+  // the background spans the full row.
+  if (!opts.fill && opts.width === undefined) return rows;
+  const contentWidth = rows.reduce((m, r) => Math.max(m, visibleWidth(r)), 0) + 2;
+  const panelWidth = Math.max(20, Math.min(120, opts.width ?? contentWidth));
+  return rows.map(r => fill(padLineTo(` ${r}`, panelWidth, "left")));
 }

package/src/tui/components/width.ts

@@ -134,6 +134,57 @@ export function truncateToWidth(s: string, cols: number): string {
   return out;
 }
 
+/**
+ * Strip control bytes that would corrupt the live differential frame. KEEPS SGR color
+ * escapes (`\x1b[…m`); DROPS every other CSI (cursor moves, EL/ED erase, etc.), OSC
+ * sequences, other escapes, and bare C0/C1 control bytes except tab/newline; and DROPS
+ * an INCOMPLETE trailing escape (a chunk that ends mid-sequence) so it can never eat the
+ * next line's `\x1b[2K`. Used to sanitize raw child stdout (e.g. a streaming `bun test`
+ * with `\r\x1b[2K` progress lines) before it enters the frame — the torn-escape /
+ * cursor-hijack class of screen corruption.
+ */
+export function sanitizeForFrame(s: string): string {
+  if (!s.includes("\x1b") && !/[\x00-\x08\x0b-\x1f\x7f]/.test(s)) return s; // fast path
+  let out = "";
+  let i = 0;
+  const n = s.length;
+  while (i < n) {
+    const ch = s[i]!;
+    if (ch === "\x1b") {
+      if (s[i + 1] === "[") {
+        // CSI: ESC [ params (0-9;:?<>= space) final (@-~)
+        let j = i + 2;
+        while (j < n && /[0-9;:?<>= ]/.test(s[j]!)) j++;
+        if (j < n && /[@-~]/.test(s[j]!)) {
+          const seq = s.slice(i, j + 1);
+          if (seq.endsWith("m")) out += seq; // keep SGR color, drop all other CSI
+          i = j + 1;
+          continue;
+        }
+        break; // incomplete CSI at the chunk tail → drop the rest
+      }
+      if (s[i + 1] === "]") {
+        // OSC: ESC ] … (BEL | ST = ESC \)
+        let j = i + 2;
+        while (j < n && s[j] !== "\x07" && !(s[j] === "\x1b" && s[j + 1] === "\\")) j++;
+        if (j >= n) break; // incomplete OSC → drop
+        i = s[j] === "\x07" ? j + 1 : j + 2;
+        continue;
+      }
+      i += i + 1 < n ? 2 : 1; // other ESC x → drop ESC (+ its single byte)
+      continue;
+    }
+    const code = ch.charCodeAt(0);
+    if ((code < 0x20 && code !== 0x09 && code !== 0x0a) || code === 0x7f) {
+      i++; // strip bare control bytes (CR/BS/…), keep tab + newline
+      continue;
+    }
+    out += ch;
+    i++;
+  }
+  return out;
+}
+
 /**
  * Hard-wrap text to `cols` display columns, breaking long words and preserving
  * existing newlines. SGR-aware (escapes don't consume width). Returns the wrapped

package/src/tui/renderer.ts

@@ -51,17 +51,22 @@ export class Renderer {
     this.prevCols = currentCols;
 
     const next = lines.map(line => truncate(line, currentCols));
+    // Rows physically occupied by the prior frame — or recorded by reset() when the
+    // baseline was dropped WITHOUT clearing the screen. The diff below EL-clears any
+    // of these that the new (possibly shorter) frame does not cover, and the reserve
+    // block below uses it so a post-reset repaint does not spuriously re-scroll.
+    const occupied = Math.max(this.prev.length, this.coverRows);
     const maxLen = Math.max(this.prev.length, next.length, this.coverRows);
     this.coverRows = 0;
     let cursorRow = 0;
     let out = "";
 
-    if (this.reserve && next.length > this.prev.length && next.length <= Math.max(1, size().rows)) {
+    if (this.reserve && next.length > occupied && next.length <= Math.max(1, size().rows)) {
       // The cursor rests on the frame's first row (the anchor). Walk to the last
       // currently-occupied row, emit one newline per missing row (scrolling the
       // viewport when at the bottom margin), then hop back up to the — possibly
       // shifted — anchor so the diff below paints at stable relative positions.
-      const have = Math.max(this.prev.length, 1);
+      const have = Math.max(occupied, 1);
       out += cursorDown(have - 1) + "\n".repeat(next.length - have) + cursorUp(next.length - 1) + toColumn(1);
     }
 
@@ -92,16 +97,17 @@ export class Renderer {
     }
     out += toColumn(1);
 
-    // Close the synchronized update opened by insertAbove() now that the full
-    // repaint is in the same buffered stream — the terminal presents the overwritten
-    // first row(s), the flushed ledger line, and the repainted frame as ONE atomic update.
-    if (this.syncOpen) {
-      out += END_SYNC;
-      this.syncOpen = false;
-    }
-
+    // Atomic present (DECSET-2026 synchronized update): wrap the WHOLE repaint so the
+    // terminal never shows a half-painted frame — no torn row, no transient duplicate
+    // bar a mid-repaint snapshot could catch. An insertAbove() may have already opened
+    // the update (syncOpen); otherwise this render opens its own. Exactly one BSU/ESU
+    // pair is emitted per write.
     if (out.length > 0) {
-      this.write(out);
+      this.write((this.syncOpen ? "" : BEGIN_SYNC) + out + END_SYNC);
+      this.syncOpen = false;
+    } else if (this.syncOpen) {
+      this.write(END_SYNC);
+      this.syncOpen = false;
     }
 
     this.prev = next;
@@ -137,7 +143,13 @@ export class Renderer {
     // clamped cursor-down desynced the row bookkeeping — each subsequent frame then
     // painted one row higher, devouring the flushed scrollback content above (the
     // "truncated card" corruption).
-    const stale = this.prev.length - written;
+    // Use the same occupancy measure the reserve block uses (max of prev.length and
+    // coverRows). A reset() between frames drops prev but records coverRows; ignoring it
+    // here left the old frame's lower rows uncleared and the cursor below the true
+    // anchor, so the next render's cursorDown crossed the bottom margin and clamped —
+    // the persistent off-by-one that duplicated the model bar.
+    const occupied = Math.max(this.prev.length, this.coverRows);
+    const stale = occupied - written;
     if (stale > 0) {
       for (let i = 0; i < stale; i++) {
         out += toColumn(1) + clearLine() + (i < stale - 1 ? cursorDown(1) : "");
@@ -146,6 +158,7 @@ export class Renderer {
     }
     this.write(out);
     this.prev = [];
+    this.coverRows = 0; // consumed: the frame below is now the single source of truth
   }
 
   /** Clear the live frame. Inline (reserve) mode walks the known frame rows with
@@ -174,6 +187,19 @@ export class Renderer {
   }
 
   reset(): void {
+    // Drop the diff baseline so the next render() repaints every line — but REMEMBER
+    // how many rows are physically on screen so that repaint also EL-clears any the
+    // new (possibly shorter) frame doesn't cover. Without this, a self-heal reset on a
+    // frame that just shrank left stale rows behind (duplicate model bars / orphaned
+    // borders — the live-analysis screen corruption).
+    this.coverRows = Math.max(this.coverRows, this.prev.length);
     this.prev = [];
+    // Close any synchronized update opened by a preceding insertAbove() so a reset()
+    // landing between insertAbove() and the next render() cannot strand an open BSU
+    // window (which times out ~150ms later and flashes a partial frame).
+    if (this.syncOpen) {
+      this.write(END_SYNC);
+      this.syncOpen = false;
+    }
   }
 }

package/src/util/update-check.ts

@@ -1,5 +1,9 @@
 import pkg from "../../package.json";
 import { compareVersions } from "../commands/update";
+import * as os from "node:os";
+import * as path from "node:path";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { jeoEnv } from "./env";
 
 export interface UpdateCheckResult {
   current: string;
@@ -62,3 +66,52 @@ export async function checkForUpdate(deps?: UpdateCheckDeps): Promise<UpdateChec
     return null;
   }
 }
+
+// ---- Update-check disk cache ------------------------------------------------
+// The live npm check often loses the startup race, so the "New version" banner
+// rarely shows even when an update exists. Persisting the last-known-latest lets
+// the NEXT launch render the banner INSTANTLY from disk (and offline), while a
+// background refresh keeps the cache fresh. Mirrors gjc / npm update notices.
+
+interface CachedUpdateCheck {
+  latest: string;
+  checkedAt: number;
+}
+
+function updateCacheDir(): string {
+  return jeoEnv("CONFIG_DIR") || path.join(os.homedir(), ".jeo");
+}
+
+function updateCachePath(): string {
+  return path.join(updateCacheDir(), "update-check.json");
+}
+
+/** Last-known-latest from disk, re-evaluated against the CURRENT local version
+ *  (so an interim upgrade clears the banner). Null when no/invalid cache. */
+export async function readUpdateCache(localVersion: string = pkg.version): Promise<UpdateCheckResult | null> {
+  if (typeof localVersion !== "string" || !localVersion) return null;
+  try {
+    const raw = await readFile(updateCachePath(), "utf-8");
+    const data = JSON.parse(raw) as Partial<CachedUpdateCheck>;
+    if (!data || typeof data.latest !== "string" || !data.latest) return null;
+    return {
+      current: localVersion,
+      latest: data.latest,
+      updateAvailable: compareVersions(localVersion, data.latest) < 0,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** Persist the latest version for the next launch (best-effort; never throws). */
+export async function writeUpdateCache(latest: string): Promise<void> {
+  if (typeof latest !== "string" || !latest) return;
+  try {
+    await mkdir(updateCacheDir(), { recursive: true, mode: 0o700 });
+    const payload: CachedUpdateCheck = { latest, checkedAt: Date.now() };
+    await writeFile(updateCachePath(), JSON.stringify(payload, null, 2), { encoding: "utf-8", mode: 0o600 });
+  } catch {
+    // Cache is an optimization; a write failure must never break launch.
+  }
+}

package/src/commands/gjc.ts

@@ -1,52 +0,0 @@
-import { runAgentLoop, executorSystemPrompt, DEFAULT_TOOLS } from "../agent/engine";
-import { loadSkills, buildSkillTask, getSkillFrom } from "../skills/catalog";
-import { readGlobalConfig, isDevMode } from "../agent/state";
-import { runPostImplementationHooks } from "../agent/hooks";
-
-export async function runGjcCommand(args: string[]): Promise<void> {
-  const intent = args.join(" ").trim();
-  const config = await readGlobalConfig();
-  
-  if (intent.toLowerCase().includes("self-improve") && !isDevMode()) {
-    console.error("Error: Self-improvement tasks are only allowed in JEO_DEV_MODE=1.");
-    process.exit(1);
-  }
-
-  const model = config.defaultModel || "fast";
-  const skills = await loadSkills();
-  const gjcSkill = getSkillFrom(skills, "gjc");
-
-  if (!gjcSkill) {
-    console.error("Error: gjc skill not found.");
-    process.exit(1);
-  }
-
-  // Correct signature: executorSystemPrompt(role?, protocol?, verificationDirective?)
-  const systemPrompt = executorSystemPrompt();
-  const task = buildSkillTask(gjcSkill, intent);
-
-  await runAgentLoop([{ role: "user", content: task }], {
-    cwd: process.cwd(),
-    systemPrompt,
-    model,
-    tools: DEFAULT_TOOLS,
-    maxSteps: 50,
-  });
-
-  console.log("\n[jeo] Verifying implementation...");
-  const verify = await runPostImplementationHooks(process.cwd(), intent);
-  
-  if (!verify.success) {
-    console.error("\n[jeo] Verification FAILED. Auto-repairing...");
-    const repairTask = `Previous implementation failed verification.\nErrors:\n${verify.output}\n\nPlease fix.`;
-    await runAgentLoop([{ role: "user", content: repairTask }], {
-      cwd: process.cwd(),
-      systemPrompt,
-      model,
-      tools: DEFAULT_TOOLS,
-      maxSteps: 30,
-    });
-  } else {
-    console.log("\n[jeo] Verification SUCCESSFUL.");
-  }
-}

package/src/prompts/skills/gjc/AGENTS.md

@@ -1,31 +0,0 @@
-<!-- Parent: ../AGENTS.md -->
-<!-- Generated: 2026-06-11 | Updated: 2026-06-11 -->
-
-# gjc
-
-## Purpose
-Bundled SKILL.md for the `gjc` workflow.
-
-## Key Files
-| File | Description |
-|------|-------------|
-| `SKILL.md` | The primary skill definition |
-
-## Subdirectories
-*(None)*
-
-## For AI Agents
-
-### Working In This Directory
-- Do not modify this without understanding the broader workflow implications.
-
-### Testing Requirements
-- N/A
-
-### Common Patterns
-*(None)*
-
-## Dependencies
-*(None)*
-
-<!-- MANUAL: -->

package/src/prompts/skills/gjc/SKILL.md

@@ -1,15 +0,0 @@
----
-description: Main implementation process using gjc spec-first workflow.
-command: jeo gjc "<request>"
-when: When you need to perform significant code changes, refactoring, or feature development using the core gjc process.
----
-
-# gjc (Gajae-Code Process)
-
-Executes the primary code implementation workflow by leveraging the underlying `gjc` engine (jeo-claw).
-This process manages the heavy lifting of code transformation, while the surrounding `jeo-code` ecosystem handles loop-level orchestration.
-
-1. **Mutation Guard**: Ensures safe code writes by blocking operations until ambiguity is low (≤ 20%).
-2. **Role Delegation**: Utilizes specialized subagents (architect, planner, executor, critic) for focused tasks.
-3. **Loop Control**: Maintains a tight feedback loop between planning and execution.
-4. **Verification**: Automatically runs verification steps after implementation to ensure correctness.