@xynogen/pix-core 0.4.1 → 0.4.3

package/README.md

@@ -10,6 +10,8 @@ Pi activates extensions per installed package via each package's `pi.extensions`
 
 ## What's included
 
+**UI / UX extensions**
+
 | Package | Description |
 |---|---|
 | `pix-welcome` | ASCII π banner + startup health checks (version, auth, models, gitignore) |
@@ -22,6 +24,27 @@ Pi activates extensions per installed package via each package's `pi.extensions`
 | `pix-skills` | Agent skill loader (`read_skills` tool + 23 bundled skills) |
 | `pix-nudge` | Tool + capability nudge hooks |
 
+**Tool suite** (drop-in replacements for Pi's built-in tools)
+
+| Package | Description |
+|---|---|
+| `pix-read` | `read` — file read with syntax highlighting |
+| `pix-write` | `write` — file write with split-diff rendering |
+| `pix-edit` | `edit` — precise text replacement with per-edit diff |
+| `pix-find` | `find` — glob search with FFF acceleration |
+| `pix-grep` | `grep` — pattern search with FFF-prioritised results |
+| `pix-ls` | `ls` — directory listing as an icon tree |
+| `pix-bash` | `bash` — shell execution with framed output + exit-code summary |
+| `pix-todo` | `todo` — durable execution checklist |
+| `pix-ask` | `ask_user` — structured TUI questionnaire |
+
+**Behaviour**
+
+| Package | Description |
+|---|---|
+| `pix-optimizer` | Caveman mode + RTK tool rewriting + jq/TOON JSON compression (`/opt`) |
+| `pix-gate` | Permission gate for dangerous bash commands |
+
 ## Install
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xynogen/pix-core",
-	"version": "0.4.1",
+	"version": "0.4.3",
 	"description": "Pi extension bundle — installs and activates all core pix-* extensions",
 	"type": "module",
 	"main": "src/extension.ts",

package/src/once.test.ts

@@ -1,62 +1,143 @@
 import { afterEach, describe, expect, it } from "bun:test";
+import registerTodo from "@xynogen/pix-todo/src/todo.ts";
 
-// Mirror of the per-member guard. pix-core does not own once.ts (each member
+// Mirror of the per-instance guard. pix-core does not own once.ts (each member
 // duplicates it to stay cross-dep-free), so we re-declare the contract here and
 // assert the dedupe semantics that the aggregator relies on.
-function once(key: string, fn: () => void): void {
-	const g = globalThis as { __pixLoaded?: Set<string> };
-	const loaded = (g.__pixLoaded ??= new Set<string>());
+function once(pi: object, key: string, fn: () => void): void {
+	const g = globalThis as { __pixOnce?: WeakMap<object, Set<string>> };
+	const registry = (g.__pixOnce ??= new WeakMap<object, Set<string>>());
+	let loaded = registry.get(pi);
+	if (!loaded) {
+		loaded = new Set<string>();
+		registry.set(pi, loaded);
+	}
 	if (loaded.has(key)) return;
 	loaded.add(key);
 	fn();
 }
 
 afterEach(() => {
-	delete (globalThis as { __pixLoaded?: Set<string> }).__pixLoaded;
+	delete (globalThis as { __pixOnce?: WeakMap<object, Set<string>> }).__pixOnce;
 });
 
 describe("once", () => {
 	it("runs the factory on first invocation", () => {
+		const pi = {};
 		let calls = 0;
-		once("pix-footer", () => {
+		once(pi, "pix-footer", () => {
 			calls++;
 		});
 		expect(calls).toBe(1);
 	});
 
-	it("skips repeated invocations of the same key", () => {
+	it("skips repeated invocations of the same key on the same pi", () => {
+		const pi = {};
 		let calls = 0;
 		const reg = () => {
 			calls++;
 		};
-		once("pix-footer", reg);
-		once("pix-footer", reg);
-		once("pix-footer", reg);
+		once(pi, "pix-footer", reg);
+		once(pi, "pix-footer", reg);
+		once(pi, "pix-footer", reg);
 		expect(calls).toBe(1);
 	});
 
-	it("isolates distinct keys", () => {
+	it("isolates distinct keys on the same pi", () => {
+		const pi = {};
 		const seen: string[] = [];
-		once("pix-footer", () => seen.push("footer"));
-		once("pix-welcome", () => seen.push("welcome"));
+		once(pi, "pix-footer", () => seen.push("footer"));
+		once(pi, "pix-welcome", () => seen.push("welcome"));
 		expect(seen).toEqual(["footer", "welcome"]);
 	});
 
-	it("shares the registry across calls via globalThis", () => {
+	it("shares the registry across calls via globalThis (same pi)", () => {
+		const pi = {};
 		let calls = 0;
-		once("pix-skills", () => {
+		once(pi, "pix-skills", () => {
 			calls++;
 		});
 		// A second loader pass (e.g. standalone install after pix-core) reuses
-		// the same globalThis registry and must not re-run.
-		once("pix-skills", () => {
+		// the same globalThis registry for the same pi and must not re-run.
+		once(pi, "pix-skills", () => {
 			calls++;
 		});
 		expect(calls).toBe(1);
-		expect(
-			(globalThis as { __pixLoaded?: Set<string> }).__pixLoaded?.has(
-				"pix-skills",
-			),
-		).toBe(true);
+	});
+
+	it("re-runs for a new pi instance with the same key (/new rehydration)", () => {
+		const pi1 = {};
+		const pi2 = {};
+		let calls = 0;
+		once(pi1, "pix-footer", () => {
+			calls++;
+		});
+		// pi2 is a fresh instance (as built by Pi on /new, /resume, /fork, /reload).
+		// The factory must run again — this is the rehydration guarantee.
+		once(pi2, "pix-footer", () => {
+			calls++;
+		});
+		expect(calls).toBe(2);
+	});
+
+	it("same key on two different pi instances dedupes within each instance", () => {
+		const pi1 = {};
+		const pi2 = {};
+		let calls1 = 0;
+		let calls2 = 0;
+		once(pi1, "pix-welcome", () => {
+			calls1++;
+		});
+		once(pi1, "pix-welcome", () => {
+			calls1++;
+		}); // second on pi1 → skip
+		once(pi2, "pix-welcome", () => {
+			calls2++;
+		});
+		once(pi2, "pix-welcome", () => {
+			calls2++;
+		}); // second on pi2 → skip
+		expect(calls1).toBe(1); // deduped within pi1
+		expect(calls2).toBe(1); // deduped within pi2
+	});
+});
+
+// Behavior pin: prove a REAL guarded member dedupes when its factory runs
+// twice against the SAME pi — the exact scenario the aggregator creates when a
+// tool is installed both via pix-core (this boots it) and standalone (Pi boots
+// it again). The member must register its tool only once or Pi reports a
+// tool conflict.
+describe("member factory dedupe (pix-todo)", () => {
+	function makeHost() {
+		const toolNames: string[] = [];
+		const pi = {
+			registerTool(def: { name: string }) {
+				toolNames.push(def.name);
+			},
+			appendEntry() {},
+			on() {},
+		} as never;
+		return { pi, toolNames };
+	}
+
+	it("registers the tool once across core + standalone activation (same pi)", () => {
+		const { pi, toolNames } = makeHost();
+		// First pass: pix-core's aggregator invokes the member factory.
+		registerTodo(pi);
+		// Second pass: standalone install loads the same module and invokes it
+		// again. The globalThis once() registry must suppress re-registration.
+		registerTodo(pi);
+		expect(toolNames).toEqual(["todo"]);
+	});
+
+	it("registers the tool again for a fresh pi instance (/new rehydration)", () => {
+		const { pi: pi1, toolNames: tools1 } = makeHost();
+		const { pi: pi2, toolNames: tools2 } = makeHost();
+		// First session.
+		registerTodo(pi1);
+		// /new: a fresh pi is built; factory must run again.
+		registerTodo(pi2);
+		expect(tools1).toEqual(["todo"]);
+		expect(tools2).toEqual(["todo"]);
 	});
 });