@bugabinga/pi-ext-llmiterate 0.1.0

package/__tests__/lock.test.ts

@@ -0,0 +1,80 @@
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { hostname, tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
+import { acquireLock, findProjectRoot, realPath, releaseLock, type LockHandle } from "../lock";
+
+const tempDirs: string[] = [];
+
+afterEach(() => {
+  while (tempDirs.length) rmSync(tempDirs.pop()!, { recursive: true, force: true });
+});
+
+function tempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "llmiterate-lock-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+describe("llmiterate lock/project root", () => {
+  test("finds nearest project boundary", () => {
+    const root = tempDir();
+    mkdirSync(join(root, ".git"));
+    const nested = join(root, "a", "b");
+    mkdirSync(nested, { recursive: true });
+
+    expect(findProjectRoot(nested)).toBe(realPath(root));
+
+    const sub = join(root, "a");
+    writeFileSync(join(sub, "AGENTS.md"), "# subproject\n");
+    expect(findProjectRoot(nested)).toBe(realPath(sub));
+  });
+
+  test("acquires, blocks duplicate, and releases lock", () => {
+    const root = tempDir();
+    const storeDir = tempDir();
+    const lock = expectLock(acquireLock(storeDir));
+
+    const duplicate = acquireLock(storeDir);
+    expect(duplicate).toContain("singleton lock held by");
+    expect(lock.dir).toBe(join(storeDir, "lock"));
+    expect(existsSync(join(root, ".pi"))).toBe(false);
+
+    releaseLock(lock);
+    const reacquired = expectLock(acquireLock(storeDir));
+    releaseLock(reacquired);
+  });
+
+  test("does not release lock owned by different token", () => {
+    const storeDir = tempDir();
+    const lock = expectLock(acquireLock(storeDir));
+    releaseLock({ dir: lock.dir, token: "wrong" });
+    expect(acquireLock(storeDir)).toContain("singleton lock held by");
+    releaseLock(lock);
+  });
+
+  test("recovers stale lock in global store", () => {
+    const storeDir = tempDir();
+    mkdirSync(join(storeDir, "lock"));
+    writeFileSync(join(storeDir, "lock", "owner.json"), JSON.stringify({ pid: 99_999_999, hostname: hostname(), token: "stale" }));
+
+    const lock = expectLock(acquireLock(storeDir));
+    expect(lock.dir).toBe(join(storeDir, "lock"));
+    releaseLock(lock);
+  });
+
+  test("malformed owner does not trigger recovery", () => {
+    const storeDir = tempDir();
+    mkdirSync(join(storeDir, "lock"));
+    writeFileSync(join(storeDir, "lock", "owner.json"), JSON.stringify({ pid: 99_999_999, hostname: hostname(), token: "old", extra: 1 }));
+
+    expect(acquireLock(storeDir)).toContain("singleton lock held by another pi");
+    expect(existsSync(join(storeDir, "lock", "owner.json"))).toBe(true);
+  });
+});
+
+function expectLock(value: LockHandle | string): LockHandle {
+  expect(typeof value).toBe("object");
+  if (typeof value === "string") throw new Error(value);
+  return value;
+}

package/__tests__/rpc.test.ts

@@ -0,0 +1,124 @@
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
+import { PiRpcWorker } from "../rpc";
+import type { RpcEvent } from "../types";
+
+const tempDirs: string[] = [];
+const workers: PiRpcWorker[] = [];
+
+afterEach(() => {
+  while (workers.length) workers.pop()!.dispose();
+  while (tempDirs.length) rmSync(tempDirs.pop()!, { recursive: true, force: true });
+});
+
+function tempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "llmiterate-rpc-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+describe("PiRpcWorker integration", () => {
+  test("runs prompt through JSON-RPC worker and forwards events", async () => {
+    const root = tempDir();
+    const fake = writeFakeRpc(root, "ok");
+    const events: RpcEvent[] = [];
+    const worker = new PiRpcWorker({
+      cwd: root,
+      sessionDir: join(root, "sessions"),
+      invocation: { command: process.execPath, args: [fake] },
+      onEvent: (event) => events.push(event),
+    });
+    workers.push(worker);
+
+    await worker.runPrompt("do thing", "job name");
+
+    expect(events.map((e) => e.type)).toEqual(["message_update", "tool_execution_start", "tool_execution_end", "agent_end"]);
+    const first = events[0];
+    expect(first.type).toBe("message_update");
+    if (first.type === "message_update") {
+      const content = first.message?.content;
+      expect(Array.isArray(content) ? content[0]?.text : undefined).toBe("streaming");
+    }
+  });
+
+  test("rejects concurrent prompts instead of corrupting current prompt", async () => {
+    const root = tempDir();
+    const fake = writeFakeRpc(root, "ok");
+    const worker = new PiRpcWorker({
+      cwd: root,
+      sessionDir: join(root, "sessions"),
+      invocation: { command: process.execPath, args: [fake] },
+      onEvent: () => {},
+    });
+    workers.push(worker);
+
+    const first = worker.runPrompt("first", "first job");
+    await expect(worker.runPrompt("second", "second job")).rejects.toThrow("already has an active prompt");
+    await first;
+  });
+
+  test("rejects failed RPC command", async () => {
+    const root = tempDir();
+    const fake = writeFakeRpc(root, "fail-new-session");
+    const worker = new PiRpcWorker({
+      cwd: root,
+      sessionDir: join(root, "sessions"),
+      invocation: { command: process.execPath, args: [fake] },
+      onEvent: () => {},
+    });
+    workers.push(worker);
+
+    await expect(worker.runPrompt("do thing", "job name")).rejects.toThrow("new_session denied");
+  });
+
+  test("rejects malformed RPC stdout", async () => {
+    const root = tempDir();
+    const fake = writeFakeRpc(root, "malformed");
+    const worker = new PiRpcWorker({
+      cwd: root,
+      sessionDir: join(root, "sessions"),
+      invocation: { command: process.execPath, args: [fake] },
+      onEvent: () => {},
+    });
+    workers.push(worker);
+
+    await expect(worker.runPrompt("do thing", "job name")).rejects.toThrow();
+  });
+});
+
+function writeFakeRpc(root: string, mode: "ok" | "fail-new-session" | "malformed"): string {
+  const file = join(root, "fake-rpc.js");
+  writeFileSync(file, `
+process.stdin.setEncoding('utf8');
+let buffer = '';
+process.stdin.on('data', chunk => {
+  buffer += chunk;
+  const lines = buffer.split('\\n');
+  buffer = lines.pop() || '';
+  for (const line of lines) handle(line);
+});
+function send(value) { process.stdout.write(JSON.stringify(value) + '\\n'); }
+function handle(line) {
+  if (!line.trim()) return;
+  const msg = JSON.parse(line);
+  if (${JSON.stringify(mode)} === 'fail-new-session' && msg.type === 'new_session') {
+    send({ id: msg.id, type: 'response', command: msg.type, success: false, error: 'new_session denied' });
+    return;
+  }
+  send({ id: msg.id, type: 'response', command: msg.type, success: true });
+  if (${JSON.stringify(mode)} === 'malformed' && msg.type === 'prompt') {
+    process.stdout.write('not json\\n');
+    return;
+  }
+  if (msg.type === 'prompt') {
+    send({ type: 'message_update', message: { role: 'assistant', content: [{ type: 'text', text: 'streaming' }] } });
+    send({ type: 'tool_execution_start', toolName: 'edit' });
+    send({ type: 'tool_execution_end', toolName: 'edit', isError: false, result: { content: [{ type: 'text', text: 'ok' }] } });
+    send({ type: 'agent_end' });
+  }
+}
+`, "utf-8");
+  return file;
+}

package/__tests__/ui.test.ts

@@ -0,0 +1,80 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { describe, expect, test } from "bun:test";
+import { defaultConfig, parseMarkerPrompts } from "../core";
+import { LlmiterateWidget, renderLlmiterateUi } from "../ui";
+import type { LlmiterateRun } from "../types";
+
+interface UiCall {
+  key: string;
+  value: string | undefined;
+}
+
+const theme = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+} as unknown as ExtensionContext["ui"]["theme"];
+
+describe("llmiterate UI", () => {
+  test("status line states", () => {
+    const calls: UiCall[] = [];
+    const ctx = fakeContext({ setStatus: (key, value) => calls.push({ key, value }) });
+
+    renderLlmiterateUi(ctx, false, [], { config: defaultConfig(), watchErrors: 0, queuedRuns: 0 });
+    renderLlmiterateUi(ctx, false, [], { config: defaultConfig(), lockError: "held", watchErrors: 0, queuedRuns: 0 });
+    renderLlmiterateUi(ctx, false, [], { config: defaultConfig(), watchErrors: 2, queuedRuns: 0 });
+    renderLlmiterateUi(ctx, false, [], { config: defaultConfig(), watchErrors: 0, queuedRuns: 3 });
+
+    expect(calls.map((c) => c.value)).toEqual([
+      "llmiterate idle",
+      "llmiterate standby",
+      "llmiterate 2 watch error(s)",
+      "llmiterate queued 3",
+    ]);
+  });
+
+  test("clears widget when hidden", () => {
+    let widgetValue: unknown = "not cleared";
+    const ctx = fakeContext({ setWidget: (_key, value) => { widgetValue = value; } });
+
+    renderLlmiterateUi(ctx, false, [], { config: defaultConfig(), watchErrors: 0, queuedRuns: 0 });
+    expect(widgetValue).toBeUndefined();
+  });
+
+  test("widget empty snapshot", () => {
+    expect(new LlmiterateWidget([], theme).render(60).join("\n")).toMatchSnapshot();
+  });
+
+  test("widget run snapshot", () => {
+    expect(new LlmiterateWidget([sampleRun()], theme).render(80).join("\n")).toMatchSnapshot();
+  });
+});
+
+function fakeContext(overrides: {
+  setStatus?: (key: string, value: string | undefined) => void;
+  setWidget?: (key: string, value: unknown) => void;
+}): ExtensionContext {
+  return {
+    hasUI: true,
+    ui: {
+      theme,
+      setStatus: overrides.setStatus ?? (() => {}),
+      setWidget: overrides.setWidget ?? (() => {}),
+    },
+  } as unknown as ExtensionContext;
+}
+
+function sampleRun(): LlmiterateRun {
+  const [block] = parseMarkerPrompts("src/main.ts", "LLM implement foo and bar");
+  return {
+    id: 1,
+    block: block!,
+    projectFile: "src/main.ts",
+    absoluteFile: "/tmp/project/src/main.ts",
+    fullPrompt: "prompt",
+    status: "running",
+    queuedAt: 1,
+    updatedAt: 2,
+    assistantText: "I am editing the file now and will run tests afterwards.",
+    toolText: "running edit",
+  };
+}

package/__tests__/watcher.test.ts

@@ -0,0 +1,133 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, describe, expect, test } from "bun:test";
+import { compilePathFilter, normalizeConfig } from "../core";
+import { ProjectWatcher } from "../watcher";
+
+const tempDirs: string[] = [];
+const watchers: ProjectWatcher[] = [];
+
+afterEach(() => {
+  while (watchers.length) watchers.pop()!.stop();
+  while (tempDirs.length) rmSync(tempDirs.pop()!, { recursive: true, force: true });
+});
+
+function tempDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "llmiterate-watcher-"));
+  tempDirs.push(dir);
+  return dir;
+}
+
+describe("ProjectWatcher integration", () => {
+  test("default config scans nothing", () => {
+    const root = tempDir();
+    mkdirSync(join(root, "src"));
+    writeFileSync(join(root, "src", "a.ts"), "LLM ignored");
+
+    const config = normalizeConfig({ debounceMs: 10 });
+    const seen: string[] = [];
+    const watcher = new ProjectWatcher(root, config, compilePathFilter(config), (file) => seen.push(file), () => {});
+    watchers.push(watcher);
+
+    expect(watcher.scanAll((file) => { seen.push(file); return 1; })).toBe(0);
+    expect(seen).toEqual([]);
+  });
+
+  test("default config starts no filesystem watchers", async () => {
+    const root = tempDir();
+    mkdirSync(join(root, "src"));
+
+    const config = normalizeConfig({ debounceMs: 10 });
+    const seen: string[] = [];
+    const watcher = new ProjectWatcher(root, config, compilePathFilter(config), (file) => seen.push(file), () => {});
+    watchers.push(watcher);
+
+    watcher.start();
+    writeFileSync(join(root, "src", "a.ts"), "LLM ignored");
+    await sleep(40);
+    expect(watcher.errorCount).toBe(0);
+    expect(seen).toEqual([]);
+  });
+
+  test("scanAll respects include whitelist and aggregates callback results", () => {
+    const root = tempDir();
+    mkdirSync(join(root, "src"));
+    mkdirSync(join(root, "research"));
+    writeFileSync(join(root, "src", "a.ts"), "LLM do it");
+    writeFileSync(join(root, "src", "a.png"), "no");
+    writeFileSync(join(root, "research", "b.ts"), "LLM ignore");
+
+    const config = normalizeConfig({ include: ["src/**/*.ts"], exclude: [], debounceMs: 10 });
+    const seen: string[] = [];
+    const watcher = new ProjectWatcher(root, config, compilePathFilter(config), (file) => seen.push(file), () => {});
+    watchers.push(watcher);
+
+    const total = watcher.scanAll((file) => {
+      seen.push(file);
+      return 2;
+    });
+
+    expect(total).toBe(2);
+    expect(seen.map((p) => p.replace(root, ""))).toEqual(["/src/a.ts"]);
+  });
+
+  test("watcher emits debounced file save events", async () => {
+    const root = tempDir();
+    mkdirSync(join(root, "src"));
+    const config = normalizeConfig({ include: ["**/*.ts"], exclude: [], debounceMs: 20 });
+    const seen: string[] = [];
+    const watcher = new ProjectWatcher(root, config, compilePathFilter(config), (file) => seen.push(file), () => {});
+    watchers.push(watcher);
+
+    watcher.start();
+    await sleep(20);
+    writeFileSync(join(root, "src", "new.ts"), "LLM hello");
+    await eventually(() => seen.some((p) => p.endsWith("new.ts")));
+  });
+
+  test("watcher ignores new files outside include whitelist", async () => {
+    const root = tempDir();
+    mkdirSync(join(root, "src"));
+    mkdirSync(join(root, "research"));
+    const config = normalizeConfig({ include: ["src/**/*.ts"], exclude: [], debounceMs: 20 });
+    const seen: string[] = [];
+    const watcher = new ProjectWatcher(root, config, compilePathFilter(config), (file) => seen.push(file), () => {});
+    watchers.push(watcher);
+
+    watcher.start();
+    await sleep(20);
+    writeFileSync(join(root, "research", "ignored.ts"), "LLM nope");
+    await sleep(80);
+    expect(seen).toEqual([]);
+    writeFileSync(join(root, "src", "seen.ts"), "LLM hello");
+    await eventually(() => seen.some((p) => p.endsWith("seen.ts")));
+  });
+
+  test("watcher notices files moved into new whitelisted directories", async () => {
+    const root = tempDir();
+    const config = normalizeConfig({ include: ["nested/**/*.ts"], exclude: [], debounceMs: 20 });
+    const seen: string[] = [];
+    const watcher = new ProjectWatcher(root, config, compilePathFilter(config), (file) => seen.push(file), () => {});
+    watchers.push(watcher);
+
+    watcher.start();
+    mkdirSync(join(root, "nested"));
+    await sleep(60);
+    writeFileSync(join(root, "nested", "moved.ts"), "LLM hello");
+    await eventually(() => seen.some((p) => p.endsWith("moved.ts")));
+  });
+});
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function eventually(predicate: () => boolean): Promise<void> {
+  const deadline = Date.now() + 1500;
+  while (Date.now() < deadline) {
+    if (predicate()) return;
+    await sleep(25);
+  }
+  expect(predicate()).toBe(true);
+}