@vincemakes/kiso-code 0.1.20 → 0.1.22

package/dist/dispatch.js

@@ -0,0 +1,138 @@
+/**
+ * 手感批 B4 (pure move) — the ONE dispatcher: slash commands, exit, and
+ * turns. The bodies moved verbatim from chat()'s closure; chat provides
+ * the context (the chain, the run state, the prompt arming).
+ */
+import { escapeTerminal, palette } from "@vincemakes/kiso-tui";
+import { MODES, getMode, setMode } from "./mode.js";
+import { body, bodyLog } from "./state.js";
+/** The ONE dispatcher — slash commands, exit, and turns. The recovery
+ *  replay routes through it too — a queued "/last" must never become a
+ *  user turn (v2c: the rl lives in main, so lines arrive earlier and the
+ *  queue is the common path). */
+export function dispatch(line, ctx) {
+    const trimmed = line.trim();
+    if (trimmed === "/help") {
+        // Prints the available commands with one-line descriptions.
+        // v2a: the command names are the blue identity accent.
+        const p = palette();
+        const cmd = (name, desc) => `${p.blue}${name}${p.reset}    ${desc}`;
+        ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+            bodyLog(cmd("/help", "print this list of commands"));
+            bodyLog(cmd("/think", "show the last full thinking block"));
+            bodyLog(cmd("/last", "show the most recent tool call's input and output"));
+            bodyLog(cmd("/status", "show session id, event count, and context estimate"));
+            bodyLog(cmd("/mode", "show the approval tier; /mode <name> switches (manual/default/accept-edits/plan/bypass)"));
+            bodyLog(cmd("/compact", "summarize the older conversation to free context"));
+            bodyLog(cmd("exit", "leave the session"));
+            ctx.input.prompt();
+        });
+        return;
+    }
+    if (trimmed === "/think") {
+        // v2b/v2d: print the last COMPLETE thinking block — the body holds
+        // it (the ThinkingCell's fold closes at the block's end).
+        ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+            const t = body.lastThinking();
+            if (t === null) {
+                bodyLog("[no thinking yet]");
+            }
+            else {
+                bodyLog(escapeTerminal(t));
+            }
+            ctx.input.prompt();
+        });
+        return;
+    }
+    if (trimmed === "/last") {
+        // B 区/v2d: print the FULL input/output of the most recent tool
+        // call — the body holds it (the ToolCell's final state). Runs on
+        // the chain: after any in-flight turn completes.
+        ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+            const tool = body.lastTool();
+            if (tool === null) {
+                bodyLog("[no tool call yet]");
+            }
+            else {
+                bodyLog(`--- ${tool.name} input ---`);
+                bodyLog(escapeTerminal(JSON.stringify(tool.input, null, 2)));
+                bodyLog(`--- ${tool.name} output${tool.result.isError ? " (error)" : ""} ---`);
+                bodyLog(escapeTerminal(tool.result.content));
+            }
+            ctx.input.prompt();
+        });
+        return;
+    }
+    if (trimmed === "/status") {
+        // B 区: session id, durable event count, and the ~ context
+        // estimate — all read straight from the live session, nothing
+        // stored separately. Runs on the chain after any in-flight turn.
+        ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+            const ctxRatio = ctx.estimateCtx();
+            const ctxPct = Number.isFinite(ctxRatio) ? `~${Math.round(ctxRatio * 100)}%` : "~?";
+            bodyLog(`session ${ctx.session.id}`);
+            bodyLog(`${ctx.session.log.all.length} events`);
+            bodyLog(`ctx ${ctxPct}`);
+            ctx.input.prompt();
+        });
+        return;
+    }
+    if (trimmed === "/mode" || trimmed.startsWith("/mode ")) {
+        // Modes: /mode alone prints the current tier + the list;
+        // /mode <name> switches — the notice cell leaves the audit
+        // line in the body, the status bar repaints at once.
+        ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+            const m = MODES.find((x) => x === trimmed.slice(5).trim());
+            if (trimmed.slice(5).trim() === "") {
+                bodyLog(`mode ${getMode()}`);
+                bodyLog(`tiers: ${MODES.join(" ")}`);
+            }
+            else if (m === undefined) {
+                bodyLog(`no such mode: ${trimmed.slice(5).trim()}`);
+                bodyLog(`tiers: ${MODES.join(" ")}`);
+            }
+            else {
+                setMode(m);
+                body.notice(`mode → ${m}`);
+                ctx.paintIdle();
+            }
+            ctx.input.prompt();
+        });
+        return;
+    }
+    if (trimmed === "/compact") {
+        // /compact (ADR-0044): the older conversation becomes one
+        // model summary — an OFF-LOOP call through the session's own
+        // adapter, so it must never race a running turn: refused
+        // mid-run, with a hint to wait for the turn to end.
+        if (ctx.isRunning()) {
+            body.notice("[/compact] a turn is running — wait for it to finish");
+            return;
+        }
+        ctx.chainRef.current = ctx.chainRef.current.then(async () => {
+            try {
+                const result = await ctx.session.summarize();
+                if (result === null) {
+                    body.notice("[/compact] nothing to compact — fewer than 5 rounds yet");
+                }
+                else {
+                    body.notice(`[/compact] saved ~${result.savedTokens.toLocaleString("en-US")} tokens`);
+                }
+            }
+            catch (err) {
+                // Honest failure: nothing was persisted, the session
+                // is unchanged (ADR-0044 crash semantics).
+                body.notice(`[/compact] failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
+            ctx.input.prompt();
+        });
+        return;
+    }
+    if (trimmed === "exit" || trimmed === "") {
+        ctx.input.close();
+        return;
+    }
+    // v2c: a turn submitted while another runs waits on the chain — the
+    // live count rides the status bar (+N queued).
+    ctx.submitTurn(line);
+}

package/dist/faux-glue.d.ts

@@ -0,0 +1,44 @@
+/**
+ * 手感批 B4 (pure move) — the faux-mode glue: the durable script position
+ * (fauxSkip), the script sources (env override + the built-in demo), and
+ * the exhaustion guard. All bodies moved verbatim from index.ts.
+ */
+import type { FauxScript } from "@vincemakes/kiso-evals";
+import { type LineInput } from "./state.js";
+/**
+ * E 区: how many faux-script turns a session has already consumed. The faux
+ * provider's script counter is per-process, so a FRESH process that resumes
+ * a session would restart the script at turn 0 — re-issuing the first
+ * scripted call instead of continuing the trajectory. The session log is
+ * the durable position: a turn is consumed when it produced a tool_result
+ * or an end_turn stop — AND when its tool call is unfinished (started but
+ * no result): the recovery completes those turns WITHOUT a provider call
+ * (executes the approved call, or fills the human verdict), so the model's
+ * next response is the turn AFTER them.
+ */
+export declare function fauxSkip(id: string): number;
+/**
+ * E 区: KISO_FAUX_SCRIPT=<path> overrides the demo script with a JSON
+ * FauxScript file — the kill -9 e2e drives the CLI through an exact
+ * multi-tool trajectory. Absent → the built-in demo script.
+ */
+export declare function readFauxScript(): FauxScript;
+/**
+ * The keyless demo script: tours the tools so `kiso chat` exercises them.
+ * FOUR turns: each user turn consumes two model rounds (call → result →
+ * summary), so at least two consecutive user turns work in one process
+ * (F 组).
+ */
+export declare function fauxScript(): FauxScript;
+/** 十: a faux-mode run whose scripted turns are exhausted must NOT print a
+ * provider error and exit 0 — the honest outcome is a loud message and a
+ * non-zero exit. Thrown as a CONTROLLED exception (never process.exit):
+ * the REPL closes, the error propagates through main's finally (so
+ * agent.close() runs and no lock is left behind), and main's catch sets
+ * the exit code. Only the exhaustion signature (the empty stream after
+ * the declared turns) triggers the script-specific message; any other
+ * error terminal still exits non-zero. */
+export declare class FauxExhaustionError extends Error {
+    constructor(message: string);
+}
+export declare function failOnFauxExhaustion(last: import("@vincemakes/kiso-core").Event | undefined, faux: boolean, input: LineInput | undefined): void;

package/dist/faux-glue.js

@@ -0,0 +1,115 @@
+/**
+ * 手感批 B4 (pure move) — the faux-mode glue: the durable script position
+ * (fauxSkip), the script sources (env override + the built-in demo), and
+ * the exhaustion guard. All bodies moved verbatim from index.ts.
+ */
+import { readFileSync } from "node:fs";
+import { escapeTerminal } from "@vincemakes/kiso-tui";
+import { SessionStore } from "@vincemakes/kiso-runtime";
+import { sessionsDir } from "./state.js";
+/**
+ * E 区: how many faux-script turns a session has already consumed. The faux
+ * provider's script counter is per-process, so a FRESH process that resumes
+ * a session would restart the script at turn 0 — re-issuing the first
+ * scripted call instead of continuing the trajectory. The session log is
+ * the durable position: a turn is consumed when it produced a tool_result
+ * or an end_turn stop — AND when its tool call is unfinished (started but
+ * no result): the recovery completes those turns WITHOUT a provider call
+ * (executes the approved call, or fills the human verdict), so the model's
+ * next response is the turn AFTER them.
+ */
+export function fauxSkip(id) {
+    const events = new SessionStore(sessionsDir())
+        .load(id)
+        .map((r) => r.event);
+    const results = new Set(events.filter((e) => e.type === "tool_result").map((e) => e.callId));
+    return (events.filter((e) => e.type === "tool_result").length +
+        events.filter((e) => e.type === "stop" && e.reason === "end_turn").length +
+        events.filter((e) => e.type === "tool_call_end" && !results.has(e.callId)).length);
+}
+/**
+ * E 区: KISO_FAUX_SCRIPT=<path> overrides the demo script with a JSON
+ * FauxScript file — the kill -9 e2e drives the CLI through an exact
+ * multi-tool trajectory. Absent → the built-in demo script.
+ */
+export function readFauxScript() {
+    const path = process.env.KISO_FAUX_SCRIPT;
+    if (path === undefined)
+        return fauxScript();
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (!Array.isArray(parsed))
+            throw new Error("not an array");
+        return parsed;
+    }
+    catch (err) {
+        console.error(`[KISO_FAUX_SCRIPT] cannot load ${path}: ${err.message}`);
+        process.exit(1);
+    }
+}
+/**
+ * The keyless demo script: tours the tools so `kiso chat` exercises them.
+ * FOUR turns: each user turn consumes two model rounds (call → result →
+ * summary), so at least two consecutive user turns work in one process
+ * (F 组).
+ */
+export function fauxScript() {
+    return [
+        {
+            events: [
+                // 自举 P1: a multi-delta thinking block — renders as ONE
+                // streaming segment, not one line per token.
+                { type: "thinking", text: "Let me think about" },
+                { type: "thinking", text: " the workspace" },
+                { type: "thinking", text: " before acting." },
+                { type: "text_start" },
+                { type: "text_delta", text: "I'm the faux model. Let me look at the working directory." },
+                { type: "tool_call_end", callId: "c1", name: "list_dir", input: {} },
+                { type: "stop", reason: "tool_use" },
+            ],
+        },
+        {
+            events: [
+                { type: "text_delta", text: "I see the workspace. What would you like me to inspect or change?" },
+                { type: "stop", reason: "end_turn" },
+            ],
+        },
+        {
+            events: [
+                { type: "text_delta", text: "The faux model is still here, with full context." },
+                { type: "stop", reason: "end_turn" },
+            ],
+        },
+        {
+            events: [
+                { type: "text_delta", text: "And this is the end of the scripted tour." },
+                { type: "stop", reason: "end_turn" },
+            ],
+        },
+    ];
+}
+/** 十: a faux-mode run whose scripted turns are exhausted must NOT print a
+ * provider error and exit 0 — the honest outcome is a loud message and a
+ * non-zero exit. Thrown as a CONTROLLED exception (never process.exit):
+ * the REPL closes, the error propagates through main's finally (so
+ * agent.close() runs and no lock is left behind), and main's catch sets
+ * the exit code. Only the exhaustion signature (the empty stream after
+ * the declared turns) triggers the script-specific message; any other
+ * error terminal still exits non-zero. */
+export class FauxExhaustionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "FauxExhaustionError";
+    }
+}
+export function failOnFauxExhaustion(last, faux, input) {
+    if (!faux)
+        return;
+    if (last?.type !== "terminal" || last.outcome.kind !== "error")
+        return;
+    const message = last.outcome.error.message;
+    input?.close(); // the REPL must not stay open waiting for a line
+    throw new FauxExhaustionError(message.startsWith("provider stream ended without a stop event")
+        ? "[faux mode] the scripted demo turns are exhausted — set ANTHROPIC_API_KEY or OPENAI_API_KEY for a real model"
+        : `[faux mode] the scripted model failed: ${escapeTerminal(message.slice(0, 200))}`);
+}

package/dist/index.d.ts

@@ -14,15 +14,15 @@
  * Sessions live under $KISO_HOME/sessions (default ~/.kiso/sessions) as
  * append-only JSONL. Write/edit/shell tools sit behind the approval policy:
  * the run pauses, asks, and resumes — durably (ADR-0024).
+ *
+ * 手感批 B4 (pure move): the interactive pieces live beside this file —
+ * chat.ts (the REPL + consumeRun), dispatch.ts (the slash dispatcher),
+ * resume.ts, trust-ui.ts (the question surface + E3 merges), faux-glue.ts
+ * (the scripted-model plumbing), state.ts (the shared process state).
+ * index.ts keeps the entry: banner, input sources, the A 区 prompt,
+ * makeAgent, and main.
  */
-import { type ProjectArtifacts } from "@vincemakes/kiso-runtime";
-/**
- * E3 — merge the project's mcp.json and skills into the env BEFORE the
- * extension load. A server name in BOTH configs is a LOUD error (a silent
- * override would be a supply-chain surprise); a skill name in both merges
- * with project-wins and a stderr note. Exported for tests.
- */
-export declare function applyProjectMerges(artifacts: ProjectArtifacts): void;
+export { applyProjectMerges } from "./trust-ui.js";
 /**
  * A 区: read the FIRST present instruction file (AGENTS.md preferred) and
  * return it as an injected section, or "" when none exists. Truncated at