gentle-pi 2.6.3 → 2.7.0

package/tests/session-change-capture.test.ts

@@ -0,0 +1,68 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtemp, writeFile, rm, realpath } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { installSessionChangeCapture } from "../lib/session-change-capture.ts";
+import { SessionChanges, SESSION_CHANGE_ENTRY } from "../lib/session-changes.ts";
+
+async function fixture(run: (f: any) => Promise<void>, child = false) {
+	const root = await realpath(await mkdtemp(join(tmpdir(), "change-capture-")));
+	const handlers = new Map<string, Function>();
+	const entries: any[] = [];
+	const listeners = new Map<string, Function>();
+	const pi = { on: (key, fn) => handlers.set(key, fn), appendEntry: (customType, data) => entries.push({type:"custom",customType,data}),
+		events: { on: (key, fn) => { listeners.set(key, fn); return () => listeners.delete(key); }, emit: (key, data) => listeners.get(key)?.(data) } };
+	let id = "session";
+	const ctx = { cwd:root, sessionManager: { getSessionId: () => id, getEntries: () => entries } };
+	installSessionChangeCapture(pi as never, child ? {GENTLE_PI_AGENTS_CHILD:"1"} : {}, () => ({root,commonDir:root}));
+	const fire = (key, event = {}) => handlers.get(key)?.(event, ctx);
+	try { await fire("session_start"); await run({root, entries, ctx, fire, switchSession: () => id = "other"}); }
+	finally { await rm(root, {recursive:true,force:true}); }
+}
+
+test("capture reads no inventory at startup and ignores read-only tools", async () => fixture(async ({fire, entries}) => {
+	await fire("tool_call", {toolCallId:"r",toolName:"read",input:{path:"missing"}});
+	await fire("tool_result", {toolCallId:"r",toolName:"read",input:{path:"missing"},isError:false});
+	await fire("tool_execution_end", {toolCallId:"r",toolName:"read",isError:false});
+	assert.deepEqual(entries, []);
+}));
+
+test("successful writes capture only the exact tool target and persist for reload", async () => fixture(async ({root,fire,entries}) => {
+	await writeFile(join(root,"file"),"human baseline\n");
+	const event = {toolCallId:"w",toolName:"write",input:{path:"file",content:"agent output\n"}};
+	await fire("tool_call",event);
+	await writeFile(join(root,"file"),event.input.content);
+	await fire("tool_result",{...event,isError:false});
+	assert.equal(entries.length,0);
+	await fire("tool_execution_end",{toolCallId:"w",toolName:"write",isError:false});
+	assert.equal(entries[0].customType,SESSION_CHANGE_ENTRY);
+	await writeFile(join(root,"file"),"later human output\n");
+	const changes = new SessionChanges("session",entries);
+	assert.match(changes.loadDiff(root,changes.model.files[0]),/\+agent output/);
+	assert.doesNotMatch(changes.loadDiff(root,changes.model.files[0]),/later human/);
+}));
+
+test("failed and stale-session tool outcomes never add session changes", async () => fixture(async ({root,fire,entries,switchSession}) => {
+	const event={toolCallId:"w",toolName:"write",input:{path:"new",content:"agent\n"}};
+	await fire("tool_call",event);
+	await writeFile(join(root,"new"),event.input.content);
+	await fire("tool_result",{...event,isError:false});
+	await fire("tool_execution_end",{toolCallId:"w",toolName:"write",isError:true});
+	assert.equal(entries.length,0);
+	await fire("tool_call",{...event,toolCallId:"x"});
+	switchSession();
+	await fire("tool_result",{...event,toolCallId:"x",isError:false});
+	await fire("tool_execution_end",{toolCallId:"x",toolName:"write",isError:false});
+	assert.equal(entries.length,0);
+}));
+
+test("child carries bounded evidence in the existing tool-result details transport", async () => fixture(async ({root,fire,entries}) => {
+	const event={toolCallId:"w",toolName:"write",input:{path:"new",content:"agent\n"}};
+	await fire("tool_call",event); await writeFile(join(root,"new"),event.input.content);
+	const result=await fire("tool_result",{...event,isError:false,details:{original:"preserved"}});
+	assert.equal(result.details.original,"preserved");
+	assert.equal(result.details.gentleSessionChange.id,"w");
+	assert.equal(result.details.gentleSessionChange.path,"new");
+	assert.deepEqual(entries,[]);
+},true));

package/tests/session-changes-shell.test.ts

@@ -0,0 +1,38 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import shell from "../extensions/gentle-shell.ts";
+import { SESSION_CHANGE_ENTRY, SESSION_CHANGE_EVENT } from "../lib/session-changes.ts";
+
+function fixture(entries: any[] = []) {
+	const handlers = new Map<string, Function[]>(), listeners = new Map<string, Function[]>();
+	const commands = new Map<string, any>(), widgets = new Map<string, any>();
+	let gitCalls = 0;
+	const pi: any = { on: (key, fn) => handlers.set(key, [...(handlers.get(key) ?? []), fn]),
+		events: { on: (key, fn) => { listeners.set(key,[...(listeners.get(key) ?? []), fn]); return () => {}; }, emit: (key,data) => listeners.get(key)?.forEach(fn=>fn(data)) },
+		appendEntry: (customType,data) => entries.push({type:"custom",customType,data}), registerTool() {}, registerShortcut() {}, registerMessageRenderer() {},
+		registerCommand: (key, registration) => commands.set(key,registration) };
+	const notices: string[] = [];
+	const ctx: any = { hasUI:true, cwd:"/repo", sessionManager:{getSessionId:()=>"session",getEntries:()=>entries},
+		ui: { setFooter() {}, getEditorComponent:()=>({}), setWorkingVisible() {}, setWidget:(key,value)=>widgets.set(key,value), notify:(text)=>notices.push(text) } };
+	shell(pi,{}, {resolveWorktree:()=>({root:"/repo",commonDir:"/git"}),devBinary:()=>undefined,
+		gitRunner:()=>async()=>{gitCalls++; return await new Promise<any>(()=>{});} });
+	const fire=async(key,event={})=>{for(const fn of handlers.get(key)??[]) await fn(event,ctx);};
+	return {pi,ctx,entries,notices,commands,widgets,fire,gitCalls:()=>gitCalls};
+}
+test("Gentle Shell startup never waits for a repository scan",async()=>{
+	const f=fixture();
+	await Promise.race([f.fire("session_start"),new Promise((_,reject)=>setTimeout(()=>reject(new Error("startup blocked by Git inventory")),100))]);
+	assert.equal(f.gitCalls(),0);
+	await f.commands.get("gentle:changes").handler("",f.ctx);
+	assert.match(f.notices.join("\n"),/captured.*agent|agent.*changes/i);
+	await f.fire("session_shutdown");
+});
+test("reload and new evidence refresh Changes without Git or live file reads",async()=>{
+	const f=fixture([{type:"custom",customType:SESSION_CHANGE_ENTRY,data:{sessionId:"session",evidence:{id:"child:1",root:"/repo",path:"own.ts",before:{kind:"absent"},after:{kind:"text",text:"own\n"}}}}]);
+	await Promise.race([f.fire("session_start"),new Promise((_,reject)=>setTimeout(()=>reject(new Error("startup blocked")),100))]);
+	f.pi.events.emit(SESSION_CHANGE_EVENT,{sessionId:"session"});
+	await new Promise(resolve=>setImmediate(resolve));
+	assert.equal(f.gitCalls(),0);
+	assert.equal(typeof f.widgets.get("gentle-shell-changes"),"function");
+	await f.fire("session_shutdown");
+});

package/tests/session-changes.test.ts

@@ -0,0 +1,103 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { SessionChanges, readChangeSnapshot, SESSION_CHANGE_ENTRY, MAX_CHANGE_BYTES } from "../lib/session-changes.ts";
+
+const text = (text: string) => ({ kind: "text" as const, text });
+const absent = { kind: "absent" as const };
+const evidence = (id = "a", root = "/repo", path = "file.ts", before = text("old\n"), after = text("new\n")) => ({ id, root, path, before, after });
+
+test("session changes starts empty without reading the worktree or its untracked contents", async () => {
+	const changes = new SessionChanges("session");
+	assert.deepEqual(await changes.refresh(), { files: [], added: 0, deleted: 0 });
+	assert.deepEqual(changes.worktrees, []);
+});
+
+test("only attributed changes appear, against the pre-tool content rather than HEAD", () => {
+	const changes = new SessionChanges("session");
+	changes.record(evidence("a", "/repo", "file.ts", text("preexisting human edit\nold\n"), text("preexisting human edit\nnew\n")));
+	assert.equal(changes.model.files.length, 1);
+	assert.equal(changes.model.added, 1);
+	assert.equal(changes.model.deleted, 1);
+	assert.match(changes.loadDiff("/repo", changes.model.files[0]), /\+new/);
+	assert.doesNotMatch(changes.loadDiff("/repo", changes.model.files[0]), /\+preexisting/);
+});
+
+test("diff counts include content lines that resemble patch headers", () => {
+	const changes = new SessionChanges("session");
+	changes.record(evidence("headers", "/repo", "patch.txt", text("-- old content\n"), text("++ new content\n")));
+	assert.equal(changes.model.added, 1);
+	assert.equal(changes.model.deleted, 1);
+});
+
+test("contiguous own edits combine and own reverts remove the file and worktree", () => {
+	const changes = new SessionChanges("session");
+	changes.record(evidence());
+	changes.record(evidence("b", "/repo", "file.ts", text("new\n"), text("final\n")));
+	assert.equal(changes.model.added, 1);
+	assert.match(changes.loadDiff("/repo", changes.model.files[0]), /\+final/);
+	changes.record(evidence("c", "/repo", "file.ts", text("final\n"), text("old\n")));
+	assert.deepEqual(changes.worktrees, []);
+});
+
+test("external edits between agent operations are not folded into an attributed diff", () => {
+	const changes = new SessionChanges("session");
+	changes.record(evidence());
+	changes.record(evidence("b", "/repo", "file.ts", text("external\n"), text("agent again\n")));
+	const file = changes.model.files[0];
+	assert.match(file.countsUnavailable!, /external|continuity/i);
+	assert.doesNotMatch(changes.loadDiff("/repo", file), /\+external|\-external/);
+});
+
+test("new files and child worktrees are admitted only by positive mutation evidence", () => {
+	const changes = new SessionChanges("session");
+	changes.record({ ...evidence("child:1", "/linked", "new.ts"), before: absent });
+	assert.deepEqual(changes.worktrees.map(tree => tree.root), ["/linked"]);
+	assert.equal(changes.model.files[0].status, "added");
+});
+
+test("reload restores only the exact session and deduplicates operation identities", () => {
+	const row = { type: "custom", customType: SESSION_CHANGE_ENTRY, data: { sessionId: "session", evidence: evidence() } };
+	const changes = new SessionChanges("session", [row, row, { ...row, data: { sessionId: "other", evidence: evidence("b", "/other") } }]);
+	assert.equal(changes.model.files.length, 1);
+	changes.record(evidence());
+	assert.equal(changes.model.added, 1);
+});
+
+test("oversized, binary, nonregular and missing snapshots are bounded and explicit", async () => {
+	const dir = await mkdtemp(join(tmpdir(), "session-changes-"));
+	try {
+		await writeFile(join(dir, "large"), Buffer.alloc(MAX_CHANGE_BYTES + 1, 65));
+		await writeFile(join(dir, "binary"), Buffer.from([65, 0, 66]));
+		assert.equal((await readChangeSnapshot(join(dir, "large"))).kind, "unavailable");
+		assert.equal((await readChangeSnapshot(join(dir, "binary"))).kind, "unavailable");
+		assert.equal((await readChangeSnapshot(dir)).kind, "unavailable");
+		assert.deepEqual(await readChangeSnapshot(join(dir, "missing")), absent);
+	} finally { await rm(dir, { recursive: true, force: true }); }
+});
+
+test("bounded captures mark partial counts, including the narrow widget", async () => {
+	const { renderChangesWidget } = await import("../lib/shell-changes.ts");
+	const changes = new SessionChanges("session");
+	changes.record({ ...evidence("large", "/repo", "a-very-long-path-that-does-not-fit-in-the-widget.bin"), before: {kind:"unavailable",reason:"Binary file"}, after:{kind:"unavailable",reason:"Binary file"} });
+	assert.match(renderChangesWidget(changes.model,{fg:(_color,text)=>text},75).join("\n"),/partial counts/);
+});
+
+test("same-count edits change preview revisions and malformed evidence is rejected", () => {
+	const changes = new SessionChanges("session");
+	changes.record(evidence());
+	const first = changes.model.files[0].diffRevision;
+	changes.record(evidence("b","/repo","file.ts",text("new\n"),text("other\n")));
+	assert.notEqual(changes.model.files[0].diffRevision,first);
+	assert.equal(changes.record({...evidence("bad"),path:"../escape"}),false);
+	assert.equal(changes.record({...evidence("bad"),path:".git/config"}),false);
+});
+
+test("capture capacity is explicit instead of growing without limit", () => {
+	const changes = new SessionChanges("session");
+	for(let i=0;i<257;i++) changes.record(evidence(String(i),"/repo",String(i)+".ts"));
+	assert.equal(changes.model.files.length,256);
+	assert.match(changes.notice!,/limit reached/);
+});

package/tests/shell-bar.test.ts

@@ -7,6 +7,7 @@ import {
 	gaugeTone,
 	renderGauge,
 	renderShellBar,
+	renderShellSidebarBar,
 	shellEnabled,
 	type ShellBarModel,
 	type ShellBarTheme,
@@ -174,3 +175,16 @@ test("shellEnabled honors GENTLE_PI_SHELL=0", () => {
 	assert.equal(shellEnabled({ GENTLE_PI_SHELL: "0" }), false);
 	assert.equal(shellEnabled({ GENTLE_PI_SHELL: "false" }), false);
 });
+
+test("sidebar profile wraps long names without changing the compact bar", () => {
+	const profile = "team-" + "x".repeat(59);
+	const base = model();
+	const active = model({ profile });
+	for (const width of [24, 46]) {
+		const lines = renderShellSidebarBar(active, plainTheme, width);
+		assert.ok(lines.every((line) => visibleWidth(line) <= width));
+		assert.match(lines.join("\n"), /Profile/);
+		assert.ok(lines.join("").replace(/[│\s]/g, "").includes(profile));
+	}
+	assert.deepEqual(renderShellBar(active, plainTheme, 120), renderShellBar(base, plainTheme, 120));
+});