@pellux/goodvibes-tui 1.0.0 → 1.7.0

package/src/panels/diff-panel.ts

@@ -5,11 +5,11 @@
 import type { Line } from '../types/grid.ts';
 import { createStyledCell, createEmptyLine } from '../types/grid.ts';
 import { truncateDisplay, getDisplayWidth } from '../utils/terminal-width.ts';
+import { GitService } from '@pellux/goodvibes-sdk/platform/git';
 import { BasePanel } from './base-panel.ts';
 import { UI_TONES, DIFF_TONES } from '../renderer/ui-primitives.ts';
-import { FilePreviewPanel } from './file-preview-panel.ts';
-import type { PanelIntegrationContext } from './types.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
+import { PanelConfirmOverlay } from './panel-confirm-overlay.ts';
 import {
   buildBodyText,
   buildEmptyState,
@@ -166,20 +166,49 @@ function parseDiff(raw: string): ParsedLine[] {
 // Split a full `git diff` output into per-file entries
 // ---------------------------------------------------------------------------
 
+/**
+ * Synthetic placeholder entries ('(error)', '(no changes)', '(no staged
+ * changes)', '(not a git repo)') are not real diffs — parenthesized so they
+ * can be styled distinctly in the tab/status bar instead of reading as a fake
+ * diff of a real file.
+ */
+function isPlaceholderPath(filePath: string): boolean {
+  return filePath.startsWith('(') && filePath.endsWith(')');
+}
+
+/**
+ * Extract the file path from one `diff --git`-delimited chunk. Tries, in
+ * order: the standard two-sided header (`diff --git a/x b/y`, bare or
+ * quoted), the combined/merge-conflict header (`diff --cc <path>` /
+ * `diff --combined <path>`, which carries no a/b prefixes), then falls back
+ * to the `+++`/`---` file lines (present across every variant, uniformly) —
+ * skipping a `/dev/null` side (deleted/new file). 'unknown' is reserved for
+ * genuinely unparseable input.
+ */
+function extractDiffFilePath(trimmed: string): string {
+  const quotedGit = trimmed.match(/^diff --git "a\/(.+)" "b\/(.+)"$/m);
+  if (quotedGit) return quotedGit[2]!;
+  const plainGit = trimmed.match(/^diff --git a\/.+? b\/(.+)$/m);
+  if (plainGit) return plainGit[1]!;
+  const combined = trimmed.match(/^diff --(?:cc|combined) "?([^"\n]+?)"?$/m);
+  if (combined) return combined[1]!;
+  const plus = trimmed.match(/^\+\+\+ (?:b\/)?"?([^"\n]+?)"?\s*$/m);
+  if (plus && plus[1] !== '/dev/null') return plus[1]!;
+  const minus = trimmed.match(/^--- (?:a\/)?"?([^"\n]+?)"?\s*$/m);
+  if (minus && minus[1] !== '/dev/null') return minus[1]!;
+  return 'unknown';
+}
+
 function splitIntoDiffEntries(raw: string): DiffEntry[] {
   const entries: DiffEntry[] = [];
-  // Split on "diff --git" lines
-  const chunks = raw.split(/(?=^diff --git )/m);
+  // Split on "diff --git" / "diff --cc" / "diff --combined" lines
+  const chunks = raw.split(/(?=^diff --git |^diff --cc |^diff --combined )/m);
   for (const chunk of chunks) {
     const trimmed = chunk.trim();
     if (!trimmed) continue;
 
-    // Extract file path from "diff --git a/foo b/foo"
-    const match = trimmed.match(/^diff --git a\/.+? b\/(.+)$/m);
-    const filePath = match ? match[1]! : 'unknown';
-
     entries.push({
-      filePath,
+      filePath: extractDiffFilePath(trimmed),
       raw: chunk,
       lines: parseDiff(chunk),
     });
@@ -232,10 +261,16 @@ export class DiffPanel extends BasePanel {
   private selectedFile = 0;
   private scrollOffset = 0;
 
-  /** Set by the 'o' key; consumed by handlePanelIntegrationAction on the next dispatch. */
-  private pendingOpenPreview = false;
+  /** One-line confirmation for the 'w'/'h'/'s' self-load hotkeys — otherwise a
+   * reload that produces identical content is visually indistinguishable
+   * from the keypress doing nothing at all. */
+  private hotkeyStatus: string | null = null;
 
-  constructor(workingDirectory: string) {
+  public readonly confirmOverlay = new PanelConfirmOverlay(() => this.markDirty()); // armed by a command handler (e.g. /rewind); see panel-confirm-overlay.ts
+  constructor(
+    workingDirectory: string,
+    private readonly requestRender: () => void = () => {},
+  ) {
     super('diff', 'Diff', 'D', 'development');
     this.workingDirectory = workingDirectory;
   }
@@ -271,12 +306,33 @@ export class DiffPanel extends BasePanel {
     this.markDirty();
   }
 
+  /**
+   * Defensive gate mirroring GitPanel's own notGitRepo messaging — short-
+   * circuits before any of this panel's self-load git spawns run, instead of
+   * letting git fail per-subcommand with an inconsistent error shape.
+   */
+  private showNotGitRepo(): void {
+    this.showDiff('(not a git repo)', '@@ -0,0 +0,0 @@\n Not a git repository here.');
+  }
+
   /** Run `git diff` against specific files and populate entries. */
   async showFileDiffs(files: string[], ref?: string): Promise<void> {
+    if (!GitService.isGitRepo(this.workingDirectory)) {
+      this.showNotGitRepo();
+      return;
+    }
     const args = ['diff', ...(ref ? [ref] : []), '--', ...files];
-    const proc = Bun.spawn(['git', ...args], { stdout: 'pipe', cwd: this.workingDirectory });
-    const raw = await new Response(proc.stdout).text();
-    await proc.exited;
+    const proc = Bun.spawn(['git', ...args], { stdout: 'pipe', stderr: 'pipe', cwd: this.workingDirectory });
+    const [raw, errText] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const errorText = errText.trim() || 'git diff failed';
+      this.showDiff('(error)', `--- error\n+++ error\n@@ -0,0 +1,1 @@\n+${errorText}`);
+      return;
+    }
     this.loadRawDiff(raw);
     this.enrichSemanticDiffs(files, ref ?? 'HEAD').catch((err) => { logger.debug('DiffPanel: semantic diff enrichment failed', { err }); });
   }
@@ -287,6 +343,10 @@ export class DiffPanel extends BasePanel {
    * enriches every loaded file with a semantic-diff summary in the background.
    */
   async showGitDiff(ref?: string): Promise<void> {
+    if (!GitService.isGitRepo(this.workingDirectory)) {
+      this.showNotGitRepo();
+      return;
+    }
     const args = ['diff', ...(ref ? [ref] : [])];
     const proc = Bun.spawn(['git', ...args], { stdout: 'pipe', stderr: 'pipe', cwd: this.workingDirectory });
     const [raw, errText] = await Promise.all([
@@ -325,6 +385,10 @@ export class DiffPanel extends BasePanel {
    * `/diff staged` command handler.
    */
   async showStagedDiff(): Promise<void> {
+    if (!GitService.isGitRepo(this.workingDirectory)) {
+      this.showNotGitRepo();
+      return;
+    }
     const proc = Bun.spawn(['/bin/sh', '-c', 'git diff --cached'], { stdout: 'pipe', stderr: 'pipe', cwd: this.workingDirectory });
     const [raw, errText] = await Promise.all([
       new Response(proc.stdout).text(),
@@ -353,7 +417,7 @@ export class DiffPanel extends BasePanel {
     if (files.length === 0) return;
     const { computeSemanticDiff, formatSemanticDiffSummary } = await import('../renderer/semantic-diff.ts');
     const { join, relative: pathRelative } = await import('path');
-    const repoRootProc = Bun.spawn(['git', 'rev-parse', '--show-toplevel'], { stdout: 'pipe', cwd: this.workingDirectory });
+    const repoRootProc = Bun.spawn(['git', 'rev-parse', '--show-toplevel'], { stdout: 'pipe', stderr: 'pipe', cwd: this.workingDirectory });
     await repoRootProc.exited;
     const repoRoot = (await new Response(repoRootProc.stdout).text()).trim() || this.workingDirectory;
     await Promise.allSettled(
@@ -418,7 +482,24 @@ export class DiffPanel extends BasePanel {
   // Input
   // -------------------------------------------------------------------------
 
+  /**
+   * Wraps a self-load hotkey ('w'/'h'/'s') with visible before/after status
+   * text in the status bar — otherwise a reload whose content is unchanged
+   * from what's already shown is indistinguishable from the keypress having
+   * done nothing at all (contrast with `/diff working`'s ctx.print() calls).
+   */
+  private runHotkeyReload(label: string, load: () => Promise<void>): void {
+    this.hotkeyStatus = `Loading ${label} diff…`;
+    this.markDirty();
+    void load().then(() => {
+      this.hotkeyStatus = `Reloaded ${label} diff.`;
+      this.markDirty();
+      this.requestRender();
+    });
+  }
+
   handleInput(key: string): boolean {
+    if (this.confirmOverlay.handleInput(key)) return true; // confirm takes priority (git-panel.ts:284-303 precedent)
     switch (key) {
       case 'up':    this.scrollUp();   return true;
       case 'down':  this.scrollDown(); return true;
@@ -433,51 +514,20 @@ export class DiffPanel extends BasePanel {
       case 'backtab': this.prevFile(); return true;
       case 'pageup':   this.scrollPageUp();   return true;
       case 'pagedown': this.scrollPageDown(); return true;
-      case 'w': void this.showGitDiff();       return true;
-      case 'h': void this.showGitDiff('HEAD'); return true;
-      case 's': void this.showStagedDiff();    return true;
-      case 'o': {
-        if (!this.currentEntry()) return false;
-        this.pendingOpenPreview = true;
-        return true;
-      }
+      case 'w': this.runHotkeyReload('working tree', () => this.showGitDiff());       return true;
+      case 'h': this.runHotkeyReload('HEAD',         () => this.showGitDiff('HEAD')); return true;
+      case 's': this.runHotkeyReload('staged',       () => this.showStagedDiff());    return true;
       default: return false;
     }
   }
 
-  /**
-   * Cross-panel integration hook — 'o' opens the currently selected file in
-   * the preview panel via the same open/focus bridge FileExplorerPanel uses
-   * (src/input/panel-integration-actions.ts), without this panel needing to
-   * know about PanelManager pane/focus mechanics beyond what ctx exposes.
-   */
-  handlePanelIntegrationAction(_key: string, ctx: PanelIntegrationContext): boolean {
-    if (!this.pendingOpenPreview) return false;
-    this.pendingOpenPreview = false;
-    const entry = this.currentEntry();
-    if (!entry) return false;
-
-    const pm = ctx.panelManager;
-    let previewPanel = pm.getPanel('preview');
-    if (previewPanel instanceof FilePreviewPanel) {
-      const pane = pm.getPaneOf('preview');
-      pm.activateById('preview');
-      if (pane) pm.focusPane(pane);
-    } else {
-      const targetPane: 'top' | 'bottom' = pm.isBottomPaneVisible()
-        ? (pm.getFocusedPane() === 'top' ? 'bottom' : 'top')
-        : 'bottom';
-      const opened = pm.open('preview', targetPane);
-      pm.show();
-      pm.focusPane(targetPane);
-      previewPanel = opened instanceof FilePreviewPanel ? opened : null;
-    }
-    if (previewPanel instanceof FilePreviewPanel) {
-      previewPanel.openFile(entry.filePath);
-      return true;
-    }
-    return false;
-  }
+  // W6.1 (the purge): 'o' used to open the currently selected file in the
+  // preview panel via a staged pendingOpenPreview flag + a
+  // handlePanelIntegrationAction cross-panel hook (the same bridge
+  // FileExplorerPanel used). 'preview' is DELETE-disposition with no
+  // successor surface (no file-picker-overlay preview to repoint to
+  // either — verified), so the key and the hook were removed rather than
+  // repointed; diff no longer has an 'o' action.
 
   private scrollUp(): void {
     if (this.scrollOffset > 0) {
@@ -535,6 +585,8 @@ export class DiffPanel extends BasePanel {
     return this.trackedRender(() => {
     if (height <= 0 || width <= 0) return [];
 
+    const confirmLines = this.confirmOverlay.renderLines(width);
+    if (confirmLines) return buildPanelWorkspace(width, height, { title: 'Diff Workspace', palette: COLOR, sections: [{ title: 'Confirmation', lines: confirmLines }] });
     if (this.entries.length === 0) {
       return buildPanelWorkspace(width, height, {
         title: 'Diff Workspace',
@@ -623,11 +675,15 @@ export class DiffPanel extends BasePanel {
     for (let i = 0; i < this.entries.length; i++) {
       const entry = this.entries[i]!;
       const active = i === this.selectedFile;
+      const placeholder = isPlaceholderPath(entry.filePath);
       const stat = diffStat(entry);
-      const fg = active ? COLOR.tabActive : COLOR.tabInactive;
+      // Placeholder entries ('(error)', '(no changes)', ...) get a distinct
+      // warn color regardless of active/inactive — they are not a real diff
+      // of a real file and must not read as one.
+      const fg = placeholder ? COLOR.warn : (active ? COLOR.tabActive : COLOR.tabInactive);
       const bg = active ? COLOR.tabActiveBg : COLOR.tabBg;
       // Active file gets a leading marker; every tab shows +adds/-dels at a glance.
-      const marker = active ? '▸ ' : '  ';
+      const marker = active ? '▸ ' : (placeholder ? '⚠ ' : '  ');
       const label = `${marker}${basename(entry.filePath)} `;
       for (const ch of label) push(ch, fg, bg, active);
       if (stat.added > 0) for (const ch of `+${stat.added}`) push(ch, COLOR.addition, bg, active);
@@ -650,11 +706,15 @@ export class DiffPanel extends BasePanel {
       return buildStyledPanelLine(width, [{ text: ' No file', fg: COLOR.tabInactive, bg: COLOR.statusBar }], { fillBg: COLOR.statusBar });
     }
     const stat = diffStat(entry);
+    const placeholder = isPlaceholderPath(entry.filePath);
     // Keep the file path display-width-aware so a long/wide path can't overflow.
     const pathBudget = Math.max(8, Math.floor(width / 2));
     const fileInfo = truncateDisplay(entry.filePath, pathBudget);
     const segments: Array<{ text: string; fg: string; bg?: string; bold?: boolean }> = [
-      { text: ` ${fileInfo} `, fg: COLOR.filename, bg: COLOR.statusBar, bold: true },
+      // Placeholder states ('(error)', '(no changes)', ...) are not a real
+      // diff of a real file — a distinct warn color keeps them from being
+      // mistaken for one.
+      { text: ` ${fileInfo} `, fg: placeholder ? COLOR.warn : COLOR.filename, bg: COLOR.statusBar, bold: true },
       { text: `[${this.selectedFile + 1}/${this.entries.length}]`, fg: COLOR.tabInactive, bg: COLOR.statusBar },
       { text: '  +', fg: COLOR.tabInactive, bg: COLOR.statusBar },
       { text: String(stat.added), fg: COLOR.addition, bg: COLOR.statusBar },
@@ -666,6 +726,9 @@ export class DiffPanel extends BasePanel {
     if (entry.semanticSummary) {
       segments.push({ text: `  ◈ ${entry.semanticSummary}`, fg: COLOR.hunk, bg: COLOR.statusBar });
     }
+    if (this.hotkeyStatus) {
+      segments.push({ text: `  ${this.hotkeyStatus}`, fg: COLOR.info, bg: COLOR.statusBar, bold: true });
+    }
     return buildStyledPanelLine(width, segments, { fillBg: COLOR.statusBar });
   }
 

package/src/panels/eval-registry.ts

@@ -0,0 +1,60 @@
+/**
+ * EvalRegistry — holds the latest evaluation harness run state.
+ *
+ * W6.1 (the purge): extracted out of eval-panel.ts. 'eval' was
+ * DELETE-disposition (no surviving human surface — the evaluation harness
+ * is driven and reviewed via the `/eval` CLI command, input/commands/eval.ts)
+ * but this registry is still a live consumer of `/eval run` output, so it
+ * survives as a standalone read-model rather than being deleted with the
+ * view. See .goodvibes/audit/2026-07-04-wave6-briefs.json (W6.1).
+ */
+
+import type { EvalSuiteResult, EvalGateResult } from '@/runtime/index.ts';
+
+export class EvalRegistry {
+  private _suiteResults: EvalSuiteResult[] = [];
+  private _gateResults: EvalGateResult[] = [];
+  private _running = false;
+  private _lastRunAt: number | null = null;
+  private readonly _subscribers = new Set<() => void>();
+
+  push(result: EvalSuiteResult): void {
+    const idx = this._suiteResults.findIndex((r) => r.suite === result.suite);
+    if (idx >= 0) {
+      this._suiteResults[idx] = result;
+    } else {
+      this._suiteResults.push(result);
+    }
+    this._lastRunAt = Date.now();
+    this._notify();
+  }
+
+  pushGate(gate: EvalGateResult): void {
+    const idx = this._gateResults.findIndex((g) => g.suite === gate.suite);
+    if (idx >= 0) {
+      this._gateResults[idx] = gate;
+    } else {
+      this._gateResults.push(gate);
+    }
+    this._notify();
+  }
+
+  setRunning(running: boolean): void {
+    this._running = running;
+    this._notify();
+  }
+
+  isRunning(): boolean { return this._running; }
+  getLastRunAt(): number | null { return this._lastRunAt; }
+  getSuiteResults(): EvalSuiteResult[] { return this._suiteResults; }
+  getGateResults(): EvalGateResult[] { return this._gateResults; }
+
+  subscribe(cb: () => void): () => void {
+    this._subscribers.add(cb);
+    return () => this._subscribers.delete(cb);
+  }
+
+  private _notify(): void {
+    for (const cb of this._subscribers) cb();
+  }
+}