@giovannijecha/jecode 0.8.1 → 0.8.3

package/dist/tui/components/messages.js

@@ -1,7 +1,7 @@
 import { trailingText } from "../../text-boundary.js";
-import { row } from "../../ui/render.js";
+import { blank, row } from "../../ui/render.js";
 import { markdown } from "../../ui/markdown.js";
-import { transcriptLead, transcriptMark, transcriptWidth } from "../transcript-grammar.js";
+import { transcriptLead, transcriptWidth } from "../transcript-grammar.js";
 export const REASONING_PREVIEW_ROWS = 3;
 const MIN_REASONING_PREVIEW_CHARS = 4_096;
 const REASONING_PREVIEW_OVERSCAN = 12;
@@ -10,12 +10,14 @@ export function renderUser(block, width, pal) {
     const content = markdown(block.text, inner, pal, inner);
     return [
         "",
+        blank(width, pal.surface.subtle),
         ...content.map((line, index) => row(width, [
             ...transcriptLead(width, index === 0
                 ? { text: "❯", fg: pal.accent, bold: true }
                 : undefined),
             ...line.segs,
-        ])),
+        ], [], pal.surface.subtle)),
+        blank(width, pal.surface.subtle),
     ];
 }
 export function renderAnswer(block, width, pal) {
@@ -25,23 +27,17 @@ export function renderAnswer(block, width, pal) {
     ];
 }
 export function renderReasoning(block, width, pal, context = {}) {
-    const inner = transcriptWidth(width);
     // Expanding a live stream is deferred until it is sealed. Re-parsing an
     // ever-growing full thought on every token makes the whole TUI stall.
     const expanded = block.expanded === true && block.live !== true;
     const source = !expanded
-        ? reasoningPreviewSource(block.text, inner)
+        ? reasoningPreviewSource(block.text, width)
         : { text: block.text, truncated: false };
-    const content = markdown(source.text, inner, pal, inner);
+    const content = markdown(source.text, width, pal, width);
     const visible = expanded ? content : content.slice(-REASONING_PREVIEW_ROWS);
     return [
-        ...(context.followsTool === true
-            ? [row(width, transcriptMark(width, { text: "│", fg: pal.rule }))]
-            : context.continues === true ? [] : [""]),
-        ...visible.map((line) => row(width, [
-            ...transcriptLead(width, { text: "│", fg: pal.rule }),
-            ...line.segs.map((seg) => ({ ...seg, fg: pal.ink.dim, italic: true })),
-        ])),
+        ...(context.continues === true ? [] : [""]),
+        ...visible.map((line) => row(width, line.segs.map((seg) => ({ ...seg, fg: pal.ink.dim, italic: true })))),
     ];
 }
 export function reasoningPreviewSource(text, width) {

package/dist/tui/components/tool.js

@@ -4,7 +4,7 @@ import { fitSegs, hasColor, plainLen, row } from "../../ui/render.js";
 import { graphemeCeiling, graphemeFloor } from "../../text-boundary.js";
 import { toolDuration } from "../../duration.js";
 import { breathe, easeInOut, easeOut, interval, mix, TOOL_BIRTH_MS, TOOL_LEADER_MAX_MS, TOOL_ROW_ARRIVAL_MS, } from "../motion.js";
-import { transcriptLead, transcriptMark } from "../transcript-grammar.js";
+import { transcriptLead } from "../transcript-grammar.js";
 const OUTPUT_ROWS = 8;
 const LIVE_OUTPUT_ROWS = 6;
 const DIFF_ROWS = 15;
@@ -25,9 +25,7 @@ export function renderTool(block, width, pal, context = {}) {
     const right = resultSegments(block, pal, context, now);
     const leader = movingLeader(width, left, right, pal, context, now);
     return [
-        ...(context.followsReasoning === true
-            ? [row(width, transcriptMark(width, { text: "│", fg: pal.rule }))]
-            : context.continues === true ? [] : [""]),
+        ...(context.continues === true ? [] : [""]),
         row(width, leader === undefined ? left : [...left, leader], right),
         ...shown.map(({ detail, sourceIndex }) => renderDetail(detail, block.tone, width, pal, context.reducedMotion === true ? undefined : context.motion?.rowsAt[sourceIndex ?? -1], now)),
     ];

package/dist/tui/editor.js

@@ -2,12 +2,14 @@
 //
 // Pure functions over an immutable state — no rendering, no I/O — so the whole
 // line editor is testable without a terminal.
+import { assertPromptAppend } from "../input-boundary.js";
 import { graphemes } from "../ui/width.js";
 export const EMPTY = { text: "", cursor: 0 };
 export function of(text) {
     return { text, cursor: text.length };
 }
 export function insert(state, chunk) {
+    assertPromptAppend(state.text.length, chunk.length);
     return {
         text: state.text.slice(0, state.cursor) + chunk + state.text.slice(state.cursor),
         cursor: state.cursor + chunk.length,

package/dist/tui/keys.js

@@ -4,6 +4,7 @@
 // sequence can be split across reads, so an incomplete one is held rather than
 // guessed at; and a bracketed paste arrives as a delimited run that must not be
 // interpreted key by key, or a pasted newline submits half the paste.
+import { MAX_PROMPT_CODE_UNITS } from "../input-boundary.js";
 const ESC = String.fromCharCode(27);
 const BS = String.fromCharCode(8);
 const DEL = String.fromCharCode(127);
@@ -64,6 +65,17 @@ export function decoder(options = {}) {
     let held = "";
     let pasting = false;
     let pasted = "";
+    let pasteTooLong = false;
+    const appendPaste = (text) => {
+        if (pasteTooLong || text === "")
+            return;
+        if (text.length > MAX_PROMPT_CODE_UNITS - pasted.length) {
+            pasted = "";
+            pasteTooLong = true;
+            return;
+        }
+        pasted += text;
+    };
     const drain = (final) => {
         const keys = [];
         while (held !== "") {
@@ -77,22 +89,26 @@ export function decoder(options = {}) {
                         // paste, then let the normal control-key path handle the byte.
                         held = held.slice(interrupt);
                         pasted = "";
+                        pasteTooLong = false;
                         pasting = false;
                         continue;
                     }
                     // Hold back a possible partial terminator rather than pasting it.
                     const safe = held.length - PASTE_END.length - 1;
                     if (safe > 0) {
-                        pasted += held.slice(0, safe);
+                        appendPaste(held.slice(0, safe));
                         held = held.slice(safe);
                     }
                     break;
                 }
-                pasted += held.slice(0, end);
+                appendPaste(held.slice(0, end));
                 held = held.slice(end + PASTE_END.length + 1);
                 pasting = false;
-                keys.push({ name: "paste", text: pasted, ctrl: false });
+                keys.push(pasteTooLong
+                    ? { name: "input_limit", text: "", ctrl: false }
+                    : { name: "paste", text: pasted, ctrl: false });
                 pasted = "";
+                pasteTooLong = false;
                 continue;
             }
             const ch = held[0];
@@ -103,6 +119,7 @@ export function decoder(options = {}) {
                 if (rest.startsWith(PASTE_START)) {
                     held = rest.slice(PASTE_START.length);
                     pasting = true;
+                    pasteTooLong = false;
                     continue;
                 }
                 const mouse = MOUSE.exec(rest);
@@ -161,14 +178,56 @@ export function decoder(options = {}) {
     };
     return {
         push(chunk) {
-            held += chunk;
-            return drain(false);
+            // The usual printable run needs no protocol buffering. This also rejects
+            // one unbracketed paste atomically before copying it into `held`.
+            if (held === "" && !pasting && printable(chunk)) {
+                return [chunk.length > MAX_PROMPT_CODE_UNITS
+                        ? { name: "input_limit", text: "", ctrl: false }
+                        : { name: "char", text: chunk, ctrl: false }];
+            }
+            const keys = [];
+            const chunkSize = 64 * 1_024;
+            for (let from = 0; from < chunk.length;) {
+                let to = Math.min(from + chunkSize, chunk.length);
+                if (to < chunk.length &&
+                    isHighSurrogate(chunk.charCodeAt(to - 1)) &&
+                    isLowSurrogate(chunk.charCodeAt(to))) {
+                    to++;
+                }
+                const part = chunk.slice(from, to);
+                from = to;
+                if (part.length > MAX_PROMPT_CODE_UNITS - held.length) {
+                    held = "";
+                    pasted = "";
+                    pasting = false;
+                    pasteTooLong = false;
+                    keys.push({ name: "input_limit", text: "", ctrl: false });
+                    break;
+                }
+                held += part;
+                keys.push(...drain(false));
+            }
+            return keys;
         },
         flush() {
             return drain(true);
         },
     };
 }
+function isHighSurrogate(code) {
+    return code >= 0xd800 && code <= 0xdbff;
+}
+function isLowSurrogate(code) {
+    return code >= 0xdc00 && code <= 0xdfff;
+}
+function printable(text) {
+    for (let index = 0; index < text.length; index++) {
+        const char = text[index];
+        if ((char.codePointAt(0) ?? 0) < 0x20 || char === ESC || char === DEL)
+            return false;
+    }
+    return text !== "";
+}
 function firstInterrupt(text) {
     const ctrlC = text.indexOf(String.fromCharCode(3));
     const ctrlD = text.indexOf(String.fromCharCode(4));

package/dist/tui/overlay.js

@@ -2,6 +2,7 @@
 import * as picker from "./picker.js";
 import { oneLine } from "./field.js";
 import { applyKey } from "./input.js";
+import { PromptLimitError } from "../input-boundary.js";
 export function shown(open) {
     if (open === undefined)
         return undefined;
@@ -33,10 +34,17 @@ export function handle(open, key) {
         cancel(open);
         return {};
     }
-    if ("picker" in open)
-        return handlePicker(open, key);
-    if ("field" in open)
-        return handleField(open, key);
+    try {
+        if ("picker" in open)
+            return handlePicker(open, key);
+        if ("field" in open)
+            return handleField(open, key);
+    }
+    catch (error) {
+        if (error instanceof PromptLimitError)
+            return { open, inputLimit: true };
+        throw error;
+    }
     return { open };
 }
 function handlePicker(open, key) {

package/dist/tui/picker.js

@@ -1,6 +1,7 @@
 // One interaction model for every terminal selector.
 import { row } from "../ui/render.js";
 import { elide, graphemes } from "../ui/width.js";
+import { assertPromptAppend } from "../input-boundary.js";
 import { menuWindow, renderMenuRows } from "./components/menu.js";
 import { promptCursor, promptLine } from "./components/prompt.js";
 const WINDOW = 6;
@@ -28,6 +29,7 @@ export function adjust(picker, step) {
 export function type(picker, text) {
     if (picker.searchable !== true || text === "")
         return picker;
+    assertPromptAppend((picker.query ?? "").length, text.length);
     return withQuery(picker, `${picker.query ?? ""}${text}`);
 }
 export function backspace(picker) {

package/dist/tui/screen.js

@@ -37,7 +37,7 @@ const CURSOR_RESET = `${CSI}0 q`;
 const SYNC_BEGIN = `${CSI}?2026h`;
 const SYNC_END = `${CSI}?2026l`;
 let active = false;
-let handlersRegistered = false;
+let restoreHandlersRegistered = false;
 export function interactive() {
     return process.stdin.isTTY === true && process.stdout.isTTY === true;
 }
@@ -54,7 +54,7 @@ export function enter(reducedMotion = false) {
     if (active)
         return;
     active = true;
-    registerProcessHandlers();
+    registerRestoreHandlers();
     write(ALT_ON + WRAP_OFF + CURSOR_HIDE + (reducedMotion ? CURSOR_STEADY : CURSOR_BLOCK) + PASTE_ON + MOUSE_ON);
     process.stdin.setRawMode(true);
     process.stdin.setEncoding("utf8");
@@ -73,24 +73,12 @@ export function setReducedMotion(reducedMotion) {
     if (active)
         write(reducedMotion ? CURSOR_STEADY : CURSOR_BLOCK);
 }
-function registerProcessHandlers() {
-    if (handlersRegistered)
+function registerRestoreHandlers() {
+    if (restoreHandlersRegistered)
         return;
-    handlersRegistered = true;
+    restoreHandlersRegistered = true;
     process.on("exit", leave);
     process.on("uncaughtExceptionMonitor", leave);
-    process.on("SIGTERM", onSigterm);
-    process.on("SIGHUP", onSighup);
-}
-function onSigterm() {
-    onFatalSignal(15);
-}
-function onSighup() {
-    onFatalSignal(1);
-}
-function onFatalSignal(number) {
-    leave();
-    process.exit(128 + number);
 }
 export function onResize(handler) {
     process.stdout.on("resize", handler);

package/dist/tui/transcript-grammar.js

@@ -1,4 +1,4 @@
-// One semantic margin shared by every transcript block.
+// One semantic margin shared by the user cue and executable tool evidence.
 const GUTTER = 2;
 export function transcriptGutter(_width) {
     return GUTTER;

package/dist/ui/theme.js

@@ -1,27 +1,27 @@
 // Jecode's fixed terminal identity. Components depend on semantic tokens, not
 // literal colours, while the product exposes one deliberate dark Slate look.
-// Jecode's fixed dark Slate baseline. The exported name stays stable while
-// cooler, quieter values leave the transcript bright enough to read and let
-// live state carry the colour.
+// Jecode's fixed dark Slate baseline. Clear text contrast and luminous
+// structural colours keep long terminal transcripts readable without making
+// live state decorative.
 // Components depend on these roles rather than embedding presentation values.
 export const STEEL = {
-    accent: [124, 164, 222],
-    technical: [126, 186, 208],
-    focus: [124, 164, 222],
-    rule: [44, 60, 78],
+    accent: [102, 155, 210],
+    technical: [78, 201, 232],
+    focus: [102, 155, 210],
+    rule: [53, 80, 110],
     ink: {
-        fg: [214, 219, 226],
-        bright: [241, 244, 248],
-        muted: [149, 160, 174],
-        dim: [99, 111, 125],
-        attention: [226, 188, 112],
-        added: [138, 190, 150],
-        removed: [223, 120, 120],
+        fg: [220, 224, 229],
+        bright: [235, 239, 244],
+        muted: [156, 169, 183],
+        dim: [112, 124, 137],
+        attention: [230, 191, 95],
+        added: [134, 203, 146],
+        removed: [232, 112, 112],
     },
     surface: {
-        subtle: [23, 29, 37],
-        added: [21, 52, 33],
-        removed: [58, 24, 27],
-        attention: [58, 47, 20],
+        subtle: [31, 38, 47],
+        added: [22, 55, 34],
+        removed: [62, 24, 27],
+        attention: [62, 50, 19],
     },
 };

package/dist/user-store.js

@@ -0,0 +1,54 @@
+// Bounded synchronous reads for the tiny JSON stores under ~/.jecode.
+import { Buffer } from "node:buffer";
+import { closeSync, constants, fstatSync, openSync, readSync } from "node:fs";
+export const USER_STORE_LIMITS = Object.freeze({
+    settingsBytes: 64 * 1_024,
+    credentialsBytes: 256 * 1_024,
+    accountsBytes: 128 * 1_024,
+    credentialEntries: 64,
+    credentialName: 256,
+    credentialValue: 16_384,
+    model: 512,
+    endpoint: 2_048,
+    accountToken: 32_768,
+    accountLabel: 1_024,
+});
+export function readBoundedJsonSync(file, maxBytes) {
+    // Non-blocking open keeps a replaced FIFO or device from stalling startup;
+    // fstat below then accepts only regular files before any content is read.
+    const flags = process.platform === "win32"
+        ? "r"
+        : constants.O_RDONLY | (constants.O_NONBLOCK ?? 0);
+    const descriptor = openSync(file, flags);
+    try {
+        const details = fstatSync(descriptor);
+        if (!details.isFile())
+            throw new Error("user store must be a regular file");
+        if (!Number.isSafeInteger(details.size) || details.size > maxBytes) {
+            throw new Error(`user store exceeds ${maxBytes} bytes`);
+        }
+        // One extra byte detects an in-place growth after fstat without allowing
+        // the read allocation to follow the file's new size.
+        const capacity = Math.min(maxBytes + 1, Math.max(1, details.size + 1));
+        const bytes = Buffer.allocUnsafe(capacity);
+        let offset = 0;
+        while (offset < capacity) {
+            const count = readSync(descriptor, bytes, offset, capacity - offset, null);
+            if (count === 0)
+                break;
+            offset += count;
+        }
+        if (offset > maxBytes || offset > details.size) {
+            throw new Error("user store changed while it was being read");
+        }
+        return JSON.parse(bytes.toString("utf8", 0, offset));
+    }
+    finally {
+        closeSync(descriptor);
+    }
+}
+export function assertStoreText(text, maxBytes) {
+    if (Buffer.byteLength(text, "utf8") > maxBytes) {
+        throw new Error(`user store exceeds ${maxBytes} bytes`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {
@@ -25,7 +25,7 @@
   "files": [
     "bin/",
     "dist/",
-    "docs/assets/brand/jeco-256.png",
+    "assets/jeco-256.png",
     "LICENSE",
     "README.md"
   ],
@@ -44,8 +44,11 @@
     "pack:release": "npm run build:release && npm pack --ignore-scripts",
     "start": "node src/main.ts",
     "tui:lab": "node dev/tui-lab.ts",
-    "bench:transcript": "node dev/benchmark-transcript.ts",
+    "bench:context": "node dev/benchmark-context.ts",
+    "bench:redaction": "node dev/benchmark-redaction.ts",
     "bench:search": "node dev/benchmark-search.ts",
+    "bench:session": "node dev/benchmark-session.ts",
+    "bench:transcript": "node dev/benchmark-transcript.ts",
     "typecheck": "tsc --noEmit",
     "test": "npm run build:release && node --test",
     "coverage": "npm run build:release && node --test --experimental-test-coverage --test-coverage-include=\"src/**/*.ts\" --test-coverage-lines=80 --test-coverage-branches=75 --test-coverage-functions=75",