@bdsqqq/pi 0.0.1

package/dist/core/config.js

@@ -0,0 +1,201 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+//#region packages/core/config/index.ts
+/**
+* shared config reader for pi extensions.
+*
+* reads per-extension configuration from pi's settings.json files,
+* keyed by extension namespace (e.g. `"@bds_pi/librarian"`).
+*
+* merge order: defaults → global (~/.pi/agent/bds-pi.json) → project-local (.pi/settings.json).
+* project-local is opt-in via `allowProjectConfig` to prevent malicious repo overrides.
+*/
+let _globalSettingsPath = null;
+function setGlobalSettingsPath(p) {
+	_globalSettingsPath = p;
+}
+const _cache = /* @__PURE__ */ new Map();
+function clearConfigCache() {
+	_cache.clear();
+}
+function resolveGlobalSettingsPath() {
+	return _globalSettingsPath ?? path.join(os.homedir(), ".pi", "agent", "bds-pi.json");
+}
+function readJsonFile(filePath) {
+	if (_cache.has(filePath)) return _cache.get(filePath);
+	try {
+		const raw = fs.readFileSync(filePath, "utf-8");
+		const parsed = JSON.parse(raw);
+		_cache.set(filePath, parsed);
+		return parsed;
+	} catch (err) {
+		if (err.code !== "ENOENT") console.error(`[@bds_pi/config] failed to read ${filePath}:`, err);
+		_cache.set(filePath, null);
+		return null;
+	}
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMerge(base, override) {
+	const result = { ...base };
+	for (const key of Object.keys(override)) {
+		const baseVal = result[key];
+		const overVal = override[key];
+		if (isPlainObject(baseVal) && isPlainObject(overVal)) result[key] = deepMerge(baseVal, overVal);
+		else result[key] = overVal;
+	}
+	return result;
+}
+function getExtensionConfig(namespace, defaults, opts) {
+	let merged = { ...defaults };
+	const globalSettings = readJsonFile(resolveGlobalSettingsPath());
+	if (globalSettings && isPlainObject(globalSettings[namespace])) merged = deepMerge(merged, globalSettings[namespace]);
+	if (opts?.allowProjectConfig && opts.cwd) {
+		const projectSettings = readJsonFile(path.join(opts.cwd, ".pi", "settings.json"));
+		if (projectSettings && isPlainObject(projectSettings[namespace])) merged = deepMerge(merged, projectSettings[namespace]);
+	}
+	return merged;
+}
+/** read a top-level (non-namespaced) key from the global settings file. */
+function getGlobalConfig(key) {
+	const settings = readJsonFile(resolveGlobalSettingsPath());
+	if (!settings || !(key in settings)) return void 0;
+	return settings[key];
+}
+/** directory containing the global settings file (e.g. ~/.pi/agent/). */
+function resolveConfigDir() {
+	return path.dirname(resolveGlobalSettingsPath());
+}
+if (import.meta.vitest) {
+	const { afterEach, describe, expect, test } = import.meta.vitest;
+	const tmpdir = os.tmpdir();
+	function writeTmpJson(dir, filename, data) {
+		const filePath = path.join(dir, filename);
+		fs.mkdirSync(path.dirname(filePath), { recursive: true });
+		fs.writeFileSync(filePath, JSON.stringify(data));
+		return filePath;
+	}
+	afterEach(() => {
+		clearConfigCache();
+		_globalSettingsPath = null;
+	});
+	describe("getExtensionConfig", () => {
+		test("returns defaults when no settings file exists", () => {
+			setGlobalSettingsPath(path.join(tmpdir, `nonexistent-${Date.now()}.json`));
+			expect(getExtensionConfig("@bds_pi/test", {
+				foo: "bar",
+				n: 1
+			})).toEqual({
+				foo: "bar",
+				n: 1
+			});
+		});
+		test("reads namespaced config from global settings", () => {
+			setGlobalSettingsPath(writeTmpJson(fs.mkdtempSync(path.join(tmpdir, "pi-config-test-")), "settings.json", { "@bds_pi/test": { foo: "overridden" } }));
+			expect(getExtensionConfig("@bds_pi/test", {
+				foo: "default",
+				extra: true
+			})).toEqual({
+				foo: "overridden",
+				extra: true
+			});
+		});
+		test("deep merges nested objects", () => {
+			setGlobalSettingsPath(writeTmpJson(fs.mkdtempSync(path.join(tmpdir, "pi-config-test-")), "settings.json", { "@bds_pi/test": { nested: {
+				b: 2,
+				c: 3
+			} } }));
+			expect(getExtensionConfig("@bds_pi/test", { nested: {
+				a: 1,
+				b: 0
+			} })).toEqual({ nested: {
+				a: 1,
+				b: 2,
+				c: 3
+			} });
+		});
+		test("arrays replace rather than merge", () => {
+			setGlobalSettingsPath(writeTmpJson(fs.mkdtempSync(path.join(tmpdir, "pi-config-test-")), "settings.json", { "@bds_pi/test": { items: [3, 4] } }));
+			expect(getExtensionConfig("@bds_pi/test", { items: [1, 2] })).toEqual({ items: [3, 4] });
+		});
+		test("caches reads — second call does not re-read file", () => {
+			const settingsPath = writeTmpJson(fs.mkdtempSync(path.join(tmpdir, "pi-config-test-")), "settings.json", { "@bds_pi/test": { v: 1 } });
+			setGlobalSettingsPath(settingsPath);
+			getExtensionConfig("@bds_pi/test", { v: 0 });
+			fs.writeFileSync(settingsPath, JSON.stringify({ "@bds_pi/test": { v: 999 } }));
+			expect(getExtensionConfig("@bds_pi/test", { v: 0 })).toEqual({ v: 1 });
+		});
+		test("clearConfigCache resets cached reads", () => {
+			const settingsPath = writeTmpJson(fs.mkdtempSync(path.join(tmpdir, "pi-config-test-")), "settings.json", { "@bds_pi/test": { v: 1 } });
+			setGlobalSettingsPath(settingsPath);
+			getExtensionConfig("@bds_pi/test", { v: 0 });
+			fs.writeFileSync(settingsPath, JSON.stringify({ "@bds_pi/test": { v: 999 } }));
+			clearConfigCache();
+			expect(getExtensionConfig("@bds_pi/test", { v: 0 })).toEqual({ v: 999 });
+		});
+		test("handles malformed JSON gracefully", () => {
+			const dir = fs.mkdtempSync(path.join(tmpdir, "pi-config-test-"));
+			const settingsPath = path.join(dir, "settings.json");
+			fs.writeFileSync(settingsPath, "NOT VALID JSON {{{");
+			setGlobalSettingsPath(settingsPath);
+			expect(getExtensionConfig("@bds_pi/test", { ok: true })).toEqual({ ok: true });
+		});
+		test("returns defaults when namespace key is missing", () => {
+			setGlobalSettingsPath(writeTmpJson(fs.mkdtempSync(path.join(tmpdir, "pi-config-test-")), "settings.json", { "@bds_pi/other": { x: 1 } }));
+			expect(getExtensionConfig("@bds_pi/test", { y: 2 })).toEqual({ y: 2 });
+		});
+		test("project-local config merges on top of global", () => {
+			setGlobalSettingsPath(writeTmpJson(fs.mkdtempSync(path.join(tmpdir, "pi-config-global-")), "settings.json", { "@bds_pi/test": {
+				a: "global",
+				b: "global"
+			} }));
+			const projectDir = fs.mkdtempSync(path.join(tmpdir, "pi-config-project-"));
+			writeTmpJson(projectDir, ".pi/settings.json", { "@bds_pi/test": {
+				b: "project",
+				c: "project"
+			} });
+			expect(getExtensionConfig("@bds_pi/test", {
+				a: "default",
+				b: "default",
+				c: "default"
+			}, {
+				cwd: projectDir,
+				allowProjectConfig: true
+			})).toEqual({
+				a: "global",
+				b: "project",
+				c: "project"
+			});
+		});
+		test("project-local config is ignored when allowProjectConfig is false", () => {
+			setGlobalSettingsPath(writeTmpJson(fs.mkdtempSync(path.join(tmpdir, "pi-config-global-")), "settings.json", { "@bds_pi/test": { a: "global" } }));
+			const projectDir = fs.mkdtempSync(path.join(tmpdir, "pi-config-project-"));
+			writeTmpJson(projectDir, ".pi/settings.json", { "@bds_pi/test": { a: "project" } });
+			expect(getExtensionConfig("@bds_pi/test", { a: "default" }, { cwd: projectDir })).toEqual({ a: "global" });
+		});
+	});
+	describe("getGlobalConfig", () => {
+		test("returns undefined when no settings file exists", () => {
+			setGlobalSettingsPath(path.join(tmpdir, `nonexistent-${Date.now()}.json`));
+			expect(getGlobalConfig("missing")).toBeUndefined();
+		});
+		test("reads top-level key from global settings", () => {
+			setGlobalSettingsPath(writeTmpJson(fs.mkdtempSync(path.join(tmpdir, "pi-config-test-")), "settings.json", { promptVariables: { foo: { literal: "bar" } } }));
+			expect(getGlobalConfig("promptVariables")).toEqual({ foo: { literal: "bar" } });
+		});
+		test("returns undefined for missing key", () => {
+			setGlobalSettingsPath(writeTmpJson(fs.mkdtempSync(path.join(tmpdir, "pi-config-test-")), "settings.json", { other: 1 }));
+			expect(getGlobalConfig("promptVariables")).toBeUndefined();
+		});
+	});
+	describe("resolveConfigDir", () => {
+		test("returns dirname of global settings path", () => {
+			setGlobalSettingsPath("/fake/dir/settings.json");
+			expect(resolveConfigDir()).toBe("/fake/dir");
+		});
+	});
+}
+//#endregion
+export { clearConfigCache, getExtensionConfig, getGlobalConfig, resolveConfigDir, setGlobalSettingsPath };

package/dist/core/file-tracker.d.ts

@@ -0,0 +1,65 @@
+//#region packages/core/file-tracker/index.d.ts
+interface FileChange {
+  /** unique id for this change record */
+  id: string;
+  /** file:// URI of the changed file */
+  uri: string;
+  /** full content before the edit */
+  before: string;
+  /** full content after the edit */
+  after: string;
+  /** unified diff */
+  diff: string;
+  /** true if this was a newly created file */
+  isNewFile: boolean;
+  /** true if undo_edit has reverted this change */
+  reverted: boolean;
+  /** epoch ms when the edit occurred */
+  timestamp: number;
+}
+/**
+* record a file change to disk. call after performing the edit.
+* the toolCallId comes from the execute() function's first argument.
+* returns the change ID (UUID) for the written record.
+*
+* one tool call can produce multiple changes (e.g., Task sub-agent
+* creating several files). each gets a unique UUID, stored as
+* {toolCallId}.{uuid}.
+*/
+declare function saveChange(sessionId: string, toolCallId: string, change: Omit<FileChange, "id" | "reverted">): string;
+/**
+* load all change records for a tool call. one tool call can produce
+* multiple changes (different files), each with its own UUID.
+*/
+declare function loadChanges(sessionId: string, toolCallId: string): FileChange[];
+/**
+* mark a specific change as reverted and restore the file.
+* returns the change record, or null if not found / already reverted.
+*/
+declare function revertChange(sessionId: string, toolCallId: string, changeId: string): FileChange | null;
+/**
+* find the most recent non-reverted change for a file path,
+* filtered to only the given tool call IDs (branch awareness).
+*
+* the caller gets activeToolCallIds by scanning the current
+* session branch for edit_file/create_file tool calls.
+*/
+declare function findLatestChange(sessionId: string, filePath: string, activeToolCallIds: string[]): {
+  toolCallId: string;
+  change: FileChange;
+} | null;
+/**
+* generate a unified diff between two strings.
+*
+* uses the `diff` npm package (Myers algorithm) when available for
+* proper hunk-based output with context lines. context=3 matches
+* git's default, producing gaps between distant changes that show()
+* can elide in collapsed display.
+*
+* falls back to a naive line-by-line comparison when `diff` isn't
+* installed (produces correct but less optimal output — every line
+* is either +, -, or context with no hunk headers).
+*/
+declare function simpleDiff(filePath: string, before: string, after: string): string;
+//#endregion
+export { FileChange, findLatestChange, loadChanges, revertChange, saveChange, simpleDiff };