@mrclrchtr/supi-review 0.1.0

package/node_modules/@mrclrchtr/supi-core/src/settings-ui.ts

@@ -0,0 +1,226 @@
+// Generic settings overlay for SuPi extensions.
+//
+// Uses pi-tui's SettingsList with scope toggle (Tab), extension grouping,
+// and search. Each extension declares its settings via registerSettings().
+
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { getSettingsListTheme } from "@earendil-works/pi-coding-agent";
+import {
+  Container,
+  Input,
+  Key,
+  matchesKey,
+  type SettingItem,
+  SettingsList,
+  Text,
+} from "@earendil-works/pi-tui";
+import {
+  getRegisteredSettings,
+  type SettingsScope,
+  type SettingsSection,
+} from "./settings-registry.ts";
+
+// ── Input submenu component ──────────────────────────────────
+
+/**
+ * Creates a pi-tui Input-backed submenu component with enter-to-confirm
+ * and escape-to-cancel handling.
+ *
+ * @param currentValue - Initial value for the text input.
+ * @param label - Label text displayed above the input.
+ * @param done - Callback invoked with the confirmed value, or undefined on cancel.
+ */
+export function createInputSubmenu(
+  currentValue: string,
+  label: string,
+  done: (selectedValue?: string) => void,
+): {
+  render: (width: number) => string[];
+  invalidate: () => void;
+  handleInput: (data: string) => boolean;
+} {
+  const input = new Input();
+  input.setValue(currentValue);
+
+  return {
+    render: (_width: number) => {
+      const lines = [`  ${label}`];
+      lines.push(...input.render(_width));
+      lines.push("  enter confirm • esc cancel");
+      return lines;
+    },
+    invalidate: () => {
+      input.invalidate();
+    },
+    handleInput: (data: string) => {
+      if (matchesKey(data, Key.escape)) {
+        done();
+        return true;
+      }
+      if (matchesKey(data, Key.enter)) {
+        done(input.getValue());
+        return true;
+      }
+      input.handleInput(data);
+      return true;
+    },
+  };
+}
+
+// ── Types ────────────────────────────────────────────────────
+
+interface OverlayState {
+  scope: SettingsScope;
+  cwd: string;
+}
+
+// ── Pure helpers ─────────────────────────────────────────────
+
+function getScopeLabel(scope: SettingsScope): string {
+  return scope === "project" ? "Project" : "Global";
+}
+
+function buildFlatItems(
+  sections: SettingsSection[],
+  scope: SettingsScope,
+  cwd: string,
+): SettingItem[] {
+  const items: SettingItem[] = [];
+  for (const section of sections) {
+    const sectionItems = section.loadValues(scope, cwd);
+    for (const item of sectionItems) {
+      items.push({
+        ...item,
+        id: `${section.id}.${item.id}`,
+        label: `${section.label}: ${item.label}`,
+      });
+    }
+  }
+  return items;
+}
+
+function findSectionAndId(
+  sections: SettingsSection[],
+  flatId: string,
+): { section: SettingsSection; itemId: string } | null {
+  const dotIndex = flatId.indexOf(".");
+  if (dotIndex === -1) return null;
+  const sectionId = flatId.slice(0, dotIndex);
+  const itemId = flatId.slice(dotIndex + 1);
+  const section = sections.find((s) => s.id === sectionId);
+  if (!section) return null;
+  return { section, itemId };
+}
+
+// ── Component ────────────────────────────────────────────────
+
+interface SettingsOverlayDeps {
+  state: OverlayState;
+  container: Container;
+  settingsList: SettingsList | null;
+  tui: Parameters<Parameters<ExtensionContext["ui"]["custom"]>[0]>[0];
+  theme: Parameters<Parameters<ExtensionContext["ui"]["custom"]>[0]>[1];
+  done: () => void;
+}
+
+function createSettingsList(deps: SettingsOverlayDeps): SettingsList {
+  const sections = getRegisteredSettings();
+  const items = buildFlatItems(sections, deps.state.scope, deps.state.cwd);
+  const onChange = (flatId: string, newValue: string) => {
+    const found = findSectionAndId(sections, flatId);
+    if (found) {
+      found.section.persistChange(deps.state.scope, deps.state.cwd, found.itemId, newValue);
+    }
+    // Re-read all values to reflect persisted changes, but keep the list
+    // instance (and its selectedIndex) intact.
+    const updatedItems = buildFlatItems(sections, deps.state.scope, deps.state.cwd);
+    for (const updated of updatedItems) {
+      const existing = items.find((i) => i.id === updated.id);
+      if (existing && existing.currentValue !== updated.currentValue) {
+        settingsList.updateValue(updated.id, updated.currentValue);
+      }
+    }
+    deps.tui.requestRender();
+  };
+  const settingsList = new SettingsList(
+    items,
+    Math.min(items.length + 4, 20),
+    getSettingsListTheme(),
+    onChange,
+    () => deps.done(),
+    { enableSearch: true },
+  );
+  return settingsList;
+}
+
+function rebuildSettingsList(deps: SettingsOverlayDeps): SettingsList {
+  const settingsList = createSettingsList(deps);
+  deps.settingsList = settingsList;
+
+  deps.container.clear();
+  deps.container.addChild(createHeaderComponent(deps));
+  deps.container.addChild(settingsList);
+
+  return settingsList;
+}
+
+function createHeaderComponent(deps: SettingsOverlayDeps): Text {
+  const { theme, state } = deps;
+  const scopeLabel = getScopeLabel(state.scope);
+  const otherScope = state.scope === "project" ? "Global" : "Project";
+  const headerText = new Text(
+    `${theme.fg("accent", theme.bold("SuPi Settings"))}  ${theme.fg("text", `Scope: ${scopeLabel}`)} ${theme.fg("dim", `(tab → ${otherScope})`)}`,
+    0,
+    0,
+  );
+  return headerText;
+}
+
+function handleScopeToggle(deps: SettingsOverlayDeps): void {
+  deps.state.scope = deps.state.scope === "project" ? "global" : "project";
+  rebuildSettingsList(deps);
+  deps.tui.requestRender();
+}
+
+// ── Entry point ──────────────────────────────────────────────
+
+export function openSettingsOverlay(ctx: ExtensionContext): void {
+  const sections = getRegisteredSettings();
+  if (sections.length === 0) {
+    ctx.ui.notify("No settings registered by SuPi extensions", "info");
+    return;
+  }
+
+  void ctx.ui.custom<void>((tui, theme, _kb, done) => {
+    const state: OverlayState = { scope: "project", cwd: ctx.cwd };
+    const container = new Container();
+
+    const deps: SettingsOverlayDeps = {
+      state,
+      container,
+      settingsList: null,
+      tui,
+      theme,
+      done,
+    };
+
+    rebuildSettingsList(deps);
+
+    const component = {
+      render: (width: number) => container.render(width),
+      invalidate: () => container.invalidate(),
+      handleInput: (data: string) => {
+        if (matchesKey(data, Key.tab)) {
+          handleScopeToggle(deps);
+          return true;
+        }
+        // Delegate input to the settings list (always set after rebuildSettingsList)
+        deps.settingsList?.handleInput?.(data);
+        deps.tui.requestRender();
+        return true;
+      },
+    };
+
+    return component;
+  });
+}

package/node_modules/@mrclrchtr/supi-core/src/terminal.ts

@@ -0,0 +1,60 @@
+/**
+ * Shared terminal title formatting and signaling utilities.
+ *
+ * Centralized place for pi title convention (π prefix), completion (✓)
+ * and waiting (●) indicators, and the audible terminal bell.
+ */
+import path from "node:path";
+
+/** Unicode checkmark shown when the agent finishes a turn. */
+export const DONE_SYMBOL = "\u2713";
+/** Unicode dot shown when waiting for user input. */
+export const WAITING_SYMBOL = "\u25CF";
+
+/** Minimal UI surface needed for title operations. */
+export interface TitleTarget {
+  ui: {
+    setTitle?(title: string): void;
+  };
+}
+
+/**
+ * Format pi's canonical terminal title from session name and cwd.
+ * Falls back gracefully when either is missing.
+ *
+ * @example
+ *   formatTitle("my-session", "/home/projects/foo")  // "π - my-session - foo"
+ *   formatTitle(undefined, "/home/projects/foo")      // "π - foo"
+ *   formatTitle("my-session")                         // "π - my-session"
+ *   formatTitle()                                     // "π"
+ */
+export function formatTitle(sessionName?: string, cwd?: string): string {
+  const base = cwd ? path.basename(cwd) : undefined;
+  if (sessionName && base) return `π - ${sessionName} - ${base}`;
+  if (sessionName) return `π - ${sessionName}`;
+  if (base) return `π - ${base}`;
+  return "π";
+}
+
+/** Sound the audible terminal bell (ASCII BEL). */
+export function signalBell(): void {
+  process.stdout.write("\x07");
+}
+
+/**
+ * Set the terminal title to indicate the agent is waiting for user input.
+ * Prefixes with ● and sounds the terminal bell.
+ */
+export function signalWaiting(ctx: TitleTarget, title: string): void {
+  ctx.ui.setTitle?.(`${WAITING_SYMBOL}  ${title}`);
+  signalBell();
+}
+
+/**
+ * Set the terminal title to indicate the agent turn has completed.
+ * Prefixes with ✓ and sounds the terminal bell.
+ */
+export function signalDone(ctx: TitleTarget, title: string): void {
+  ctx.ui.setTitle?.(`${DONE_SYMBOL} ${title}`);
+  signalBell();
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@mrclrchtr/supi-review",
+  "version": "0.1.0",
+  "description": "SuPi Review extension — structured code review via /supi-review command",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mrclrchtr/supi.git"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-coding-agent"
+  ],
+  "files": [
+    "src/**/*.ts",
+    "README.md"
+  ],
+  "dependencies": {
+    "@mrclrchtr/supi-core": "workspace:*"
+  },
+  "bundledDependencies": [
+    "@mrclrchtr/supi-core"
+  ],
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "@earendil-works/pi-tui": "*",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "vitest": "^4.1.4"
+  },
+  "pi": {
+    "extensions": [
+      "./src/review.ts"
+    ]
+  },
+  "main": "src/index.ts"
+}

package/src/format-content.ts

@@ -0,0 +1,71 @@
+import type { ReviewResult } from "./types.ts";
+
+function priorityLabel(priority: number): string {
+  switch (priority) {
+    case 0:
+      return "info";
+    case 1:
+      return "minor";
+    case 2:
+      return "major";
+    case 3:
+      return "critical";
+    default:
+      return "info";
+  }
+}
+
+export function formatReviewContent(result: ReviewResult): string {
+  switch (result.kind) {
+    case "success":
+      return formatSuccessContent(result);
+    case "failed":
+      return `Review failed: ${result.reason}`;
+    case "canceled":
+      return "Review canceled";
+    case "timeout":
+      return formatTimeoutContent(result);
+  }
+}
+
+function formatTimeoutContent(result: Extract<ReviewResult, { kind: "timeout" }>): string {
+  const parts = [`Review timed out (exceeded ${(result.timeoutMs / 1000).toFixed(0)}s)`];
+  if (result.partialOutput) {
+    parts.push("", "Partial output:", result.partialOutput);
+  }
+  return parts.join("\n");
+}
+
+function formatSuccessContent(result: Extract<ReviewResult, { kind: "success" }>): string {
+  const output = result.output;
+  const confidencePercent = Math.round(output.overall_confidence_score * 100);
+  const lines = [
+    "## Code Review Result",
+    "",
+    `Verdict: ${output.overall_correctness} (confidence: ${confidencePercent}%)`,
+  ];
+
+  if (output.findings.length > 0) {
+    lines.push("", "### Findings", "", ...formatFindings(output.findings));
+  }
+
+  lines.push("", `Overall: ${output.overall_explanation}`);
+  return lines.join("\n");
+}
+
+function formatFindings(
+  findings: Extract<ReviewResult, { kind: "success" }>["output"]["findings"],
+): string[] {
+  return findings.flatMap((finding, index) => {
+    const loc = finding.code_location;
+    const lineRange =
+      loc.line_range.start === loc.line_range.end
+        ? String(loc.line_range.start)
+        : `${loc.line_range.start}-${loc.line_range.end}`;
+    return [
+      `#${index + 1} [${priorityLabel(finding.priority)}] ${finding.title}`,
+      `   ${loc.absolute_file_path}:${lineRange}`,
+      `   ${finding.body}`,
+    ];
+  });
+}

package/src/git.ts

@@ -0,0 +1,197 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+const GIT_TIMEOUT_MS = 30_000;
+
+export async function getMergeBase(repoPath: string, branch: string): Promise<string | undefined> {
+  try {
+    const { stdout } = await execFileAsync("git", ["merge-base", "HEAD", branch], {
+      cwd: repoPath,
+      timeout: GIT_TIMEOUT_MS,
+    });
+    return stdout.trim() || undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export async function getDiff(repoPath: string, baseSha: string): Promise<string> {
+  const { stdout } = await execFileAsync("git", ["diff", baseSha], {
+    cwd: repoPath,
+    timeout: GIT_TIMEOUT_MS,
+  });
+  return stdout;
+}
+
+export async function getUncommittedDiff(repoPath: string): Promise<string> {
+  const [staged, unstaged, untracked] = await Promise.all([
+    execFileAsync("git", ["diff", "--cached"], { cwd: repoPath, timeout: GIT_TIMEOUT_MS }).then(
+      (r) => r.stdout,
+      () => "",
+    ),
+    execFileAsync("git", ["diff"], { cwd: repoPath, timeout: GIT_TIMEOUT_MS }).then(
+      (r) => r.stdout,
+      () => "",
+    ),
+    execFileAsync("git", ["ls-files", "--others", "--exclude-standard"], {
+      cwd: repoPath,
+      timeout: GIT_TIMEOUT_MS,
+    }).then(
+      (r) => r.stdout,
+      () => "",
+    ),
+  ]);
+
+  let result = "";
+  if (staged.trim()) {
+    result += `=== Staged ===\n${staged}\n`;
+  }
+  if (unstaged.trim()) {
+    result += `=== Unstaged ===\n${unstaged}\n`;
+  }
+  if (untracked.trim()) {
+    const files = untracked
+      .trim()
+      .split("\n")
+      .map((f) => f.trim())
+      .filter((f) => f.length > 0);
+    if (files.length > 0) {
+      result += `=== Untracked files ===\n${files.join("\n")}\n`;
+    }
+  }
+  return result.trimEnd();
+}
+
+export interface CommitEntry {
+  sha: string;
+  subject: string;
+}
+
+export async function getRecentCommits(repoPath: string, limit = 20): Promise<CommitEntry[]> {
+  const { stdout } = await execFileAsync(
+    "git",
+    ["log", `--max-count=${limit}`, "--pretty=format:%H %s"],
+    { cwd: repoPath, timeout: GIT_TIMEOUT_MS },
+  );
+  return stdout
+    .split("\n")
+    .map((line) => {
+      const idx = line.indexOf(" ");
+      if (idx <= 0) return undefined;
+      return { sha: line.slice(0, idx), subject: line.slice(idx + 1) };
+    })
+    .filter((e): e is CommitEntry => e !== undefined);
+}
+
+export async function getCommitShow(repoPath: string, sha: string): Promise<string> {
+  const { stdout } = await execFileAsync("git", ["show", sha], {
+    cwd: repoPath,
+    timeout: GIT_TIMEOUT_MS,
+  });
+  return stdout;
+}
+
+export async function getDiffFileNames(repoPath: string, baseSha: string): Promise<string[]> {
+  const { stdout } = await execFileAsync("git", ["diff", "--name-only", baseSha], {
+    cwd: repoPath,
+    timeout: GIT_TIMEOUT_MS,
+  });
+  return stdout
+    .trim()
+    .split("\n")
+    .map((f) => f.trim())
+    .filter((f) => f.length > 0);
+}
+
+export async function getUncommittedFileNames(repoPath: string): Promise<string[]> {
+  const [unstaged, staged, untracked] = await Promise.all([
+    execFileAsync("git", ["diff", "--name-only"], { cwd: repoPath, timeout: GIT_TIMEOUT_MS }).then(
+      (r) => r.stdout,
+      () => "",
+    ),
+    execFileAsync("git", ["diff", "--cached", "--name-only"], {
+      cwd: repoPath,
+      timeout: GIT_TIMEOUT_MS,
+    }).then(
+      (r) => r.stdout,
+      () => "",
+    ),
+    execFileAsync("git", ["ls-files", "--others", "--exclude-standard"], {
+      cwd: repoPath,
+      timeout: GIT_TIMEOUT_MS,
+    }).then(
+      (r) => r.stdout,
+      () => "",
+    ),
+  ]);
+
+  const set = new Set([
+    ...unstaged
+      .trim()
+      .split("\n")
+      .map((f) => f.trim())
+      .filter((f) => f.length > 0),
+    ...staged
+      .trim()
+      .split("\n")
+      .map((f) => f.trim())
+      .filter((f) => f.length > 0),
+    ...untracked
+      .trim()
+      .split("\n")
+      .map((f) => f.trim())
+      .filter((f) => f.length > 0),
+  ]);
+  return Array.from(set).sort();
+}
+
+export async function getCommitFileNames(repoPath: string, sha: string): Promise<string[]> {
+  const { stdout } = await execFileAsync(
+    "git",
+    ["diff-tree", "--no-commit-id", "--name-only", "-r", sha],
+    { cwd: repoPath, timeout: GIT_TIMEOUT_MS },
+  );
+  return stdout
+    .trim()
+    .split("\n")
+    .map((f) => f.trim())
+    .filter((f) => f.length > 0);
+}
+
+export async function getLocalBranches(repoPath: string): Promise<string[]> {
+  const [{ stdout: local }, { stdout: current }] = await Promise.all([
+    execFileAsync("git", ["branch", "--format=%(refname:short)"], {
+      cwd: repoPath,
+      timeout: GIT_TIMEOUT_MS,
+    }),
+    execFileAsync("git", ["branch", "--show-current"], {
+      cwd: repoPath,
+      timeout: GIT_TIMEOUT_MS,
+    }),
+  ]);
+
+  const names = local
+    .trim()
+    .split("\n")
+    .map((b) => b.trim())
+    .filter((b) => b.length > 0);
+
+  const currentBranch = current.trim();
+  const set = new Set(names);
+  const sorted: string[] = [];
+
+  // Put default candidates first
+  for (const candidate of ["main", "master", currentBranch]) {
+    if (candidate && set.has(candidate)) {
+      sorted.push(candidate);
+      set.delete(candidate);
+    }
+  }
+
+  // Then remaining alphabetically
+  const remaining = Array.from(set).sort((a, b) => a.localeCompare(b));
+  sorted.push(...remaining);
+  return sorted;
+}

package/src/index.ts

@@ -0,0 +1 @@
+export { default } from "./review.ts";

package/src/progress-widget.ts

@@ -0,0 +1,82 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { CancellableLoader, Container, Text, type TUI } from "@earendil-works/pi-tui";
+import { formatTokens } from "./runner.ts";
+import type { ReviewProgress } from "./runner-types.ts";
+
+/**
+ * Live progress widget for code review.
+ *
+ * Shows an animated loader, turn count, tool uses, token count,
+ * and human-readable activity description.
+ */
+export class ReviewProgressWidget extends Container {
+  private _message: string;
+  private _progress: ReviewProgress = { turns: 0, toolUses: 0, activities: [] };
+  private _loader: CancellableLoader;
+  private _tui: TUI;
+  private _theme: Theme;
+
+  constructor(tui: TUI, theme: Theme, message: string) {
+    super();
+    this._tui = tui;
+    this._theme = theme;
+    this._message = message;
+    this._loader = new CancellableLoader(
+      tui,
+      (s: string) => theme.fg("accent", s),
+      (s: string) => theme.fg("muted", s),
+      message,
+    );
+
+    this._renderContent();
+  }
+
+  get signal(): AbortSignal {
+    return this._loader.signal;
+  }
+
+  set onAbort(fn: (() => void) | undefined) {
+    this._loader.onAbort = fn;
+  }
+
+  handleInput(data: string): void {
+    this._loader.handleInput(data);
+  }
+
+  /** Update progress state and re-render. */
+  updateProgress(progress: ReviewProgress): void {
+    this._progress = progress;
+    this._renderContent();
+    this._tui.requestRender();
+  }
+
+  dispose(): void {
+    this._loader.dispose();
+  }
+
+  private _renderContent(): void {
+    this.clear();
+
+    const { turns, toolUses, activities, tokens } = this._progress;
+
+    // Build the loader message with stats
+    const stats: string[] = [];
+    if (turns > 0) stats.push(`⟳${turns}`);
+    if (toolUses > 0) stats.push(`${toolUses} tool uses`);
+    if (tokens) {
+      stats.push(`${formatTokens(tokens.total)} tokens`);
+    }
+
+    const loaderMessage =
+      stats.length > 0 ? `${this._message} · ${stats.join(" · ")}` : this._message;
+
+    this._loader.setMessage(loaderMessage);
+    this.addChild(this._loader);
+
+    // Activity line
+    if (activities.length > 0) {
+      const activityText = activities.join(", ");
+      this.addChild(new Text(this._theme.fg("dim", `  ⎿  ${activityText}…`), 1, 0));
+    }
+  }
+}