gentle-pi 4.1.0 → 4.2.0

package/tests/shell-changes.test.ts

@@ -159,6 +159,24 @@ test("ChangesTracker reads the working tree on start and again on refresh", asyn
 	assert.deepEqual(calls[1], ["status", "--porcelain=v1", "--untracked-files=all", "-z"]);
 });
 
+test("ChangesTracker skips untracked dependency backups but preserves tracked edits and legitimate new files", async () => {
+	const backup = "node_modules.backup-20261007-192802/pkg/index.js";
+	const nestedBackup = "packages/app/node_modules.backup-local/pkg/index.js";
+	const tracked = "node_modules.backup-local/tracked.ts";
+	const legitimate = ["src/new.ts", "node_modules.backup-notes.md", "node_modules.backup-/new.ts"];
+	const { git } = fakeGit(
+		[`4\t2\t${tracked}\n`],
+		[[`?? ${backup}`, `?? ${nestedBackup}`, ` M ${tracked}`, ...legitimate.map((path) => `?? ${path}`)].join("\0") + "\0"],
+	);
+	const counted: string[] = [];
+	const tracker = new ChangesTracker(git, async (path) => { counted.push(path); return 3; });
+	await tracker.start();
+	assert.deepEqual(counted.sort(), [...legitimate].sort());
+	assert.deepEqual(tracker.model, changesModel([
+		file(tracked, 4, 2), ...legitimate.map((path) => file(path, 3, 0, CHANGE_STATUS.UNTRACKED)),
+	]));
+});
+
 test("ChangesTracker stays quiet outside a git repository", async () => {
 	const { git, calls } = fakeGit([""], [""], 128);
 	const tracker = new ChangesTracker(git);

package/tests/shell-todo.test.ts

@@ -9,6 +9,7 @@ import {
 	staleTurns,
 	TODO_STATUS,
 	todoPromptBlock,
+	todoStateMessage,
 	todoSummary,
 	type TodoState,
 } from "../lib/shell-todo.ts";
@@ -152,19 +153,21 @@ test("replayTodo rebuilds the latest state from Gentle and rpiv tool results ali
 	assert.deepEqual(replayTodo([]), emptyTodo());
 });
 
-test("todoPromptBlock lists open work with the rules, and stays silent when there is nothing open", () => {
-	const block = todoPromptBlock(seeded(), 0);
-	assert.ok(block);
+test("todoPromptBlock is the byte-stable rules block; todoStateMessage carries the open work (#1662)", () => {
+	const block = todoPromptBlock();
 	assert.match(block, /^## Todo list/m);
 	assert.match(block, /mark a task in_progress before starting/);
-	assert.match(block, /1\. \[done\] Add quiet tool rendering/);
-	assert.match(block, /2\. \[in_progress\] Fix quiet tools conflict — fixing conflict/);
-	assert.match(block, /3\. \[pending\] Show git bash tails/);
 	assert.doesNotMatch(block, /stale/);
-	assert.match(todoPromptBlock(seeded(), 2) ?? "", /stale: 2 turns without an update/);
-	assert.equal(todoPromptBlock(emptyTodo(), 0), undefined);
+	assert.doesNotMatch(block, /Add quiet tool rendering/, "the rules block never contains task content");
+	const message = todoStateMessage(seeded());
+	assert.ok(message);
+	assert.match(message, /1\. \[done\] Add quiet tool rendering/);
+	assert.match(message, /2\. \[in_progress\] Fix quiet tools conflict — fixing conflict/);
+	assert.match(message, /3\. \[pending\] Show git bash tails/);
+	assert.doesNotMatch(message, /stale/);
+	assert.equal(todoStateMessage(emptyTodo()), undefined);
 	const allDone = applyTodo(seeded(), { action: "write", tasks: [{ title: "A", status: "done" }] }, 1).state;
-	assert.equal(todoPromptBlock(allDone, 0), undefined);
+	assert.equal(todoStateMessage(allDone), undefined);
 });
 
 test("collapsed long tasks occupy one body line, including stale state, without losing task data", (t) => {
@@ -446,7 +449,7 @@ test("applyTodo rejects blocked without a note and leaves the list unchanged", (
 test("dropped tasks never count as open: a list of done and dropped is finished, silent, and never stale", () => {
 	const state = applyTodo(emptyTodo(), { action: "write", tasks: [{ title: "A", status: "done" }, { title: "B", status: "dropped" }, { title: "C", status: "dropped" }] }, 1).state;
 	assert.deepEqual(todoSummary(state), { done: 1, total: 3, open: 0 });
-	assert.equal(todoPromptBlock(state, 5), undefined);
+	assert.equal(todoStateMessage(state), undefined);
 	assert.equal(staleTurns(state, 9), 0);
 });
 
@@ -454,8 +457,8 @@ test("blocked tasks stay open but alone never make the list stale; an actionable
 	const blockedOnly = applyTodo(emptyTodo(), { action: "write", tasks: [{ title: "A", status: "done" }, { title: "Deploy", status: "blocked", note: "waiting for an admin" }] }, 1).state;
 	assert.deepEqual(todoSummary(blockedOnly), { done: 1, total: 2, open: 1 });
 	assert.equal(staleTurns(blockedOnly, 9), 0);
-	const block = todoPromptBlock(blockedOnly, 0) ?? "";
-	assert.match(block, /2\. \[blocked\] Deploy — waiting for an admin/);
+	assert.match(todoStateMessage(blockedOnly) ?? "", /2\. \[blocked\] Deploy — waiting for an admin/);
+	const block = todoPromptBlock();
 	assert.match(block, /A blocked task waits on something outside the list: do not work on it until its condition holds/);
 	assert.match(block, /mark the tasks it made obsolete dropped instead of leaving them pending or marking them done/);
 	const mixed = applyTodo(blockedOnly, { action: "add", title: "Write docs" }, 1).state;

package/tests/vim-editor-adapter.test.ts

@@ -5,12 +5,17 @@ import { tmpdir } from "node:os";
 import { createRequire } from "node:module";
 import { fileURLToPath, pathToFileURL } from "node:url";
 import { dirname, resolve } from "node:path";
-import { CURSOR_MARKER, Editor, visibleWidth } from "@earendil-works/pi-tui";
+import { CURSOR_MARKER, Editor, TuiMainScreen, visibleWidth } from "@earendil-works/pi-tui";
 import { AUDITED_PI_EDITOR_VERSIONS, createVimEditorAdapter, isAuditedPiEditorVersion } from "../lib/vim-editor-adapter.ts";
 import { resolveVimRuntime, VIM_AGENT_INDEX_PATTERN, VIM_CLI_ENTRY_PATTERN } from "../extensions/gentle-shell.ts";
 import { VimOperatorEngine } from "../lib/vim-operator-engine.ts";
 import { VimVisualEngine } from "../lib/vim-visual-engine.ts";
 
+function resolveFakeCursors(rows: string[], hardware = false): string[] {
+  const host = TuiMainScreen.prototype as unknown as { resolveFakeCursors(rows: string[]): string[] };
+  return host.resolveFakeCursors.call({ showHardwareCursor: hardware }, rows);
+}
+
 function editor(): Editor {
   return new Editor({ terminal: { rows: 24 }, requestRender() {} } as never, { borderColor: (s: string) => s } as never);
 }
@@ -20,6 +25,8 @@ function editor(): Editor {
 function paintedCells(row: string): Array<{ char: string; inverse: boolean }> {
   const cells: Array<{ char: string; inverse: boolean }> = [];
   let inverse = false;
+  // Decode the actual host post-pass, including hardware cursor suppression.
+  row = resolveFakeCursors([row])[0]!;
   const tokens = row.match(/\x1b\[[0-9;]*m|\x1b_pi:c\x07|[^\x1b]/g) ?? [];
   assert.equal(tokens.join(""), row, "only known editor escape sequences are present");
   for (const token of tokens) {
@@ -270,12 +277,12 @@ test("resolveVimRuntime resolves local bundle cli entrypoint when provided", ()
 });
 
 test("audited Pi editor releases are one frozen exact allowlist that includes the installed TUI", () => {
-  assert.deepEqual([...AUDITED_PI_EDITOR_VERSIONS], ["0.99.1", "0.99.2", "1.0.0", "1.1.0"]);
+  assert.deepEqual([...AUDITED_PI_EDITOR_VERSIONS], ["0.99.1", "0.99.2", "1.0.0", "1.1.0", "1.2.0"]);
   assert.equal(bundledAgent.VERSION, INSTALLED_PI, "bundled and local metadata must describe the same actual installed release");
   assert.ok(Object.isFrozen(AUDITED_PI_EDITOR_VERSIONS));
   assert.throws(() => (AUDITED_PI_EDITOR_VERSIONS as unknown as string[]).push("0.99.3"), TypeError);
   assert.ok(isAuditedPiEditorVersion(INSTALLED_PI), `installed pi-tui ${INSTALLED_PI} must be audited`);
-  for (const unknown of ["0.99.3", "0.99.10", "0.99", "v0.99.2", " 0.99.2", "0.99.2-rc.1", ">=0.99.2", "1.0.1", ">=1.0.0", "v1.0.0", " 1.0.0", "1.0.0-rc.1", undefined, 99.2]) {
+  for (const unknown of ["0.99.3", "0.99.10", "0.99", "v0.99.2", " 0.99.2", "0.99.2-rc.1", ">=0.99.2", "1.0.1", ">=1.0.0", "v1.0.0", " 1.0.0", "1.0.0-rc.1", "1.2.1", "1.2.0-rc.1", "v1.2.0", ">=1.2.0", undefined, 99.2]) {
     assert.equal(isAuditedPiEditorVersion(unknown), false, String(unknown));
   }
 });
@@ -309,6 +316,8 @@ test("bundled host admits each audited release and rejects unknown or mismatched
     assert.equal(resolveVimRuntime(fabricatedPiCli(t, version), bundledAgent.CustomEditor), undefined, version);
   }
   assert.equal(resolveVimRuntime(fabricatedPiCli(t, "1.0.0", "1.0.0", "0.99.2"), bundledAgent.CustomEditor), undefined);
+  assert.equal(resolveVimRuntime(fabricatedPiCli(t, "1.2.1"), bundledAgent.CustomEditor), undefined);
+  assert.equal(resolveVimRuntime(fabricatedPiCli(t, "1.2.0", "1.2.0", "1.1.0"), bundledAgent.CustomEditor), undefined);
 });
 
 test("installed agent/TUI pair admits each audited release and skips unknown or mismatched pairs", (t) => {
@@ -343,6 +352,8 @@ test("adapter admits each verified audited release and rejects unknown or mismat
     assert.throws(() => createVimEditorAdapter(editor(), version), /unsupported/i, version);
   }
   assert.throws(() => createVimEditorAdapter(e, "1.0.0", BundledEditor, "0.99.2"), /unsupported/i);
+  assert.throws(() => createVimEditorAdapter(e, "1.2.1", BundledEditor, "1.2.1"), /unsupported/i);
+  assert.throws(() => createVimEditorAdapter(e, "1.2.0", BundledEditor, "1.1.0"), /unsupported/i);
   assert.equal(e.getText(), "untouched");
   assert.deepEqual(e.getCursor(), cursor);
   assert.deepEqual(e.render(30), frame);
@@ -638,24 +649,39 @@ test("operator insertion and registered marker guards keep one undo snapshot", (
   assert.equal(paste.getExpandedText(), "z".repeat(1001));
 });
 
+test("Pi 1.2 selection preserves fake markers and host hardware-cursor suppression", () => {
+  const e = editor();
+  e.setText("abcd");
+  e.focused = true;
+  const adapter = createVimEditorAdapter(e, INSTALLED_PI);
+  adapter.move({ line: 0, col: 1 });
+  const rows = adapter.renderSelection(20, { line: 0, col: 0 }, { line: 0, col: 4 });
+  assert.ok(rows[1]!.includes(`${CURSOR_MARKER}\x1b_pi:fc\x07`));
+  assert.ok(rows[1]!.includes("\x1b_pi:/fc\x07"));
+  for (const hardware of [false, true]) {
+    const resolved = resolveFakeCursors(rows, hardware);
+    assert.deepEqual(paintedCells(resolved[1]!).slice(0, 4), "abcd".split("").map(char => ({ char, inverse: true })));
+    assert.ok(resolved.every(row => visibleWidth(row) === 20));
+  }
+  const boundary = adapter.renderSelection(20, { line: 0, col: 0 }, { line: 0, col: 1 });
+  assert.ok(boundary[1]!.includes(`${CURSOR_MARKER}\x1b_pi:fc\x07`));
+  assert.deepEqual(selectedColumns(resolveFakeCursors(boundary, true)[1]!), [0]);
+  assert.deepEqual(selectedColumns(resolveFakeCursors(boundary, false)[1]!), [0, 1]);
+  const legacy = e.render(20);
+  legacy[1] = legacy[1]!.replaceAll("\x1b_pi:fc\x07", "\x1b[7m").replaceAll("\x1b_pi:/fc\x07", "\x1b[0m");
+  assert.deepEqual(selectedColumns(adapter.renderSelection(20, { line: 0, col: 0 }, { line: 0, col: 4 }, legacy)[1]!), [0, 1, 2, 3]);
+  const unknown = e.render(20).map(row => row.replace("\x1b_pi:fc\x07", "\x1b_pi:unknown\x07"));
+  assert.deepEqual(adapter.renderSelection(20, { line: 0, col: 0 }, { line: 0, col: 4 }, unknown), unknown);
+});
+
 test("selection survives fake cursor reset and retains surrounding color", () => {
   const e = editor();
   e.setText("abcd");
   createVimEditorAdapter(e, INSTALLED_PI).move({ line: 0, col: 1 });
   const frame = createVimEditorAdapter(e, INSTALLED_PI).renderSelection(20, { line: 0, col: 0 }, { line: 0, col: 4 });
   const row = frame.find((line) => line.includes("a")) ?? frame.join("");
-  let reverse = false;
-  const selected: string[] = [];
-  for (const token of row.matchAll(/\x1b\[[0-9;]*m|[^\x1b]/g)) {
-    const value = token[0];
-    if (value.startsWith("\x1b[")) {
-      for (const code of value.slice(2, -1).split(";").map(Number)) {
-        if (code === 0 || code === 27) reverse = false;
-        if (code === 7) reverse = true;
-      }
-    } else if ("abcd".includes(value)) selected.push(reverse ? value : `!${value}`);
-  }
-  assert.deepEqual(selected, ["a", "b", "c", "d"], "every visible cell must have effective reverse SGR");
+  assert.deepEqual(paintedCells(row).slice(0, 4), "abcd".split("").map(char => ({ char, inverse: true })),
+    "every visible cell must have effective reverse SGR after the host post-pass");
 });
 
 test("truecolor channels do not change inverse state across selected and unselected cells", () => {

package/tests/yolo-mode.test.ts

@@ -192,7 +192,12 @@ test("active YOLO waives only ordinary push after full destructive/guard evaluat
 	await h.command("enable");
 	assert.equal(await call("git push origin main"), undefined);
 	assert.equal(h.confirmations(), 1);
-	for (const command of ["git push origin main && rm -rf ./data", `sh -c "psql -c 'DROP TABLE users'"`, "git push origin main && git rebase main", "git push --force origin main", "git push origin main && npm publish", "git -C /other push origin main", "sh -c 'git push origin main'"]) {
+	// gentle-shell#2172: reversible compound delivery is waived too.
+	for (const command of ["git commit -m 'fix: x' && git push -u origin feature/x", "git push origin main && gh pr create --fill", "git -C /other push origin main", "git rebase origin/main && git push"]) {
+		assert.equal(await call(command), undefined, command);
+	}
+	assert.equal(h.confirmations(), 1, "waived commands never reach the confirmation dialog");
+	for (const command of ["git push origin main && rm -rf ./data", `sh -c "psql -c 'DROP TABLE users'"`, "git push origin main && git rebase -i main", "git push --force origin main", "git push origin main && npm publish", "git push origin :main", "sh -c 'git push origin main'"]) {
 		assert.ok(await call(command), command);
 	}
 	await h.command("disable"); assert.ok(await call("git push origin main"));