@xynogen/pix-runtime 0.12.2 → 0.13.0

package/README.md

@@ -10,7 +10,9 @@ See `DESIGN.md` for the full contract.
 ## What it does
 
 - Versioned, sparse `pix.json` (`$version: 1`) — defaults resolve in code.
-- Typed sections: `collapse`, `pretty`, `io`, `compaction`, `optimizer`, `gate`.
+- Typed sections: `collapse`, `pretty`, `io`, `compaction`, `optimizer`, `gate`, `fetch`, `search`, `voice`, `toolbox`.
+- `/pix` has a Footer tab for `pretty.footer` visibility.
+- Startup imports legacy service config files and archives them only after a successful save.
 - Atomic writes behind a serialized in-process queue and a short-lived
   cross-process lock. A failed write leaves the old file intact.
 - Immutable, deeply frozen config snapshots with a monotonic revision.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-runtime",
-	"version": "0.12.2",
+	"version": "0.13.0",
 	"description": "Pix shared runtime — versioned pix.json config, atomic persistence, typed change events",
 	"type": "module",
 	"main": "src/index.ts",
@@ -28,6 +28,7 @@
 		"./collapse": "./src/collapse.ts",
 		"./icon-catalog": "./src/icon-catalog.ts",
 		"./io": "./src/io.ts",
+		"./hashline": "./src/hashline.ts",
 		"./lfid": "./src/lfid.ts",
 		"./once": "./src/once.ts",
 		"./paths": "./src/paths.ts",
@@ -63,5 +64,8 @@
 	"peerDependencies": {
 		"@earendil-works/pi-coding-agent": "*",
 		"@earendil-works/pi-tui": "*"
+	},
+	"dependencies": {
+		"xxhash-wasm": "1.1.0"
 	}
 }

package/src/hashline.check.mjs

@@ -0,0 +1,11 @@
+import assert from "node:assert/strict";
+import xxhash from "xxhash-wasm";
+
+const { h32, h32Raw } = await xxhash();
+// Official xxHash v0.8.3 tests/sanity_test_vectors.h, empty-input vectors.
+assert.equal(h32("", 0), 0x02cc5d05);
+assert.equal(h32("", 0x9e3779b1), 0x36b78ae7);
+for (const text of ["", "hello", "中文🙂", " a ", "\tconst x = 1;  "]) {
+	assert.equal(h32(text, 0), h32Raw(new TextEncoder().encode(text), 0));
+	console.log(`${(h32(text, 0) & 0xfff).toString(16).toUpperCase().padStart(3, "0")}|${text}`);
+}

package/src/hashline.ts

@@ -0,0 +1,71 @@
+import xxhash from "xxhash-wasm";
+
+// Pi reevaluates shared modules with Jiti. Both tools must share one WASM instance.
+const global = globalThis as typeof globalThis & {
+	__pixHashline?: {
+		initialization?: Promise<void>;
+		h32?: (input: string, seed?: number) => number;
+	};
+};
+const state = global.__pixHashline ?? {};
+global.__pixHashline = state;
+
+export function initHashline(): Promise<void> {
+	state.initialization ??= xxhash()
+		.then((hash) => {
+			state.h32 = hash.h32;
+		})
+		.catch((error) => {
+			throw new Error("Hashline WASM initialization failed", { cause: error });
+		});
+	return state.initialization;
+}
+
+export function hashLine(text: string): string {
+	if (!state.h32) throw new Error("Hashline WASM is not initialized");
+	return (state.h32(text, 0) & 0xfff).toString(16).toUpperCase().padStart(3, "0");
+}
+
+export function anchor(line: number, text: string): string {
+	return `${line}#${hashLine(text)}`;
+}
+
+export function parseAnchor(value: unknown): { line: number; hash: string } {
+	const match = typeof value === "string" ? /^([1-9]\d*)#([0-9A-F]{3})$/.exec(value) : null;
+	if (!match || !Number.isSafeInteger(Number(match[1])))
+		throw new Error(`Invalid anchor: ${String(value)}`);
+	return { line: Number(match[1]), hash: match[2]! };
+}
+
+export type SourceLine = { text: string; ending: string };
+
+export function decodeLines(bytes: Uint8Array): {
+	bom: string;
+	lines: SourceLine[];
+	delimiter: string;
+	finalNewline: boolean;
+} {
+	const decoded = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
+	if (decoded.includes("\0")) throw new Error("Unsupported binary text: NUL byte");
+	const bom = decoded.startsWith("\uFEFF") ? "\uFEFF" : "";
+	const text = decoded.slice(bom.length);
+	const lines: SourceLine[] = [];
+	const counts = new Map<string, number>();
+	let start = 0;
+	for (const match of text.matchAll(/\r\n|\r|\n/g)) {
+		const ending = match[0];
+		lines.push({ text: text.slice(start, match.index), ending });
+		counts.set(ending, (counts.get(ending) ?? 0) + 1);
+		start = match.index + ending.length;
+	}
+	if (start < text.length) lines.push({ text: text.slice(start), ending: "" });
+	let delimiter = "\n";
+	let highest = 0;
+	for (const [ending, count] of counts) {
+		if (count > highest) {
+			delimiter = ending;
+			highest = count;
+		}
+	}
+	return { bom, lines, delimiter, finalNewline: lines.length > 0 && lines.at(-1)!.ending !== "" };
+}

package/src/migrations.ts

@@ -106,7 +106,31 @@ export function importOptimizerSidecar(
 	agentDir: string,
 	ctx: ParseContext,
 ): { changed: boolean; archive?: () => void } {
-	const sidecarPath = join(agentDir, "optimizer.json");
+	const imports = ["optimizer", "voice", "fetch", "search", "toolbox"];
+	let changed = false;
+	const archives: (() => void)[] = [];
+	for (const section of imports) {
+		const result = importSidecar(doc, agentDir, ctx, section);
+		changed ||= result.changed;
+		if (result.archive) archives.push(result.archive);
+	}
+	return {
+		changed,
+		archive: archives.length
+			? () => {
+					for (const archive of archives) archive();
+				}
+			: undefined,
+	};
+}
+
+function importSidecar(
+	doc: RawDocument,
+	agentDir: string,
+	ctx: ParseContext,
+	section: string,
+): { changed: boolean; archive?: () => void } {
+	const sidecarPath = join(agentDir, `${section}.json`);
 	if (!existsSync(sidecarPath)) return { changed: false };
 
 	let raw: Record<string, unknown>;
@@ -118,32 +142,39 @@ export function importOptimizerSidecar(
 		ctx.diagnostic({
 			code: "MIGRATION_FAILED",
 			severity: "warning",
-			path: "optimizer.json",
-			message: "malformed optimizer sidecar left untouched",
+			path: `${section}.json`,
+			message: `malformed ${section} config left unchanged`,
 			cause: err,
 		});
 		return { changed: false };
 	}
 
-	const existing = isObj(doc.optimizer) ? { ...doc.optimizer } : {};
+	const existing = isObj(doc[section]) ? { ...doc[section] } : {};
 	let changed = false;
-	for (const key of OPTIMIZER_KEYS) {
+	for (const key of section === "optimizer" ? OPTIMIZER_KEYS : Object.keys(raw)) {
 		const value = raw[key];
-		if (typeof value === "string" && !(key in existing)) {
+		if ((section !== "optimizer" || typeof value === "string") && !(key in existing)) {
 			existing[key] = value;
 			changed = true;
 		}
 	}
-	if (changed) doc.optimizer = existing;
+	if (changed) doc[section] = existing;
 
-	const hasLegacyToon = typeof raw.toon === "string";
+	const hasLegacyToon = section === "optimizer" && typeof raw.toon === "string";
 	const archive = () => {
 		let target = `${sidecarPath}.migrated-v1`;
 		if (existsSync(target)) target = `${target}.${Date.now()}`;
 		try {
 			renameSync(sidecarPath, target);
-		} catch {
-			// A competing process may have moved it — ENOENT is benign.
+		} catch (err) {
+			if ((err as NodeJS.ErrnoException).code !== "ENOENT")
+				ctx.diagnostic({
+					code: "MIGRATION_FAILED",
+					severity: "warning",
+					path: sidecarPath,
+					message: "config backup failed; original file remains",
+					cause: err,
+				});
 		}
 	};
 

package/src/pix-command.ts

@@ -19,7 +19,7 @@ import {
 import { createBinariesTab } from "./binaries-tab.ts";
 import { icon } from "./icon-catalog.ts";
 import type { PixRuntime } from "./runtime.ts";
-import type { DeepPartial, SectionHandle } from "./schema.ts";
+import { type DeepPartial, deepMerge, type SectionHandle } from "./schema.ts";
 import { collapseSection } from "./sections/collapse.ts";
 import { compactionSection } from "./sections/compaction.ts";
 import { gateSection } from "./sections/gate.ts";
@@ -184,6 +184,17 @@ const SETTINGS: SettingRow<unknown>[] = [
 		read: (v) => v.guardrails,
 		patch: (guardrails) => ({ guardrails: guardrails as "on" | "off" }),
 	}),
+	...Object.keys(prettySection.defaults.footer).map((key) => {
+		const part = key as keyof typeof prettySection.defaults.footer;
+		return row({
+			section: "Footer",
+			label: part,
+			handle: prettySection,
+			values: ["show", "hide"],
+			read: (v) => (v.footer[part] ? "show" : "hide"),
+			patch: (value) => ({ footer: { [part]: value === "show" } }),
+		});
+	}),
 ];
 
 /** Env whose agent dir is the folder holding pix.json (binary.json lives beside it). */
@@ -191,7 +202,7 @@ function binariesEnv(runtime: PixRuntime): NodeJS.ProcessEnv {
 	return { ...process.env, PI_CODING_AGENT_DIR: dirname(runtime.path) };
 }
 
-const TABS = ["Settings", "Binaries"] as const;
+const TABS = ["Settings", "Binaries", "Footer"] as const;
 
 function buildSummary(runtime: PixRuntime): string {
 	const lines = [`Pix Settings (${runtime.path})`, ""];
@@ -270,13 +281,16 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 					const switchTab = (direction: -1 | 1) => {
 						const next = (TABS.indexOf(tab) + direction + TABS.length) % TABS.length;
 						tab = TABS[next] ?? "Settings";
+						selected = 0;
 						bodyOffset = 0;
 						inspectingPage = false;
 						if (tab === "Binaries") binariesTab().refresh();
 					};
 
+					const rows = () =>
+						SETTINGS.filter((r) => (r.section === "Footer") === (tab === "Footer"));
 					const cycle = (direction: -1 | 1) => {
-						const row = SETTINGS[selected];
+						const row = rows()[selected];
 						if (!row) return;
 						// Functional updater: the runtime queue serializes writes, and the
 						// callback sees the latest committed value — so rapid presses each
@@ -296,7 +310,7 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 							const next = (cur + direction + row.values.length) % row.values.length;
 							const val = row.values[next];
 							if (val === undefined) return state;
-							return { ...state, ...(row.patch(val) as object) };
+							return deepMerge(state, row.patch(val) as DeepPartial<SettingsState>);
 						};
 						// Re-render AFTER the commit lands; the synchronous render in
 						// handleInput fires before the queued write and shows a stale value.
@@ -306,7 +320,7 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 							.catch(() => ui.notify(`pix: failed to update ${row.label}`, "error"));
 					};
 					const move = (direction: -1 | 1) => {
-						selected = (selected + direction + SETTINGS.length) % SETTINGS.length;
+						selected = (selected + direction + rows().length) % rows().length;
 						inspectingPage = false;
 					};
 
@@ -346,12 +360,13 @@ export function registerPixCommand(pi: ExtensionAPI, runtime: PixRuntime): void
 								maxBodyOffset = result.maxBodyOffset;
 								return result.lines;
 							}
-							const labelW = Math.max(...SETTINGS.map((r) => r.label.length));
+							const settings = rows();
+							const labelW = Math.max(...settings.map((r) => r.label.length));
 							const body: string[] = [];
 							const settingBodyLines: number[] = [];
 							let lastSection = "";
-							for (let i = 0; i < SETTINGS.length; i++) {
-								const row = SETTINGS[i];
+							for (let i = 0; i < settings.length; i++) {
+								const row = settings[i];
 								if (!row) continue;
 								if (row.section !== lastSection) {
 									if (lastSection) body.push("");

package/src/sections/index.ts

@@ -30,6 +30,18 @@ import { ioSection } from "./io.ts";
 import { optimizerSection } from "./optimizer.ts";
 import { prettySection } from "./pretty.ts";
 
+export {
+	fetchSection,
+	searchSection,
+	type ToolboxConfig,
+	toolboxSection,
+	type VoiceConfig,
+	voiceSection,
+	type WebConfig,
+} from "./services.ts";
+
+import { fetchSection, searchSection, toolboxSection, voiceSection } from "./services.ts";
+
 /** All built-in sections, in stable registration order. */
 export const builtinSections = [
 	collapseSection,
@@ -38,4 +50,8 @@ export const builtinSections = [
 	optimizerSection,
 	gateSection,
 	compactionSection,
+	fetchSection,
+	searchSection,
+	voiceSection,
+	toolboxSection,
 ] as const;

package/src/sections/pretty.ts

@@ -1,4 +1,4 @@
-import { defineSection, enumOr, isObj, posNumOr } from "../schema.ts";
+import { boolOr, defineSection, enumOr, isObj, posNumOr } from "../schema.ts";
 
 export type IconMode = "nerd" | "unicode" | "ascii";
 export type LsStyle = "grid" | "tree";
@@ -19,6 +19,21 @@ export interface PrettyConfig {
 	maxHighlightChars: number;
 	cacheLimit: number;
 	diff: DiffConfig;
+	footer: Record<
+		| "mode"
+		| "cwd"
+		| "git"
+		| "context"
+		| "model"
+		| "thinking"
+		| "price"
+		| "score"
+		| "statuses"
+		| "tokens"
+		| "cost"
+		| "tps",
+		boolean
+	>;
 }
 
 const ICON_MODES: readonly IconMode[] = ["nerd", "unicode", "ascii"];
@@ -43,15 +58,35 @@ const DEFAULTS: Readonly<PrettyConfig> = {
 	maxHighlightChars: 80_000,
 	cacheLimit: 128,
 	diff: { splitMinWidth: 150, splitMinCodeWidth: 60 },
+	footer: {
+		mode: true,
+		cwd: true,
+		git: true,
+		context: true,
+		model: true,
+		thinking: true,
+		price: true,
+		score: true,
+		statuses: true,
+		tokens: true,
+		cost: true,
+		tps: true,
+	},
 };
 
 export const prettySection = defineSection<"pretty", PrettyConfig>({
 	key: "pretty",
 	defaults: DEFAULTS,
 	parse(raw) {
-		if (!isObj(raw)) return { ...DEFAULTS, diff: { ...DEFAULTS.diff } };
+		if (!isObj(raw)) return structuredClone(DEFAULTS);
 		const rawDiff = isObj(raw.diff) ? raw.diff : {};
+		const rawFooter = isObj(raw.footer) ? raw.footer : {};
+		const footer = { ...DEFAULTS.footer };
+		for (const key of Object.keys(footer) as (keyof typeof footer)[]) {
+			footer[key] = boolOr(rawFooter[key], DEFAULTS.footer[key]);
+		}
 		return {
+			footer,
 			icons: enumOr(raw.icons, ICON_MODES, DEFAULTS.icons),
 			lsStyle: enumOr(raw.lsStyle, LS_STYLES, DEFAULTS.lsStyle),
 			maxRenderWidth: renderSizeOr(raw.maxRenderWidth, DEFAULTS.maxRenderWidth),

package/src/sections/services.ts

@@ -0,0 +1,71 @@
+import { boolOr, defineSection, isObj, strArr } from "../schema.ts";
+
+export interface WebConfig {
+	provider: string;
+	nineRouterModel: string;
+}
+
+const webDefaults: WebConfig = { provider: "auto", nineRouterModel: "exa" };
+function parseWeb(raw: unknown): WebConfig {
+	const item = isObj(raw) ? raw : {};
+	return {
+		provider: typeof item.provider === "string" ? item.provider : webDefaults.provider,
+		nineRouterModel:
+			typeof item.nineRouterModel === "string" ? item.nineRouterModel : webDefaults.nineRouterModel,
+	};
+}
+export const fetchSection = defineSection({ key: "fetch", defaults: webDefaults, parse: parseWeb });
+export const searchSection = defineSection({
+	key: "search",
+	defaults: webDefaults,
+	parse: parseWeb,
+});
+
+const voiceDefaults = {
+	sttProvider: "auto",
+	ttsProvider: "auto",
+	sttNineRouterModel: "dg/nova-3",
+	ttsNineRouterModel: "edge-tts/en-US-AriaNeural",
+	ttsPlay: true,
+	sttDevice: "default",
+	sttLanguage: "auto",
+	sttShortcut: "ctrl+alt+z",
+	sttCleanup: "off",
+};
+export type VoiceConfig = typeof voiceDefaults;
+export const voiceSection = defineSection({
+	key: "voice",
+	defaults: voiceDefaults,
+	parse(raw): VoiceConfig {
+		const item = isObj(raw) ? raw : {};
+		const result = { ...voiceDefaults };
+		for (const key of Object.keys(result) as (keyof VoiceConfig)[]) {
+			if (key === "ttsPlay") result.ttsPlay = boolOr(item.ttsPlay, true);
+			else if (typeof item[key] === "string" && item[key].trim()) result[key] = item[key].trim();
+		}
+		result.sttLanguage = result.sttLanguage.toLowerCase();
+		return result;
+	},
+});
+export interface ToolboxConfig {
+	disabledTools?: string[];
+	loadedTools?: string[];
+	enabledTools?: string[];
+}
+export const toolboxSection = defineSection<"toolbox", ToolboxConfig>({
+	key: "toolbox",
+	defaults: {},
+	parse(raw) {
+		const result: ToolboxConfig = {};
+		if (isObj(raw)) {
+			for (const key of ["disabledTools", "loadedTools", "enabledTools"] as const) {
+				if (
+					Array.isArray(raw[key]) &&
+					raw[key].every((value: unknown) => typeof value === "string")
+				)
+					result[key] = strArr(raw[key]);
+			}
+		}
+		return result;
+	},
+});