@namzu/cli 2.6.0 → 3.0.0

package/dist/tui/bottom-spacer.js

@@ -0,0 +1,83 @@
+/**
+ * How many blank rows to put above the composer so it sits at the bottom.
+ *
+ * ## The narrow defect
+ *
+ * Ink writes the transcript to native scrollback via `<Static>` and re-renders
+ * the live region — activity, composer, status bar — beneath it. Once the
+ * output exceeds the viewport the terminal has scrolled, and the composer is
+ * already at the bottom. The complaint is entirely the case before that: five
+ * lines on a forty-row terminal leaves the composer at row six with blank space
+ * under it, and the operator's eye has to find it.
+ *
+ * So this does not try to pin the composer always. It pads only while the
+ * transcript is unambiguously shorter than the viewport, and returns 0 the
+ * moment that stops being knowable. After that, the terminal does it.
+ *
+ * ## Why a rough estimate is safe here, and would not be in general
+ *
+ * The rendered height of a transcript is not knowable from this side: ink does
+ * not report it, and wrapping depends on ANSI, wide glyphs and markdown that
+ * this module does not model. That is exactly why the whole-session version of
+ * this idea is a bad one.
+ *
+ * It is safe in the short case because the error is **asymmetric**:
+ *
+ * - Overestimate the content ⇒ pad less, or not at all ⇒ the composer floats,
+ *   which is precisely today's behaviour. No worse than not doing this.
+ * - Underestimate the content ⇒ pad too much ⇒ the composer is pushed off the
+ *   bottom, which is worse than today.
+ *
+ * So every uncertainty is resolved toward *more* content and *less* padding:
+ * `estimateRenderedLines` counts a minimum, {@link SAFETY_ROWS} is subtracted
+ * on top, and anything unknown returns 0. Being wrong costs the feature, never
+ * the usability.
+ */
+/**
+ * Rows held back from the calculation.
+ *
+ * Absorbs what the estimate cannot see — a wrapped line the width maths missed,
+ * a wide glyph, a markdown block that renders taller than its source. Six is
+ * chosen to be visibly generous rather than tuned: the cost of it being too
+ * large is a small gap under the composer on a nearly-empty screen, and the
+ * cost of it being too small is a composer pushed out of view.
+ */
+export const SAFETY_ROWS = 6;
+/**
+ * A deliberate UNDER-count of how tall the transcript will render.
+ *
+ * Under, not over, because it is subtracted from the space available: counting
+ * low leaves more apparent room, and the safety margin plus the guard below are
+ * what stop that becoming padding. Each entry is at least one row, and a long
+ * entry is divided by the width to approximate wrapping.
+ */
+export function estimateRenderedLines(transcript, columns) {
+    const width = Math.max(20, columns ?? 80);
+    let total = 0;
+    for (const entry of transcript) {
+        for (const line of entry.split('\n')) {
+            total += Math.max(1, Math.ceil(line.length / width));
+        }
+    }
+    return total;
+}
+/**
+ * Blank rows to insert above the composer, or 0 to leave the layout alone.
+ *
+ * Returns 0 whenever the answer could be wrong: no TTY, an implausible height,
+ * or a transcript long enough that the terminal has plausibly begun to scroll.
+ */
+export function bottomSpacerRows(input) {
+    const { rows, columns, transcript, liveRows } = input;
+    // Not a terminal, or a height too small to reason about. A pipe has no
+    // bottom to pin to.
+    if (rows === undefined || !Number.isFinite(rows) || rows < 12)
+        return 0;
+    const used = estimateRenderedLines(transcript, columns) + liveRows + SAFETY_ROWS;
+    // The transcript is at or past the viewport: the terminal is scrolling and
+    // the composer is already where it should be. Padding now would push it off.
+    if (used >= rows)
+        return 0;
+    return rows - used;
+}
+//# sourceMappingURL=bottom-spacer.js.map

package/dist/tui/bottom-spacer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bottom-spacer.js","sourceRoot":"","sources":["../../src/tui/bottom-spacer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAA;AAa5B;;;;;;;GAOG;AACH,MAAM,UAAU,qBAAqB,CACpC,UAA6B,EAC7B,OAA2B;IAE3B,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,OAAO,IAAI,EAAE,CAAC,CAAA;IACzC,IAAI,KAAK,GAAG,CAAC,CAAA;IACb,KAAK,MAAM,KAAK,IAAI,UAAU,EAAE,CAAC;QAChC,KAAK,MAAM,IAAI,IAAI,KAAK,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;YACtC,KAAK,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,KAAK,CAAC,CAAC,CAAA;QACrD,CAAC;IACF,CAAC;IACD,OAAO,KAAK,CAAA;AACb,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAkB;IAClD,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAA;IAErD,uEAAuE;IACvE,oBAAoB;IACpB,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,EAAE;QAAE,OAAO,CAAC,CAAA;IAEvE,MAAM,IAAI,GAAG,qBAAqB,CAAC,UAAU,EAAE,OAAO,CAAC,GAAG,QAAQ,GAAG,WAAW,CAAA;IAEhF,2EAA2E;IAC3E,6EAA6E;IAC7E,IAAI,IAAI,IAAI,IAAI;QAAE,OAAO,CAAC,CAAA;IAE1B,OAAO,IAAI,GAAG,IAAI,CAAA;AACnB,CAAC"}

package/dist/tui/permission-timing.d.ts

@@ -0,0 +1,35 @@
+/**
+ * When an approving keystroke at the permission prompt counts as a decision.
+ *
+ * The prompt takes the screen on the agent's schedule, not the operator's. The
+ * composer stays live while a turn runs and the docs encourage typing a
+ * follow-up there, so the moment the agent asks to run a tool the overlay
+ * replaces a composer someone's hands are already in. A keystroke begun before
+ * that swap was aimed at the composer behind it, and must not be read as
+ * consent for a tool call nobody has had time to read.
+ *
+ * So approval is deferred for a beat after the prompt opens. Refusal is NOT:
+ * rejecting a call the operator wanted costs them a retry, while approving one
+ * they never saw cannot be taken back, and a guard that hesitates in both
+ * directions would make the safe key feel broken to buy nothing.
+ */
+/**
+ * How long after the prompt opens an approving key is ignored.
+ *
+ * Long enough to swallow a keystroke already in flight, short enough that
+ * someone who read the prompt and reached for `y` never waits on it. A fast
+ * typist runs near 100ms between characters, so this covers roughly three
+ * characters of overshoot.
+ */
+export declare const APPROVAL_SETTLE_MS = 350;
+/**
+ * Whether an approving keypress arriving `now` should decide the prompt that
+ * opened at `openedAt`.
+ *
+ * `null` — no recorded open — is refused rather than allowed. The value exists
+ * only while a prompt is up, so its absence means the caller cannot establish
+ * that the operator has seen anything, and the fail-safe reading of "I cannot
+ * establish this" is not consent.
+ */
+export declare function approvalIsDeliberate(openedAt: number | null, now: number): boolean;
+//# sourceMappingURL=permission-timing.d.ts.map

package/dist/tui/permission-timing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission-timing.d.ts","sourceRoot":"","sources":["../../src/tui/permission-timing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,MAAM,CAAA;AAErC;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAGlF"}

package/dist/tui/permission-timing.js

@@ -0,0 +1,39 @@
+/**
+ * When an approving keystroke at the permission prompt counts as a decision.
+ *
+ * The prompt takes the screen on the agent's schedule, not the operator's. The
+ * composer stays live while a turn runs and the docs encourage typing a
+ * follow-up there, so the moment the agent asks to run a tool the overlay
+ * replaces a composer someone's hands are already in. A keystroke begun before
+ * that swap was aimed at the composer behind it, and must not be read as
+ * consent for a tool call nobody has had time to read.
+ *
+ * So approval is deferred for a beat after the prompt opens. Refusal is NOT:
+ * rejecting a call the operator wanted costs them a retry, while approving one
+ * they never saw cannot be taken back, and a guard that hesitates in both
+ * directions would make the safe key feel broken to buy nothing.
+ */
+/**
+ * How long after the prompt opens an approving key is ignored.
+ *
+ * Long enough to swallow a keystroke already in flight, short enough that
+ * someone who read the prompt and reached for `y` never waits on it. A fast
+ * typist runs near 100ms between characters, so this covers roughly three
+ * characters of overshoot.
+ */
+export const APPROVAL_SETTLE_MS = 350;
+/**
+ * Whether an approving keypress arriving `now` should decide the prompt that
+ * opened at `openedAt`.
+ *
+ * `null` — no recorded open — is refused rather than allowed. The value exists
+ * only while a prompt is up, so its absence means the caller cannot establish
+ * that the operator has seen anything, and the fail-safe reading of "I cannot
+ * establish this" is not consent.
+ */
+export function approvalIsDeliberate(openedAt, now) {
+    if (openedAt === null)
+        return false;
+    return now - openedAt >= APPROVAL_SETTLE_MS;
+}
+//# sourceMappingURL=permission-timing.js.map

package/dist/tui/permission-timing.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission-timing.js","sourceRoot":"","sources":["../../src/tui/permission-timing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,CAAA;AAErC;;;;;;;;GAQG;AACH,MAAM,UAAU,oBAAoB,CAAC,QAAuB,EAAE,GAAW;IACxE,IAAI,QAAQ,KAAK,IAAI;QAAE,OAAO,KAAK,CAAA;IACnC,OAAO,GAAG,GAAG,QAAQ,IAAI,kBAAkB,CAAA;AAC5C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@namzu/cli",
-  "version": "2.6.0",
+  "version": "3.0.0",
   "description": "Operator CLI for the Namzu agent platform — namzu doctor + future commands. Dual-purpose: standalone bin (`namzu doctor`) and library (`import { runDoctor } from '@namzu/cli'`).",
   "keywords": [
     "namzu",
@@ -45,10 +45,10 @@
     "react": "^19.2.6",
     "yaml": "^2.9.0",
     "@namzu/anthropic": "3.1.1",
-    "@namzu/openai": "1.1.1",
-    "@namzu/openrouter": "2.0.1",
     "@namzu/ollama": "2.0.1",
-    "@namzu/sdk": "^15.1.0"
+    "@namzu/openrouter": "2.0.1",
+    "@namzu/openai": "1.1.1",
+    "@namzu/sdk": "^16.0.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.4",