@giovannijecha/jecode 0.5.0 → 0.7.0

package/dist/sessions/store.js

@@ -9,7 +9,7 @@ import * as path from "node:path";
 import { atomicWrite } from "../atomic.js";
 import { CONVERSATION_LIMITS, ConversationTree } from "../conversation.js";
 import { userDataPath } from "../user-data.js";
-import { decodeHead, decodeMeta, decodeNode, encodeHead, encodeMeta, encodeNode, } from "./codec.js";
+import { decodeHead, decodeMeta, decodeNode, encodeHead, encodeMeta, encodeNode, SESSION_SCHEMA, } from "./codec.js";
 import { leaseOwner, leaseToken, pidIsAlive, removeLease, sessionLease, } from "./lease.js";
 const DIRECTORY_MODE = 0o700;
 const FILE_MODE = 0o600;
@@ -104,7 +104,7 @@ export class DurableSessionStore {
                 throw new Error("session checkpoint cannot be recovered safely");
             }
             head = {
-                version: 1,
+                version: SESSION_SCHEMA,
                 sequence: candidate.sequence,
                 nodeId: candidate.node.id,
                 parentId: candidate.node.parentId,
@@ -128,14 +128,14 @@ export class DurableSessionStore {
         const temporary = path.join(this.#bucket, `.${id}.${randomUUID()}.tmp`);
         const target = this.#sessionDirectory(id);
         const meta = {
-            version: 1,
+            version: SESSION_SCHEMA,
             id,
             workspaceRoot: this.workspaceRoot,
             workspaceDigest: this.workspaceDigest,
             createdAt: now,
         };
         const head = {
-            version: 1,
+            version: SESSION_SCHEMA,
             sequence: conversation.nodes.length,
             nodeId: active.id,
             parentId: active.parentId,
@@ -187,7 +187,7 @@ export class DurableSessionStore {
         assertSharedNodes(previous.conversation, conversation, replacesHead ? active.id : undefined);
         const now = new Date().toISOString();
         const head = {
-            version: 1,
+            version: SESSION_SCHEMA,
             sequence: previous.head.sequence + 1,
             nodeId: active.id,
             parentId: active.parentId,

package/dist/settings-command.js

@@ -1,6 +1,7 @@
 // The persistent settings hub. Provider access and model selection reuse the
 // same command flows exposed directly through /providers and /models.
 import { saveCommandSettings } from "./command-settings.js";
+import { MAX_COMPACTION_PERCENT, MIN_COMPACTION_PERCENT } from "./context/policy.js";
 import { modelsCommand } from "./model-command.js";
 import { providerFailure } from "./provider-errors.js";
 import { providerLabel } from "./provider-label.js";
@@ -43,6 +44,9 @@ export async function settingsCommand(session, host) {
             case "maxSteps":
                 await numberSetting(session, host, "maxSteps", "max tool steps");
                 break;
+            case "compactionPercent":
+                await compactionSetting(session, host);
+                break;
             case "reducedMotion":
                 await motionSetting(session, host);
                 break;
@@ -53,9 +57,11 @@ export async function settingsCommand(session, host) {
     }
 }
 export function settingsPicker(values, index = 0) {
+    const items = settingsItems(values);
     return {
         title: [],
-        options: settingsItems(values).map((item) => item.option),
+        options: items.map((item) => item.option),
+        visible: items.length,
         index,
     };
 }
@@ -76,13 +82,17 @@ function settingsItems(values) {
                     option: { label: "max output tokens", value: String(values.maxTokens) },
                 }]),
         { action: "maxSteps", option: { label: "max tool steps", value: String(values.maxSteps) } },
+        {
+            action: "compactionPercent",
+            option: { label: "context compaction", value: `${values.compactionPercent}%` },
+        },
         {
             action: "reducedMotion",
             option: { label: "reduced motion", value: values.reducedMotion ? "on" : "off" },
         },
         {
             action: "providers",
-            option: { label: "providers", hint: "manage access and connections" },
+            option: { label: "providers", hint: "manage connections" },
         },
     ];
 }
@@ -93,6 +103,7 @@ function settingsValues(session) {
         effort: session.config.effort,
         ...(session.provider.id === "openai-codex" ? {} : { maxTokens: session.config.maxTokens }),
         maxSteps: session.config.maxSteps,
+        compactionPercent: session.config.compactionPercent,
         reducedMotion: session.config.reducedMotion,
     };
 }
@@ -185,6 +196,35 @@ async function numberSetting(session, host, name, label) {
         return;
     session.config[name] = value;
 }
+async function compactionSetting(session, host) {
+    if (host.type === undefined)
+        return;
+    const label = "context compaction";
+    const field = {
+        title: heading(label, `${MIN_COMPACTION_PERCENT}-${MAX_COMPACTION_PERCENT} percent`, session.palette),
+        right: "enter save · esc back",
+        editor: of(String(session.config.compactionPercent)),
+        secret: false,
+        note: "Compacts when model context reaches this percentage.",
+    };
+    const text = await host.type(field);
+    if (text === undefined)
+        return;
+    const value = Number(text);
+    if (!Number.isSafeInteger(value) ||
+        value < MIN_COMPACTION_PERCENT ||
+        value > MAX_COMPACTION_PERCENT) {
+        host.emit({
+            kind: "notice",
+            text: `${label} must be from ${MIN_COMPACTION_PERCENT} to ${MAX_COMPACTION_PERCENT}`,
+            tone: "error",
+        });
+        return;
+    }
+    if (!(await saveCommandSettings(host, { compactionPercent: value })))
+        return;
+    session.config.compactionPercent = value;
+}
 function chooser(host) {
     if (host.choose === undefined) {
         host.emit({ kind: "notice", text: "that command needs the screen", tone: "warn" });

package/dist/settings.js

@@ -3,6 +3,7 @@ import { readFileSync } from "node:fs";
 import { chmod, mkdir } from "node:fs/promises";
 import * as path from "node:path";
 import { atomicWrite } from "./atomic.js";
+import { MAX_COMPACTION_PERCENT, MIN_COMPACTION_PERCENT } from "./context/policy.js";
 import { EFFORTS } from "./effort.js";
 import { providerNames } from "./providers/index.js";
 import { parseOllamaEndpoint } from "./providers/ollama-endpoint.js";
@@ -59,6 +60,7 @@ function normalize(value) {
     const reducedMotion = typeof value["reducedMotion"] === "boolean" ? value["reducedMotion"] : undefined;
     const maxTokens = positiveInteger(value["maxTokens"]);
     const maxSteps = positiveInteger(value["maxSteps"]);
+    const compactionPercent = percentage(value["compactionPercent"]);
     return {
         ...(provider === undefined ? {} : { provider }),
         ...(models === undefined ? {} : { models }),
@@ -67,6 +69,7 @@ function normalize(value) {
         ...(reducedMotion === undefined ? {} : { reducedMotion }),
         ...(maxTokens === undefined ? {} : { maxTokens }),
         ...(maxSteps === undefined ? {} : { maxSteps }),
+        ...(compactionPercent === undefined ? {} : { compactionPercent }),
     };
 }
 function modelsOf(value, providers) {
@@ -91,6 +94,12 @@ function endpoint(value) {
 function positiveInteger(value) {
     return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
 }
+function percentage(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) &&
+        value >= MIN_COMPACTION_PERCENT && value <= MAX_COMPACTION_PERCENT
+        ? value
+        : undefined;
+}
 function record(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }

package/dist/timeline.js

@@ -0,0 +1,90 @@
+// A compact, read-only projection of the durable conversation tree.
+//
+// Selecting a node changes only the in-memory path. The next real user turn
+// is what persists a branch, so opening or cancelling this control plane can
+// never create empty history.
+import { usageFromHistory } from "./usage.js";
+import { heading } from "./tui/picker.js";
+export function timelinePicker(conversation, palette) {
+    const entries = timelineEntries(conversation);
+    const selectedId = conversation.latestCompleted()?.activeNodeId ?? 0;
+    const index = Math.max(0, entries.findIndex((entry) => entry.node.id === selectedId));
+    return Object.freeze({
+        picker: {
+            title: heading("timeline", "conversation tree", palette),
+            searchable: true,
+            query: "",
+            visible: 8,
+            options: entries.map((entry) => ({
+                label: `${entry.prefix}${preview(entry.node)}`,
+                hint: stamp(entry.node.createdAt),
+                ...(entry.node.id === selectedId ? { value: "active" } : {}),
+            })),
+            index,
+        },
+        nodeIds: Object.freeze(entries.map((entry) => entry.node.id)),
+    });
+}
+export async function selectTimeline(session, choose) {
+    const timeline = timelinePicker(session.conversation, session.palette);
+    if (timeline.nodeIds.length === 0)
+        return false;
+    const index = await choose(timeline.picker);
+    const nodeId = index === undefined ? undefined : timeline.nodeIds[index];
+    if (nodeId === undefined || nodeId === session.conversation.activeNodeId)
+        return false;
+    session.conversation = session.conversation.select(nodeId);
+    session.usage = usageFromHistory(session.conversation.history);
+    return true;
+}
+function timelineEntries(conversation) {
+    const completed = conversation.nodes.filter((node) => node.settlement === "completed");
+    const completedIds = new Set(completed.map((node) => node.id));
+    const children = new Map();
+    for (const node of completed) {
+        let parentId = node.parentId;
+        while (parentId !== 0 && !completedIds.has(parentId)) {
+            parentId = conversation.node(parentId)?.parentId ?? 0;
+        }
+        const siblings = children.get(parentId) ?? [];
+        siblings.push(node);
+        children.set(parentId, siblings);
+    }
+    const entries = [];
+    const visit = (parentId, lanes) => {
+        const siblings = children.get(parentId) ?? [];
+        for (let index = 0; index < siblings.length; index++) {
+            const node = siblings[index];
+            const forks = siblings.length > 1;
+            const last = index === siblings.length - 1;
+            const hidden = Math.max(0, lanes.length - 4);
+            const lanePrefix = `${hidden === 0 ? "" : "…  "}${lanes.slice(hidden)
+                .map((closed) => closed ? "   " : "│  ").join("")}`;
+            entries.push({
+                node,
+                prefix: `${lanePrefix}${forks ? (last ? "└─ " : "├─ ") : "• "}`,
+            });
+            visit(node.id, forks ? [...lanes, last] : lanes);
+        }
+    };
+    visit(0, []);
+    return entries;
+}
+function preview(node) {
+    for (const message of node.messages) {
+        if (message.role !== "user")
+            continue;
+        const text = message.content.find((block) => block.kind === "text")?.text
+            .replace(/\s+/gu, " ").trim();
+        if (text !== undefined && text !== "")
+            return text.slice(0, 160);
+    }
+    return "Untitled turn";
+}
+function stamp(value) {
+    const date = new Date(value);
+    if (!Number.isFinite(date.getTime()))
+        return value.replace("T", " ").slice(0, 16);
+    const two = (part) => String(part).padStart(2, "0");
+    return `${two(date.getHours())}:${two(date.getMinutes())}`;
+}

package/dist/tui/app-state.js

@@ -13,5 +13,6 @@ export function appState() {
         draft: "",
         spin: 0,
         closeWhenIdle: false,
+        committedNodeId: 0,
     };
 }

package/dist/tui/app-workflows.js

@@ -1,9 +1,14 @@
 // Foreground command and model-turn workflows for the TUI shell.
 import { handleCommand } from "../commands.js";
 import { runTurn } from "../controller.js";
+import { resolveContextPolicy } from "../context/capacity.js";
+import { compactContext } from "../context/compactor.js";
+import { compactSession } from "../context/manual.js";
+import { isContextOverflow, shouldResolveContextPolicy } from "../context/policy.js";
 import { updateSettings } from "../settings.js";
 import { saveTranscript } from "../transcript-export.js";
-import { recordUsage } from "../usage.js";
+import { recordAuxiliaryUsage, recordUsage } from "../usage.js";
+import { selectTimeline } from "../timeline.js";
 import { answerAt } from "./approve.js";
 import { cancel as cancelOpen } from "./overlay.js";
 import { controllerOptions, turnFailure } from "./session-view.js";
@@ -11,6 +16,10 @@ import { transcribe } from "./turn.js";
 const WAITING = "Waiting";
 export function appWorkflows(options) {
     const { session, state, permissions, feedback } = options;
+    const choose = (picker) => new Promise((resolve) => {
+        state.open = { picker, settle: resolve };
+        options.render();
+    });
     async function command(text) {
         const activity = options.startActivity("command", `Running ${text.split(/\s+/)[0]}`);
         if (activity === undefined)
@@ -23,10 +32,7 @@ export function appWorkflows(options) {
                     state.open = { help: true, settle: resolve };
                     options.render();
                 }),
-                choose: (picker) => new Promise((resolve) => {
-                    state.open = { picker, settle: resolve };
-                    options.render();
-                }),
+                choose,
                 dismiss: () => {
                     state.open = state.open === undefined ? undefined : cancelOpen(state.open);
                     options.render();
@@ -48,6 +54,7 @@ export function appWorkflows(options) {
                     state.follow = true;
                     state.unseen = 0;
                     state.lastMaxScroll = 0;
+                    state.committedNodeId = 0;
                 },
                 permissions,
                 exportTranscript: () => saveTranscript(options.transcriptRoot, state.blocks),
@@ -55,6 +62,27 @@ export function appWorkflows(options) {
                     await updateSettings(patch);
                 },
                 refreshSettings: options.refreshSettings,
+                timeline: async () => {
+                    const selected = await selectTimeline(session, choose);
+                    if (!selected)
+                        return "unchanged";
+                    options.replaceTranscript();
+                    return session.conversation.activeNodeId === state.committedNodeId
+                        ? "unchanged"
+                        : "selected";
+                },
+                compact: async () => {
+                    if (session.conversation.activeNodeId !== state.committedNodeId) {
+                        return "branch-pending";
+                    }
+                    return compactSession(session, {
+                        signal: activity.control.signal,
+                        onStatus: (status) => {
+                            state.status = status ?? activity.label;
+                            options.render();
+                        },
+                    });
+                },
             });
             if (outcome === "exit")
                 state.closeWhenIdle = true;
@@ -81,12 +109,18 @@ export function appWorkflows(options) {
             return;
         const parentId = session.conversation.activeNodeId;
         const history = session.conversation.history;
+        const modelHistory = session.conversation.contextHistory;
         const historyStart = history.length;
         const blockStart = state.blocks.length;
         const createdAt = new Date().toISOString();
+        const prospectiveNodeId = session.conversation.nodes.length + 1;
         let nodeId;
+        let context;
+        let contextPolicy;
         options.emit({ kind: "user", text });
-        history.push({ role: "user", content: [{ kind: "text", text }] });
+        const user = { role: "user", content: [{ kind: "text", text }] };
+        history.push(user);
+        modelHistory.push(structuredClone(user));
         const events = transcribe({
             emit: options.emit,
             render: options.render,
@@ -102,7 +136,7 @@ export function appWorkflows(options) {
             },
             usage: (usage) => recordUsage(session.usage, usage),
         });
-        events.onCheckpoint = async (checkpoint, settlement) => {
+        const persist = async (checkpoint, settlement) => {
             const next = session.conversation.commit({
                 ...(nodeId === undefined ? {} : { nodeId }),
                 parentId,
@@ -114,14 +148,77 @@ export function appWorkflows(options) {
                 },
                 messages: checkpoint.slice(historyStart),
                 blocks: state.blocks.slice(blockStart),
+                ...(context === undefined ? {} : { context }),
             }, settlement);
             await session.persistence?.checkpoint(next);
             session.conversation = next;
             nodeId = next.activeNodeId;
+            state.committedNodeId = next.activeNodeId;
+        };
+        const compact = async (checkpoint, projected, reason, error) => {
+            if (reason === "overflow" && (error === undefined || !isContextOverflow(error))) {
+                return undefined;
+            }
+            const force = reason === "overflow";
+            if (!shouldResolveContextPolicy(projected, session.usage.lastInputTokens, force)) {
+                return undefined;
+            }
+            if (contextPolicy === undefined) {
+                state.status = "Checking context";
+                options.render();
+                contextPolicy = resolveContextPolicy({
+                    provider: session.provider,
+                    model: session.model,
+                    compactionPercent: session.config.compactionPercent,
+                    signal: activity.control.signal,
+                    onStatus: (status) => {
+                        state.status = status;
+                        options.render();
+                    },
+                }).finally(() => {
+                    state.status = WAITING;
+                    options.render();
+                });
+            }
+            const result = await compactContext({
+                provider: session.provider,
+                model: session.model,
+                effort: session.config.effort,
+                context: projected,
+                turn: checkpoint.slice(historyStart),
+                nodeId: nodeId ?? prospectiveNodeId,
+                coveredMessages: context?.messageCount ?? 0,
+                lastInputTokens: session.usage.lastInputTokens,
+                signal: activity.control.signal,
+                force,
+                policy: await contextPolicy,
+                onBegin: () => {
+                    state.status = "Compacting";
+                    options.render();
+                },
+                onEnd: () => {
+                    state.status = WAITING;
+                    options.render();
+                },
+            });
+            if (result === undefined)
+                return undefined;
+            context = result.anchor;
+            if (result.usage !== undefined)
+                recordAuxiliaryUsage(session.usage, result.usage);
+            return result.messages;
+        };
+        events.onContext = compact;
+        events.onCheckpoint = async (checkpoint, settlement, projected) => {
+            await persist(checkpoint, settlement);
+            const compacted = await compact(checkpoint, projected, "budget");
+            if (compacted !== undefined)
+                await persist(checkpoint, settlement);
+            return compacted;
         };
         let finishReason;
         try {
-            await runTurn(history, controllerOptions(session, permissions.availableTools()), events, activity.control.signal);
+            await runTurn(history, controllerOptions(session, permissions.availableTools()), events, activity.control.signal, modelHistory);
         }
         catch (error) {
             const interrupted = activity.control.signal.aborted;

package/dist/tui/app.js

@@ -32,6 +32,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     const workspace = await workspaceLabel(session.config.root);
     const state = appState();
     state.blocks.push(...session.conversation.transcript);
+    state.committedNodeId = session.conversation.activeNodeId;
     const permissions = sessionPermissions(session.tools, session.config.autoApprove);
     let closed;
     let frameTimer;
@@ -116,6 +117,16 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         if (state.follow)
             state.unseen = 0;
     };
+    const replaceTranscript = () => {
+        state.blocks.splice(0, state.blocks.length, ...session.conversation.transcript);
+        state.scroll = 0;
+        state.follow = true;
+        state.unseen = 0;
+        state.lastMaxScroll = 0;
+        transcript.invalidate();
+        paint.invalidate();
+        render();
+    };
     function quit() {
         if (!live)
             return;
@@ -187,6 +198,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         emit,
         commandNotice,
         render,
+        replaceTranscript,
         refreshSettings: () => {
             terminal.setReducedMotion(session.config.reducedMotion);
             paint.invalidate();
@@ -229,14 +241,9 @@ export async function runApp(session, transcriptRoot, environment = {}) {
                 return;
             try {
                 await launch.open(candidate.id);
-                state.blocks.splice(0, state.blocks.length, ...session.conversation.transcript);
+                replaceTranscript();
+                state.committedNodeId = session.conversation.activeNodeId;
                 state.past.length = 0;
-                state.scroll = 0;
-                state.follow = true;
-                state.unseen = 0;
-                state.lastMaxScroll = 0;
-                transcript.invalidate();
-                paint.invalidate();
                 finishActivity(activity);
                 return;
             }

package/dist/tui/components/misc.js

@@ -5,11 +5,13 @@ export function renderNotice(block, width, pal) {
         warn: pal.ink.attention,
         error: pal.ink.removed,
     };
-    const mark = block.tone === "error" ? "× " : block.tone === "warn" ? "! " : "· ";
+    const mark = block.tone === "error" ? "× " : block.tone === "warn" ? "! " : undefined;
     return [
         "",
         ...wrap(block.text, Math.max(1, width - 3)).map((line, index) => row(width, [
-            { text: index === 0 ? mark : "  ", fg: fg[block.tone], bold: index === 0 },
+            ...(mark === undefined
+                ? []
+                : [{ text: index === 0 ? mark : "  ", fg: fg[block.tone], bold: index === 0 }]),
             { text: line, fg: fg[block.tone] },
         ], [], undefined, 1)),
     ];

package/dist/usage.js

@@ -13,6 +13,14 @@ export function emptyUsage() {
 export function recordUsage(total, next) {
     total.requests += 1;
     total.lastInputTokens = next.inputTokens;
+    addUsage(total, next);
+}
+/** Account for an internal request without replacing the main context signal. */
+export function recordAuxiliaryUsage(total, next) {
+    total.requests += 1;
+    addUsage(total, next);
+}
+function addUsage(total, next) {
     total.inputTokens += next.inputTokens;
     total.outputTokens += next.outputTokens;
     total.cachedInputTokens += next.cachedInputTokens;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giovannijecha/jecode",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {