@giovannijecha/jecode 0.5.0 → 0.6.0

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/tui/app-workflows.js

@@ -1,9 +1,12 @@
 // 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 { 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 { answerAt } from "./approve.js";
 import { cancel as cancelOpen } from "./overlay.js";
 import { controllerOptions, turnFailure } from "./session-view.js";
@@ -81,12 +84,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 +111,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 +123,76 @@ 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;
         };
+        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/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.6.0",
   "description": "An owned coding agent with zero external runtime dependencies.",
   "license": "MIT",
   "repository": {