@xynogen/pix-runtime 0.1.0

package/src/sections/gate.ts

@@ -0,0 +1,71 @@
+import { boolOr, defineSection, isObj, strArr } from "../schema.ts";
+
+export type GateSeverity = "risky" | "dangerous" | "critical";
+
+export interface GateRuleConfig {
+	pattern: string;
+	flags?: string;
+	severity?: GateSeverity;
+	reason?: string;
+}
+
+export interface GateConfig {
+	disableDefaults: boolean;
+	autoApprove: string[];
+	extraRules: GateRuleConfig[];
+}
+
+const SEVERITIES: readonly GateSeverity[] = ["risky", "dangerous", "critical"];
+
+const DEFAULTS: Readonly<GateConfig> = {
+	disableDefaults: false,
+	autoApprove: [],
+	extraRules: [],
+};
+
+/** Validate a regex pattern + flags; return an error message or undefined. */
+function regexError(pattern: string, flags?: string): string | undefined {
+	try {
+		new RegExp(pattern, flags);
+		return undefined;
+	} catch (err) {
+		return err instanceof Error ? err.message : String(err);
+	}
+}
+
+export const gateSection = defineSection<"gate", GateConfig>({
+	key: "gate",
+	defaults: DEFAULTS,
+	parse(raw, ctx) {
+		if (!isObj(raw)) return { disableDefaults: false, autoApprove: [], extraRules: [] };
+		const extraRules: GateRuleConfig[] = [];
+		if (Array.isArray(raw.extraRules)) {
+			raw.extraRules.forEach((r, i) => {
+				if (!isObj(r) || typeof r.pattern !== "string") return;
+				const flags = typeof r.flags === "string" ? r.flags : undefined;
+				const err = regexError(r.pattern, flags);
+				if (err) {
+					ctx.diagnostic({
+						code: "INVALID_VALUE",
+						severity: "warning",
+						path: `gate.extraRules[${i}]`,
+						message: `invalid regex: ${err}`,
+					});
+					return;
+				}
+				const rule: GateRuleConfig = { pattern: r.pattern };
+				if (flags) rule.flags = flags;
+				if (typeof r.severity === "string" && SEVERITIES.includes(r.severity as GateSeverity)) {
+					rule.severity = r.severity as GateSeverity;
+				}
+				if (typeof r.reason === "string") rule.reason = r.reason;
+				extraRules.push(rule);
+			});
+		}
+		return {
+			disableDefaults: boolOr(raw.disableDefaults, DEFAULTS.disableDefaults),
+			autoApprove: strArr(raw.autoApprove),
+			extraRules,
+		};
+	},
+});

package/src/sections/index.ts

@@ -0,0 +1,34 @@
+export { type CollapseConfig, collapseSection } from "./collapse.ts";
+export {
+	type GateConfig,
+	type GateRuleConfig,
+	type GateSeverity,
+	gateSection,
+} from "./gate.ts";
+export {
+	type CavemanLevel,
+	type OptimizerConfig,
+	optimizerSection,
+	type PonytailLevel,
+	type Toggle,
+} from "./optimizer.ts";
+export {
+	type DiffConfig,
+	type IconMode,
+	type LsStyle,
+	type PrettyConfig,
+	prettySection,
+} from "./pretty.ts";
+
+import { collapseSection } from "./collapse.ts";
+import { gateSection } from "./gate.ts";
+import { optimizerSection } from "./optimizer.ts";
+import { prettySection } from "./pretty.ts";
+
+/** All built-in sections, in stable registration order. */
+export const builtinSections = [
+	collapseSection,
+	prettySection,
+	optimizerSection,
+	gateSection,
+] as const;

package/src/sections/optimizer.ts

@@ -0,0 +1,37 @@
+import { defineSection, enumOr, isObj } from "../schema.ts";
+
+export type CavemanLevel = "off" | "lite" | "full" | "ultra" | "micro";
+export type PonytailLevel = "off" | "lite" | "full" | "ultra";
+export type Toggle = "off" | "on";
+
+export interface OptimizerConfig {
+	caveman: CavemanLevel;
+	rtk: Toggle;
+	toon: Toggle;
+	ponytail: PonytailLevel;
+}
+
+const CAVEMAN: readonly CavemanLevel[] = ["off", "lite", "full", "ultra", "micro"];
+const PONYTAIL: readonly PonytailLevel[] = ["off", "lite", "full", "ultra"];
+const TOGGLE: readonly Toggle[] = ["off", "on"];
+
+const DEFAULTS: Readonly<OptimizerConfig> = {
+	caveman: "off",
+	rtk: "on",
+	toon: "on",
+	ponytail: "off",
+};
+
+export const optimizerSection = defineSection<"optimizer", OptimizerConfig>({
+	key: "optimizer",
+	defaults: DEFAULTS,
+	parse(raw) {
+		if (!isObj(raw)) return { ...DEFAULTS };
+		return {
+			caveman: enumOr(raw.caveman, CAVEMAN, DEFAULTS.caveman),
+			rtk: enumOr(raw.rtk, TOGGLE, DEFAULTS.rtk),
+			toon: enumOr(raw.toon, TOGGLE, DEFAULTS.toon),
+			ponytail: enumOr(raw.ponytail, PONYTAIL, DEFAULTS.ponytail),
+		};
+	},
+});

package/src/sections/pretty.ts

@@ -0,0 +1,53 @@
+import { defineSection, enumOr, isObj, posNumOr } from "../schema.ts";
+
+export type IconMode = "nerd" | "unicode" | "ascii";
+export type LsStyle = "grid" | "tree";
+
+export interface DiffConfig {
+	splitMinWidth: number;
+	splitMinCodeWidth: number;
+}
+
+export interface PrettyConfig {
+	icons: IconMode;
+	lsStyle: LsStyle;
+	maxPreviewLines: number;
+	maxRenderLines: number;
+	maxHighlightChars: number;
+	cacheLimit: number;
+	diff: DiffConfig;
+}
+
+const ICON_MODES: readonly IconMode[] = ["nerd", "unicode", "ascii"];
+const LS_STYLES: readonly LsStyle[] = ["grid", "tree"];
+
+const DEFAULTS: Readonly<PrettyConfig> = {
+	icons: "nerd",
+	lsStyle: "grid",
+	maxPreviewLines: 80,
+	maxRenderLines: 150,
+	maxHighlightChars: 80_000,
+	cacheLimit: 128,
+	diff: { splitMinWidth: 150, splitMinCodeWidth: 60 },
+};
+
+export const prettySection = defineSection<"pretty", PrettyConfig>({
+	key: "pretty",
+	defaults: DEFAULTS,
+	parse(raw) {
+		if (!isObj(raw)) return { ...DEFAULTS, diff: { ...DEFAULTS.diff } };
+		const rawDiff = isObj(raw.diff) ? raw.diff : {};
+		return {
+			icons: enumOr(raw.icons, ICON_MODES, DEFAULTS.icons),
+			lsStyle: enumOr(raw.lsStyle, LS_STYLES, DEFAULTS.lsStyle),
+			maxPreviewLines: posNumOr(raw.maxPreviewLines, DEFAULTS.maxPreviewLines),
+			maxRenderLines: posNumOr(raw.maxRenderLines, DEFAULTS.maxRenderLines),
+			maxHighlightChars: posNumOr(raw.maxHighlightChars, DEFAULTS.maxHighlightChars),
+			cacheLimit: posNumOr(raw.cacheLimit, DEFAULTS.cacheLimit),
+			diff: {
+				splitMinWidth: posNumOr(rawDiff.splitMinWidth, DEFAULTS.diff.splitMinWidth),
+				splitMinCodeWidth: posNumOr(rawDiff.splitMinCodeWidth, DEFAULTS.diff.splitMinCodeWidth),
+			},
+		};
+	},
+});

package/src/testing.ts

@@ -0,0 +1,28 @@
+/**
+ * testing.ts — construct isolated runtimes with injected adapters so tests
+ * never touch the real agent directory or the process singleton.
+ */
+
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { FileStorage } from "./persistence.ts";
+import { createRuntime, type PixRuntime } from "./runtime.ts";
+
+export interface IsolatedRuntime {
+	runtime: PixRuntime;
+	agentDir: string;
+	/** Remove the temp directory. */
+	cleanup(): void;
+}
+
+/** Create a runtime backed by a fresh temp directory. */
+export function createIsolatedRuntime(): IsolatedRuntime {
+	const agentDir = mkdtempSync(join(tmpdir(), "pix-runtime-"));
+	const runtime = createRuntime({ agentDir, storage: new FileStorage(agentDir) });
+	return {
+		runtime,
+		agentDir,
+		cleanup: () => rmSync(agentDir, { recursive: true, force: true }),
+	};
+}