pi-jar 0.1.0

package/src/changes.ts

@@ -0,0 +1,146 @@
+import { existsSync, lstatSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { isAbsolute, relative, resolve } from "node:path";
+
+/** Files larger than this, or binary files, are not tracked for review. */
+export const MAX_TRACKED_BYTES = 1024 * 1024;
+export const MAX_TRACKED_FILES = 200;
+/** Above this many (old × new) changed lines the inline diff is replaced by a summary. */
+const MAX_DIFF_CELLS = 4_000_000;
+
+export type ChangeStatus = "added" | "modified" | "deleted";
+export interface FileChange { path: string; rel: string; status: ChangeStatus; before: string; after: string; added: number; removed: number }
+export type DiffOp = { op: " " | "+" | "-"; text: string };
+export type DiffRow = { kind: "hunk" | "context" | "add" | "remove" | "note"; text: string; oldLine?: number; newLine?: number };
+
+/** Text content, `null` when the file is missing, or `undefined` when it cannot be tracked. */
+function readText(path: string): string | null | undefined {
+  if (!existsSync(path)) return null;
+  const info = lstatSync(path);
+  if (!info.isFile() || info.size > MAX_TRACKED_BYTES) return undefined;
+  const buffer = readFileSync(path);
+  if (buffer.subarray(0, 8000).includes(0)) return undefined;
+  return buffer.toString("utf8");
+}
+
+const splitLines = (text: string) => text === "" ? [] : text.replace(/\r\n/g, "\n").replace(/\n$/, "").split("\n");
+
+/** Line diff: trims the common prefix/suffix, then an LCS over the changed middle. */
+export function lineDiff(before: string, after: string): DiffOp[] | undefined {
+  const a = splitLines(before), b = splitLines(after);
+  let start = 0;
+  while (start < a.length && start < b.length && a[start] === b[start]) start++;
+  let endA = a.length, endB = b.length;
+  while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) { endA--; endB--; }
+  const midA = a.slice(start, endA), midB = b.slice(start, endB);
+  if (midA.length * midB.length > MAX_DIFF_CELLS) return undefined;
+  const n = midA.length, m = midB.length;
+  // lcs[i][j] = LCS length of midA[i..] and midB[j..], flattened.
+  const lcs = new Uint32Array((n + 1) * (m + 1));
+  for (let i = n - 1; i >= 0; i--) for (let j = m - 1; j >= 0; j--) {
+    lcs[i * (m + 1) + j] = midA[i] === midB[j] ? lcs[(i + 1) * (m + 1) + j + 1]! + 1
+      : Math.max(lcs[(i + 1) * (m + 1) + j]!, lcs[i * (m + 1) + j + 1]!);
+  }
+  const ops: DiffOp[] = a.slice(0, start).map((text) => ({ op: " ", text }));
+  let i = 0, j = 0;
+  while (i < n || j < m) {
+    if (i < n && j < m && midA[i] === midB[j]) { ops.push({ op: " ", text: midA[i]! }); i++; j++; }
+    else if (j < m && (i >= n || lcs[i * (m + 1) + j + 1]! > lcs[(i + 1) * (m + 1) + j]!)) ops.push({ op: "+", text: midB[j++]! });
+    else ops.push({ op: "-", text: midA[i++]! });
+  }
+  for (const text of a.slice(endA)) ops.push({ op: " ", text });
+  return ops;
+}
+
+/** Unified hunks with `context` lines around each change. */
+export function diffRows(ops: readonly DiffOp[], context = 3): DiffRow[] {
+  const rows: DiffRow[] = [];
+  const changed = ops.map((op) => op.op !== " ");
+  let oldLine = 1, newLine = 1;
+  const positions = ops.map((op) => {
+    const at = { oldLine, newLine };
+    if (op.op !== "+") oldLine++;
+    if (op.op !== "-") newLine++;
+    return at;
+  });
+  let index = 0;
+  while (index < ops.length) {
+    if (!changed[index]) { index++; continue; }
+    const from = Math.max(0, index - context);
+    let to = index;
+    // Extend the hunk while the next change is within 2 × context lines.
+    while (to < ops.length) {
+      let next = to + 1;
+      while (next < ops.length && !changed[next]) next++;
+      if (next < ops.length && next - to <= context * 2) { to = next; continue; }
+      break;
+    }
+    const end = Math.min(ops.length, to + context + 1);
+    const slice = ops.slice(from, end);
+    const oldCount = slice.filter((op) => op.op !== "+").length;
+    const newCount = slice.filter((op) => op.op !== "-").length;
+    rows.push({ kind: "hunk", text: `@@ -${positions[from]!.oldLine},${oldCount} +${positions[from]!.newLine},${newCount} @@` });
+    for (let at = from; at < end; at++) {
+      const op = ops[at]!;
+      rows.push({ kind: op.op === "+" ? "add" : op.op === "-" ? "remove" : "context", text: op.text,
+        ...(op.op !== "+" ? { oldLine: positions[at]!.oldLine } : {}), ...(op.op !== "-" ? { newLine: positions[at]!.newLine } : {}) });
+    }
+    index = end;
+  }
+  return rows;
+}
+
+/**
+ * Remembers each file's content before the agent's first edit/write to it, so the user can
+ * review everything changed since and accept or revert per file. Session-local and in memory.
+ */
+export class ChangeTracker {
+  private baselines = new Map<string, string | null>();
+  private readonly cwd: () => string;
+  constructor(cwd: () => string) { this.cwd = cwd; }
+
+  private absolute(path: string): string { return isAbsolute(path) ? resolve(path) : resolve(this.cwd(), path); }
+
+  /** Record the pre-change content once; returns false when the file cannot be tracked. */
+  capture(path: string): boolean {
+    const target = this.absolute(path);
+    if (this.baselines.has(target)) return true;
+    // Only project files: plan files and scratch space elsewhere are not part of the review.
+    const rel = relative(this.cwd(), target);
+    if (!rel || rel.startsWith("..") || isAbsolute(rel)) return false;
+    if (this.baselines.size >= MAX_TRACKED_FILES) return false;
+    const content = readText(target);
+    if (content === undefined) return false;
+    this.baselines.set(target, content);
+    return true;
+  }
+
+  changes(): FileChange[] {
+    const result: FileChange[] = [];
+    for (const [path, before] of this.baselines) {
+      const now = readText(path);
+      if (now === undefined || now === before) continue;
+      const ops = lineDiff(before ?? "", now ?? "");
+      const added = ops ? ops.filter((op) => op.op === "+").length : splitLines(now ?? "").length;
+      const removed = ops ? ops.filter((op) => op.op === "-").length : splitLines(before ?? "").length;
+      const rel = relative(this.cwd(), path);
+      result.push({ path, rel: rel && !rel.startsWith("..") ? rel : path, status: before === null ? "added" : now === null ? "deleted" : "modified",
+        before: before ?? "", after: now ?? "", added, removed });
+    }
+    return result.sort((a, b) => a.rel.localeCompare(b.rel));
+  }
+
+  count(): number { return this.changes().length; }
+  /** Keep the current content: stop tracking the file. */
+  accept(path: string): void { this.baselines.delete(this.absolute(path)); }
+  acceptAll(): void { this.baselines.clear(); }
+  /** Restore the pre-change content (or remove a file the agent created). */
+  revert(path: string): void {
+    const target = this.absolute(path);
+    if (!this.baselines.has(target)) throw new Error("not a tracked change: " + path);
+    const before = this.baselines.get(target)!;
+    if (before === null) { if (existsSync(target)) unlinkSync(target); }
+    else writeFileSync(target, before);
+    this.baselines.delete(target);
+  }
+  clear(): void { this.baselines.clear(); }
+}

package/src/commit.ts

@@ -0,0 +1,61 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { ModelRoleManager } from "./model-roles.ts";
+import { askRole, type SideUsage } from "./side-model.ts";
+
+const DIFF_LIMIT = 60_000;
+
+export const COMMIT_SYSTEM = [
+  "You write git commit messages.",
+  "Reply with the message only: no code fences, no preamble.",
+  "First line: imperative summary under 72 characters, matching the style of the recent commits (e.g. a `type: ` prefix if they use one).",
+  "Then a blank line and a short body explaining what changed and why, wrapped at 72 columns. Skip the body for trivial changes."
+].join("\n");
+
+/** Remove fences or quoting a model may add around the message. */
+export function cleanCommitMessage(text: string): string {
+  let body = text.trim().replace(/^```[a-z]*\n([\s\S]*?)\n```$/i, "$1").trim();
+  if (/^["'].*["']$/s.test(body)) body = body.slice(1, -1).trim();
+  return body.split("\n").map((line) => line.trimEnd()).join("\n").replace(/\n{3,}/g, "\n\n");
+}
+
+export function commitPrompt(stat: string, diff: string, log: string, hint: string): string {
+  const clipped = diff.length > DIFF_LIMIT ? diff.slice(0, DIFF_LIMIT) + `\n… diff truncated (${diff.length - DIFF_LIMIT} more characters)` : diff;
+  return [hint ? `Author's note: ${hint}\n` : "", "Recent commits:\n" + (log.trim() || "(none)"), "\nStaged files:\n" + stat.trim(), "\nStaged diff:\n" + clipped].join("\n");
+}
+
+/** `/jar commit [note]`: draft a message for the staged changes with the commit role, review it, commit. Never pushes. */
+export async function jarCommit(pi: ExtensionAPI, ctx: ExtensionContext, roles: ModelRoleManager, usage: SideUsage | undefined, hint = ""): Promise<void> {
+  if (!ctx.hasUI) { ctx.ui.notify("/jar commit needs the interactive UI to review the message", "warning"); return; }
+  const git = async (...args: string[]) => {
+    const result = await pi.exec("git", args, { cwd: ctx.cwd, timeout: 20_000 });
+    if (result.code !== 0) throw new Error(`git ${args[0]}: ${(result.stderr || result.stdout).trim() || "exit " + result.code}`);
+    return result.stdout;
+  };
+  try {
+    await git("rev-parse", "--is-inside-work-tree");
+    let stat = await git("diff", "--cached", "--stat");
+    if (!stat.trim()) {
+      const dirty = await git("status", "--porcelain");
+      if (!dirty.trim()) { ctx.ui.notify("Nothing to commit", "info"); return; }
+      if (!await ctx.ui.confirm("Nothing staged", "Stage all changes (git add -A) and continue?")) return;
+      await git("add", "-A");
+      stat = await git("diff", "--cached", "--stat");
+    }
+    const [diff, log] = await Promise.all([git("diff", "--cached", "--no-color"), git("log", "-n", "8", "--oneline").catch(() => "")]);
+    ctx.ui.notify("Drafting a commit message…", "info");
+    const answer = await askRole(ctx, roles, usage, "commit", COMMIT_SYSTEM, commitPrompt(stat, diff, log, hint), ctx.signal);
+    const message = cleanCommitMessage(await ctx.ui.editor(`Commit message · ${answer.model} · save to commit, empty to cancel`, cleanCommitMessage(answer.text)) ?? "");
+    if (!message) { ctx.ui.notify("Commit cancelled", "info"); return; }
+    const dir = mkdtempSync(join(tmpdir(), "pi-jar-commit-"));
+    try {
+      writeFileSync(join(dir, "MSG"), message + "\n");
+      const out = await git("commit", "-F", join(dir, "MSG"));
+      ctx.ui.notify(out.trim().split("\n")[0] || "Committed", "info");
+    } finally { rmSync(dir, { recursive: true, force: true }); }
+  } catch (error) {
+    ctx.ui.notify("pi-jar commit: " + (error instanceof Error ? error.message : String(error)), "error");
+  }
+}

package/src/compact-tools.ts

@@ -0,0 +1,129 @@
+import {
+  createBashToolDefinition,
+  createEditToolDefinition,
+  createReadToolDefinition,
+  createWriteToolDefinition,
+  getAgentDir,
+  SettingsManager,
+  type ExtensionAPI,
+  type ExtensionContext
+} from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+
+type ToolResult = { content: Array<{ type: string; text?: string }>; details?: unknown };
+
+const outputText = (result: ToolResult): string => result.content
+  .filter((item) => item.type === "text" && typeof item.text === "string")
+  .map((item) => item.text!)
+  .join("\n");
+
+const nonEmptyLines = (text: string): string[] => text.split("\n").filter((line) => line.trim().length > 0);
+const expandHint = " · [ expand ] Ctrl+O";
+
+function compactText(text: string, max = 72): string {
+  const clean = text.replace(/\s+/g, " ").trim();
+  return clean.length <= max ? clean : clean.slice(0, Math.max(0, max - 1)) + "…";
+}
+
+function bashFor(ctx: ExtensionContext) {
+  const settings = SettingsManager.create(ctx.cwd, getAgentDir(), { projectTrusted: ctx.isProjectTrusted() });
+  return createBashToolDefinition(ctx.cwd, {
+    shellPath: settings.getShellPath(),
+    commandPrefix: settings.getShellCommandPrefix()
+  });
+}
+
+/**
+ * Keep Pi's execution/schema/prompt metadata intact and replace only the collapsed
+ * presentation. Expanded cards delegate back to Pi's native renderers.
+ */
+export function installCompactBuiltinTools(pi: ExtensionAPI): void {
+  if (typeof (pi as ExtensionAPI & { registerTool?: unknown }).registerTool !== "function") return;
+
+  const cwd = process.cwd();
+  const read = createReadToolDefinition(cwd);
+  const bash = createBashToolDefinition(cwd);
+  const edit = createEditToolDefinition(cwd);
+  const write = createWriteToolDefinition(cwd);
+
+  pi.registerTool({
+    ...read,
+    renderCall(args, theme, context) {
+      if (context.expanded && read.renderCall) return read.renderCall(args, theme, context);
+      const range = args.offset || args.limit
+        ? theme.fg("dim", ` · ${args.offset ?? 1}${args.limit ? `+${args.limit}` : ""}`)
+        : "";
+      return new Text(theme.fg("toolTitle", theme.bold("read ")) + theme.fg("accent", args.path) + range, 0, 0);
+    },
+    renderResult(result, options, theme, context) {
+      if (options.expanded && read.renderResult) return read.renderResult(result, options, theme, context);
+      if (options.isPartial) return new Text(theme.fg("warning", "reading…"), 0, 0);
+      const text = outputText(result);
+      const count = text ? text.split("\n").length : 0;
+      return new Text(theme.fg("muted", `${count} line${count === 1 ? "" : "s"}${expandHint}`), 0, 0);
+    }
+  });
+
+  pi.registerTool({
+    ...bash,
+    async execute(id, params, signal, onUpdate, ctx) {
+      return bashFor(ctx).execute(id, params, signal, onUpdate, ctx);
+    },
+    renderCall(args, theme, context) {
+      if (context.expanded && bash.renderCall) return bash.renderCall(args, theme, context);
+      return new Text(theme.fg("toolTitle", theme.bold("$ ")) + theme.fg("accent", compactText(args.command, 88)), 0, 0);
+    },
+    renderResult(result, options, theme, context) {
+      if (options.expanded && bash.renderResult) return bash.renderResult(result as Parameters<NonNullable<typeof bash.renderResult>>[0], options, theme, context);
+      const text = outputText(result);
+      const lines = nonEmptyLines(text);
+      const preview = lines[0] ? ` · ${compactText(lines[0], 56)}` : "";
+      const label = options.isPartial ? "running" : "done";
+      return new Text(theme.fg(options.isPartial ? "warning" : "muted",
+        `${label} · ${lines.length} line${lines.length === 1 ? "" : "s"}${preview}${expandHint}`), 0, 0);
+    }
+  });
+
+  pi.registerTool({
+    ...edit,
+    renderCall(args, theme, context) {
+      if (context.expanded && edit.renderCall) return edit.renderCall(args, theme, context);
+      return new Text(theme.fg("toolTitle", theme.bold("edit ")) + theme.fg("accent", args.path), 0, 0);
+    },
+    renderResult(result, options, theme, context) {
+      if (options.expanded && edit.renderResult) return edit.renderResult(result, options, theme, context);
+      if (options.isPartial) return new Text(theme.fg("warning", "editing…"), 0, 0);
+      const details = result.details as { diff?: string } | undefined;
+      const diff = details?.diff ?? "";
+      if (!diff) {
+        const text = outputText(result);
+        return new Text(theme.fg(text.startsWith("Error") ? "error" : "success", compactText(text || "applied", 96)), 0, 0);
+      }
+      let additions = 0;
+      let removals = 0;
+      for (const line of diff.split("\n")) {
+        if (line.startsWith("+") && !line.startsWith("+++")) additions++;
+        else if (line.startsWith("-") && !line.startsWith("---")) removals++;
+      }
+      return new Text(theme.fg("success", `+${additions}`) + theme.fg("dim", " / ")
+        + theme.fg("error", `-${removals}`) + theme.fg("dim", expandHint), 0, 0);
+    }
+  });
+
+  pi.registerTool({
+    ...write,
+    renderCall(args, theme, context) {
+      if (context.expanded && write.renderCall) return write.renderCall(args, theme, context);
+      const count = args.content.split("\n").length;
+      return new Text(theme.fg("toolTitle", theme.bold("write ")) + theme.fg("accent", args.path)
+        + theme.fg("dim", ` · ${count} lines`), 0, 0);
+    },
+    renderResult(result, options, theme, context) {
+      if (options.expanded && write.renderResult) return write.renderResult(result, options, theme, context);
+      if (options.isPartial) return new Text(theme.fg("warning", "writing…"), 0, 0);
+      const text = outputText(result);
+      return new Text(theme.fg(text.startsWith("Error") ? "error" : "success", compactText(text || "written", 96))
+        + theme.fg("dim", text ? expandHint : ""), 0, 0);
+    }
+  });
+}