opencode-clm 0.1.1 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-clm",
-  "version": "0.1.1",
+  "version": "0.3.0",
   "description": "OpenCode plugin for Context Language Models: the model edits a file mirror of its own context, and the edited mirror becomes its next input.",
   "type": "module",
   "license": "MIT",
@@ -23,10 +23,13 @@
   ],
   "main": "./index.ts",
   "exports": {
-    ".": "./index.ts"
+    ".": "./index.ts",
+    "./server": "./index.ts",
+    "./tui": "./tui.ts"
   },
   "files": [
     "index.ts",
+    "tui.ts",
     "src/**/*.ts",
     "skills/**",
     "steering/**",
@@ -51,8 +54,20 @@
   "dependencies": {
     "@opencode-ai/plugin": "^1.18.34"
   },
+  "peerDependencies": {
+    "@opentui/core": ">=0.4.5"
+  },
+  "peerDependenciesMeta": {
+    "@opentui/core": {
+      "optional": true
+    }
+  },
   "devDependencies": {
-    "@types/bun": "1.3.14",
-    "typescript": "5.9.3"
+    "@opentui/core": "0.5.14",
+    "@opentui/keymap": "0.5.14",
+    "@opentui/solid": "0.5.14",
+    "@types/bun": "1.4.2",
+    "@xterm/headless": "6.0.0",
+    "typescript": "7.0.2"
   }
 }

package/src/atomic.ts

@@ -0,0 +1,27 @@
+// Atomic replacement of small session files (overrides.json, snapshot.json, rN.json): write
+// a temp file with mode 0600 next to the target, then rename it over the target, so a
+// reader never sees a torn file. Written for this package.
+import { randomUUID } from "node:crypto";
+import { mkdir, open, rename, rm } from "node:fs/promises";
+import { dirname } from "node:path";
+
+export async function writeFileAtomic(path: string, text: string): Promise<void> {
+	await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+	const temporary = `${path}.${process.pid}.${randomUUID()}.tmp`;
+	try {
+		const handle = await open(temporary, "wx", 0o600);
+		try {
+			await handle.writeFile(text, "utf8");
+		} finally {
+			await handle.close();
+		}
+		await rename(temporary, path);
+	} catch (error) {
+		await rm(temporary, { force: true }).catch(() => undefined);
+		throw error;
+	}
+}
+
+export function writeJsonAtomic(path: string, value: unknown): Promise<void> {
+	return writeFileAtomic(path, `${JSON.stringify(value, null, 1)}\n`);
+}

package/src/budget.ts

@@ -7,14 +7,14 @@
  *
  * Two measurements are kept apart and always labelled:
  *
- * - `estimated`: the harness estimate of the conversation in the *next* request (pinned
- *   task + editable context + notices). Available before every call.
+ * - `estimated`: the harness estimate of the *next* request (pinned task + editable
+ *   context + notices, plus the system prompt and tool schemas once their sizes are
+ *   known). Available before every call.
  * - `observed`: the provider-reported input size of the *previous* request (OpenCode's
- *   assistant `tokens`). Authoritative but one call late, and it includes the system
- *   prompt and tool schemas, which the budget does not cover.
+ *   assistant `tokens`). Authoritative but one call late.
  *
- * The estimate alone governs reminder tiers and the reminder text; `observed` is shown
- * for reference only, because it covers more than the budget does. The harness never
+ * The estimate alone governs reminder tiers and the reminder text; `observed` calibrates
+ * the estimate and is shown for reference. The harness never
  * blocks a request; the overflow guard (overflow.ts) withholds old tool output when the
  * estimate exceeds budget - reserve.
  */
@@ -360,7 +360,7 @@ export function budgetNoticeText(
  * odd sample cannot run away.
  */
 export class EstimateCalibrator {
-	private pending: { estimate: number; rawCount: number } | undefined;
+	private pending: { estimate: number; rawCount: number; offset: number } | undefined;
 	private current = 1;
 	private samples = 0;
 
@@ -390,9 +390,11 @@ export class EstimateCalibrator {
 	 * Remember the raw (uncalibrated) estimate of the request about to be sent. The estimate
 	 * must cover the same scope as the provider count it will be compared with; an estimate
 	 * that omits the system prompt and tool schemas reads their size as undercounting.
+	 * `offset`: tokens of the provider count the estimate does not cover, already measured
+	 * (the fixed overhead); they are subtracted from the observation before the comparison.
 	 */
-	record(estimate: number, rawCount: number): void {
-		if (estimate > 0) this.pending = { estimate, rawCount };
+	record(estimate: number, rawCount: number, offset = 0): void {
+		if (estimate > 0) this.pending = { estimate, rawCount, offset };
 	}
 
 	/**
@@ -402,7 +404,7 @@ export class EstimateCalibrator {
 	 */
 	observe(observed: { tokens: number; index: number } | undefined): number {
 		if (!observed || !this.pending || observed.index < this.pending.rawCount) return this.current;
-		const sample = observed.tokens / this.pending.estimate;
+		const sample = (observed.tokens - this.pending.offset) / this.pending.estimate;
 		this.pending = undefined;
 		if (!Number.isFinite(sample) || sample <= 0) return this.current;
 		const smoothing = this.options.smoothing ?? 0.5;

package/src/channel.ts

@@ -0,0 +1,187 @@
+// The turn-free channel between the TUI plugin and the server plugin. Both sides speak
+// through OpenCode's `tui.command.execute` bus event: `POST /tui/publish` accepts any
+// command string, the server publishes it on the instance bus, and every listener sees it:
+// the server plugin's `event` hook, each TUI's own `api.event` and the TUI app, which
+// dispatches the string as a keymap command (an unknown name is a no-op). Requests and
+// replies are prefixed, base64url-encoded JSON, so they carry no spaces and never collide
+// with a real keymap command. Written for this package. Verified against opencode 1.18.34:
+// publish handler server/routes/instance/httpapi/handlers/tui.ts:84-93; command schema
+// packages/schema/src/tui-event.ts:13-37; plugin `event` hook plugin/index.ts:255-260 (events
+// of the plugin's own directory only); TUI app dispatch packages/tui/src/app.tsx:987-990.
+
+/** `tui.command.execute` event type (opencode packages/schema/src/tui-event.ts). */
+export const COMMAND_EVENT = "tui.command.execute";
+export const REQUEST_PREFIX = "opencode-clm.request:";
+export const REPLY_PREFIX = "opencode-clm.reply:";
+export const CHANNEL_VERSION = 1;
+
+export type ChannelOperation =
+	/** Where the server keeps the session's files. Answer: `directory` and `root`. */
+	| { op: "locate" }
+	/** `/clm config <setting> <value>`, `/clm on|off` and the panel's apply. */
+	| { op: "set"; setting: string; value: string }
+	/** `/clm config reset`. */
+	| { op: "settings-reset" }
+	/** `/clm reset`: drop the accepted revision. */
+	| { op: "reset" }
+	/** A file of the session directory (`path` relative to it). Answer: `content`, absent when missing. */
+	| { op: "read"; path: string }
+	/** A directory of the session directory (`""` = itself). Answer: `names`, absent when missing. */
+	| { op: "list"; path: string };
+
+/** Largest file a `read` reply carries; replies travel on the instance bus to every client. */
+export const MAX_READ_BYTES = 4 * 1024 * 1024;
+
+export type ChannelRequest = ChannelOperation & { v: typeof CHANNEL_VERSION; id: string; session: string };
+
+export interface ChannelReply {
+	v: typeof CHANNEL_VERSION;
+	id: string;
+	ok: boolean;
+	/** User-facing result or error. */
+	text: string;
+	/** `locate`: the session directory on the server. */
+	directory?: string;
+	/** `locate`: the server's instance directory, the root `file.read` paths are relative to. */
+	root?: string;
+	/** `read`: the file text. */
+	content?: string;
+	/** `list`: the entry names. */
+	names?: string[];
+}
+
+function encode(prefix: string, value: unknown): string {
+	return prefix + Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
+}
+
+function decode(prefix: string, command: unknown): Record<string, unknown> | undefined {
+	if (typeof command !== "string" || !command.startsWith(prefix)) return undefined;
+	try {
+		const value: unknown = JSON.parse(Buffer.from(command.slice(prefix.length), "base64url").toString("utf8"));
+		if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
+		const record = value as Record<string, unknown>;
+		if (record.v !== CHANNEL_VERSION || typeof record.id !== "string" || record.id === "") return undefined;
+		return record;
+	} catch {
+		return undefined;
+	}
+}
+
+export function encodeRequest(request: ChannelRequest): string {
+	return encode(REQUEST_PREFIX, request);
+}
+
+/** The request in a command string; undefined for anything else (foreign or malformed). */
+export function decodeRequest(command: unknown): ChannelRequest | undefined {
+	const record = decode(REQUEST_PREFIX, command);
+	if (!record || typeof record.session !== "string" || record.session === "") return undefined;
+	switch (record.op) {
+		case "locate":
+		case "settings-reset":
+		case "reset":
+			return { v: CHANNEL_VERSION, id: record.id as string, session: record.session, op: record.op };
+		case "read":
+		case "list":
+			if (typeof record.path !== "string") return undefined;
+			return { v: CHANNEL_VERSION, id: record.id as string, session: record.session, op: record.op, path: record.path };
+		case "set":
+			if (typeof record.setting !== "string" || typeof record.value !== "string") return undefined;
+			return { v: CHANNEL_VERSION, id: record.id as string, session: record.session, op: "set", setting: record.setting, value: record.value };
+		default:
+			return undefined;
+	}
+}
+
+export function encodeReply(reply: ChannelReply): string {
+	return encode(REPLY_PREFIX, reply);
+}
+
+export function decodeReply(command: unknown): ChannelReply | undefined {
+	const record = decode(REPLY_PREFIX, command);
+	if (!record || typeof record.ok !== "boolean" || typeof record.text !== "string") return undefined;
+	return {
+		v: CHANNEL_VERSION,
+		id: record.id as string,
+		ok: record.ok,
+		text: record.text,
+		...(typeof record.directory === "string" ? { directory: record.directory } : {}),
+		...(typeof record.root === "string" ? { root: record.root } : {}),
+		...(typeof record.content === "string" ? { content: record.content } : {}),
+		...(Array.isArray(record.names) && record.names.every((name) => typeof name === "string") ? { names: record.names as string[] } : {}),
+	};
+}
+
+/** The command string of a `tui.command.execute` event, if the value is one. */
+export function commandOf(event: unknown): string | undefined {
+	if (!event || typeof event !== "object") return undefined;
+	const { type, properties } = event as { type?: unknown; properties?: { command?: unknown } };
+	if (type !== COMMAND_EVENT) return undefined;
+	return typeof properties?.command === "string" ? properties.command : undefined;
+}
+
+/** The TUI side: send a request, wait for the reply with the same id. */
+export interface ChannelClientDeps {
+	/** Publishes a `tui.command.execute` event with this command string. */
+	publish(command: string): Promise<void>;
+	/** Subscribes to `tui.command.execute` command strings; returns the unsubscribe. */
+	subscribe(handler: (command: string) => void): () => void;
+	timeoutMs?: number;
+	/** Request ids; random by default. */
+	newId?: () => string;
+}
+
+export interface ChannelClient {
+	/** `timeoutMs` overrides the client's default for this request. */
+	request(session: string, operation: ChannelOperation, timeoutMs?: number): Promise<ChannelReply>;
+	dispose(): void;
+}
+
+export class ChannelTimeout extends Error {
+	constructor(readonly timeoutMs: number) {
+		super(
+			`the opencode-clm server plugin did not answer within ${Math.round(timeoutMs / 100) / 10} s: the server does not load ` +
+				"opencode-clm, loads an older version without the TUI channel, or has CLM disabled (enabled: false)",
+		);
+	}
+}
+
+export const CHANNEL_TIMEOUT_MS = 5_000;
+/** `locate` is asked on panel loads; a short wait keeps a missing server plugin from stalling them. */
+export const LOCATE_TIMEOUT_MS = 1_000;
+
+export function createChannelClient(deps: ChannelClientDeps): ChannelClient {
+	const pending = new Map<string, (reply: ChannelReply) => void>();
+	const unsubscribe = deps.subscribe((command) => {
+		const reply = decodeReply(command);
+		if (!reply) return;
+		pending.get(reply.id)?.(reply);
+	});
+	const newId = deps.newId ?? (() => crypto.randomUUID());
+	const defaultTimeoutMs = deps.timeoutMs ?? CHANNEL_TIMEOUT_MS;
+	return {
+		request(session, operation, timeoutMs = defaultTimeoutMs) {
+			const id = newId();
+			const request = { ...operation, v: CHANNEL_VERSION, id, session } as ChannelRequest;
+			return new Promise<ChannelReply>((resolve, reject) => {
+				const timer = setTimeout(() => {
+					pending.delete(id);
+					reject(new ChannelTimeout(timeoutMs));
+				}, timeoutMs);
+				pending.set(id, (reply) => {
+					clearTimeout(timer);
+					pending.delete(id);
+					resolve(reply);
+				});
+				deps.publish(encodeRequest(request)).catch((error: unknown) => {
+					clearTimeout(timer);
+					pending.delete(id);
+					reject(error instanceof Error ? error : new Error(String(error)));
+				});
+			});
+		},
+		dispose() {
+			unsubscribe();
+			pending.clear();
+		},
+	};
+}