pi-extensions 0.1.9

package/files-widget/file-tree.ts

@@ -0,0 +1,224 @@
+import { join } from "node:path";
+
+import { MAX_TREE_DEPTH } from "./constants";
+import type { DiffStats, FileNode, FlatNode } from "./types";
+
+const collator = new Intl.Collator(undefined, { sensitivity: "base" });
+
+function compareNodes(a: FileNode, b: FileNode): number {
+  if (a.isDirectory !== b.isDirectory) {
+    return a.isDirectory ? -1 : 1;
+  }
+  return collator.compare(a.name, b.name);
+}
+
+function shouldIgnoreSegment(segment: string, ignored: Set<string>): boolean {
+  return ignored.has(segment) || segment.startsWith(".");
+}
+
+export function sortChildren(node: FileNode): void {
+  if (!node.children || node.children.length === 0) return;
+  node.children.sort(compareNodes);
+}
+
+function sortTree(node: FileNode): void {
+  sortChildren(node);
+  if (node.children) {
+    for (const child of node.children) {
+      if (child.isDirectory) {
+        sortTree(child);
+      }
+    }
+  }
+}
+
+export function updateTreeStats(root: FileNode | null): void {
+  if (!root) return;
+
+  function traverse(node: FileNode): {
+    totalLines: number;
+    totalAdditions: number;
+    totalDeletions: number;
+    lineCountComplete: boolean;
+    hasChanges: boolean;
+  } {
+    if (!node.isDirectory) {
+      const totalLines = node.lineCount ?? 0;
+      const totalAdditions = node.diffStats?.additions ?? 0;
+      const totalDeletions = node.diffStats?.deletions ?? 0;
+      const lineCountComplete = node.lineCount !== undefined;
+      const hasChanges = Boolean(node.gitStatus || node.agentModified);
+      return { totalLines, totalAdditions, totalDeletions, lineCountComplete, hasChanges };
+    }
+
+    let totalLines = 0;
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+    let lineCountComplete = true;
+    let hasChanges = false;
+
+    if (node.children) {
+      for (const child of node.children) {
+        const stats = traverse(child);
+        totalLines += stats.totalLines;
+        totalAdditions += stats.totalAdditions;
+        totalDeletions += stats.totalDeletions;
+        if (!stats.lineCountComplete) {
+          lineCountComplete = false;
+        }
+        if (stats.hasChanges) {
+          hasChanges = true;
+        }
+      }
+    }
+
+    node.totalLines = totalLines;
+    node.totalAdditions = totalAdditions;
+    node.totalDeletions = totalDeletions;
+    node.lineCountComplete = lineCountComplete;
+    node.hasChangedChildren = hasChanges;
+
+    return { totalLines, totalAdditions, totalDeletions, lineCountComplete, hasChanges };
+  }
+
+  traverse(root);
+}
+
+export function buildFileTreeFromPaths(
+  cwd: string,
+  filePaths: string[],
+  gitStatus: Map<string, string>,
+  diffStats: Map<string, DiffStats>,
+  ignored: Set<string>,
+  agentModified: Set<string>
+): FileNode {
+  const root: FileNode = {
+    name: ".",
+    path: cwd,
+    isDirectory: true,
+    children: [],
+    expanded: true,
+    hasChangedChildren: false,
+  };
+
+  const directoryMap = new Map<string, FileNode>();
+  directoryMap.set("", root);
+  const seenFiles = new Set<string>();
+
+  for (const rawPath of filePaths) {
+    let normalized = rawPath.trim();
+    if (!normalized) continue;
+    if (normalized.startsWith("./")) {
+      normalized = normalized.slice(2);
+    }
+    normalized = normalized.replace(/\\/g, "/");
+
+    const parts = normalized.split("/").filter(Boolean);
+    if (parts.length === 0) continue;
+    const dirDepth = parts.length - 1;
+    if (dirDepth > MAX_TREE_DEPTH) continue;
+
+    let current = root;
+    let relPath = "";
+    let skip = false;
+
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (shouldIgnoreSegment(part, ignored)) {
+        skip = true;
+        break;
+      }
+      relPath = relPath ? `${relPath}/${part}` : part;
+      let dirNode = directoryMap.get(relPath);
+      if (!dirNode) {
+        const depth = i + 1;
+        dirNode = {
+          name: part,
+          path: join(cwd, relPath),
+          isDirectory: true,
+          children: [],
+          expanded: depth < 1,
+          hasChangedChildren: false,
+        };
+        directoryMap.set(relPath, dirNode);
+        current.children?.push(dirNode);
+      }
+      current = dirNode;
+    }
+
+    if (skip) continue;
+
+    const fileName = parts[parts.length - 1];
+    if (shouldIgnoreSegment(fileName, ignored)) continue;
+
+    const fileRelPath = parts.join("/");
+    if (seenFiles.has(fileRelPath)) continue;
+    seenFiles.add(fileRelPath);
+
+    const filePath = join(cwd, fileRelPath);
+    const fileGitStatus = gitStatus.get(fileRelPath);
+    const fileDiffStats = diffStats.get(fileRelPath);
+
+    current.children?.push({
+      name: fileName,
+      path: filePath,
+      isDirectory: false,
+      gitStatus: fileGitStatus,
+      agentModified: agentModified.has(filePath),
+      diffStats: fileDiffStats,
+    });
+  }
+
+  sortTree(root);
+  updateTreeStats(root);
+  return root;
+}
+
+export function getIgnoredNames(): Set<string> {
+  return new Set([
+    "node_modules",
+    ".git",
+    ".DS_Store",
+    "__pycache__",
+    ".pytest_cache",
+    ".mypy_cache",
+    ".next",
+    ".nuxt",
+    "dist",
+    "build",
+    ".venv",
+    "venv",
+    ".env",
+    "coverage",
+    ".nyc_output",
+    ".turbo",
+    ".cache",
+  ]);
+}
+
+export function flattenTree(
+  node: FileNode,
+  depth = 0,
+  isRoot = true,
+  includeCollapsed = false
+): FlatNode[] {
+  const result: FlatNode[] = [];
+
+  // Skip the root "." node itself, just process its children
+  if (isRoot && node.name === ".") {
+    for (const child of node.children || []) {
+      result.push(...flattenTree(child, 0, false, includeCollapsed));
+    }
+    return result;
+  }
+
+  result.push({ node, depth });
+
+  if (node.isDirectory && node.children && (includeCollapsed || node.expanded)) {
+    for (const child of node.children) {
+      result.push(...flattenTree(child, depth + 1, false, includeCollapsed));
+    }
+  }
+
+  return result;
+}

package/files-widget/file-viewer.ts

@@ -0,0 +1,93 @@
+import { execSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+
+import { isGitRepo } from "./git";
+import { hasCommand, stripLeadingEmptyLines } from "./utils";
+
+export function loadFileContent(
+  filePath: string,
+  cwd: string,
+  diffMode: boolean,
+  hasChanges: boolean,
+  width?: number
+): string[] {
+  const isMarkdown = filePath.endsWith(".md");
+  const termWidth = width || process.stdout.columns || 80;
+
+  try {
+    if (diffMode && hasChanges && isGitRepo(cwd)) {
+      try {
+        // Try different diff strategies
+        let diffOutput = "";
+
+        // First try: unstaged changes
+        const unstaged = execSync(`git diff -- "${filePath}"`, { cwd, encoding: "utf-8", timeout: 10000, stdio: "pipe" });
+        if (unstaged.trim()) {
+          diffOutput = unstaged;
+        } else {
+          // Second try: staged changes
+          const staged = execSync(`git diff --cached -- "${filePath}"`, { cwd, encoding: "utf-8", timeout: 10000, stdio: "pipe" });
+          if (staged.trim()) {
+            diffOutput = staged;
+          } else {
+            // Third try: diff against HEAD (for new files that are staged)
+            const headDiff = execSync(`git diff HEAD -- "${filePath}"`, { cwd, encoding: "utf-8", timeout: 10000, stdio: "pipe" });
+            if (headDiff.trim()) {
+              diffOutput = headDiff;
+            }
+          }
+        }
+
+        if (!diffOutput.trim()) {
+          return ["No diff available - file may be untracked or unchanged"];
+        }
+
+        if (hasCommand("delta")) {
+          // Pipe through delta with line numbers for better readability
+          try {
+            const deltaOutput = execSync(
+              `delta --no-gitconfig --width=${termWidth} --line-numbers`,
+              {
+                cwd,
+                encoding: "utf-8",
+                timeout: 10000,
+                input: diffOutput,
+                stdio: ["pipe", "pipe", "pipe"],
+              }
+            );
+            return stripLeadingEmptyLines(deltaOutput.split("\n"));
+          } catch {
+            // Fall back to raw diff
+          }
+        }
+
+        return diffOutput.split("\n");
+      } catch (e: any) {
+        return [`Diff error: ${e.message}`];
+      }
+    }
+
+    if (isMarkdown && hasCommand("glow")) {
+      try {
+        const output = execSync(`glow -s dark -w ${termWidth} "${filePath}"`, { encoding: "utf-8", timeout: 10000 });
+        if (output.trim()) {
+          return stripLeadingEmptyLines(output.split("\n"));
+        }
+      } catch {
+        // Fall through to bat
+      }
+    }
+
+    if (hasCommand("bat")) {
+      return execSync(
+        `bat --style=numbers --color=always --paging=never --wrap=auto --terminal-width=${termWidth} "${filePath}"`,
+        { encoding: "utf-8", timeout: 10000 }
+      ).split("\n");
+    }
+
+    const raw = readFileSync(filePath, "utf-8");
+    return raw.split("\n").map((line, i) => `${String(i + 1).padStart(4)} │ ${line}`);
+  } catch (e: any) {
+    return [`Error loading file: ${e.message}`];
+  }
+}

package/files-widget/git.ts

@@ -0,0 +1,107 @@
+import { execSync } from "node:child_process";
+
+import type { DiffStats } from "./types";
+
+export function isGitRepo(cwd: string): boolean {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", { cwd, encoding: "utf-8", timeout: 2000, stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function getGitStatus(cwd: string, options: { includeIgnored?: boolean } = {}): Map<string, string> {
+  const status = new Map<string, string>();
+  try {
+    const flags = ["--porcelain"];
+    if (options.includeIgnored !== false) {
+      flags.push("--ignored");
+    }
+    const output = execSync(`git status ${flags.join(" ")}`, { cwd, encoding: "utf-8", timeout: 5000, stdio: "pipe" });
+    for (const line of output.split("\n")) {
+      if (line.length < 3) continue;
+      const statusCode = line.slice(0, 2).trim() || "?";
+      const filePath = line.slice(3);
+      status.set(filePath, statusCode);
+    }
+  } catch {}
+  return status;
+}
+
+export function getGitFileList(cwd: string): string[] {
+  const files = new Set<string>();
+  try {
+    const tracked = execSync("git ls-files -z", { cwd, encoding: "utf-8", timeout: 5000, stdio: "pipe" });
+    for (const entry of tracked.split("\0")) {
+      if (entry) files.add(entry);
+    }
+  } catch {}
+
+  try {
+    const statusOutput = execSync("git status --porcelain -uall -z", { cwd, encoding: "utf-8", timeout: 5000, stdio: "pipe" });
+    const entries = statusOutput.split("\0");
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (!entry) continue;
+      const statusCode = entry.slice(0, 2).trim();
+      let filePath = entry.slice(3);
+      if ((statusCode.startsWith("R") || statusCode.startsWith("C")) && entries[i + 1]) {
+        i += 1;
+        filePath = entries[i];
+      } else if (filePath.includes(" -> ")) {
+        filePath = filePath.split(" -> ").pop() || filePath;
+      }
+      if (filePath) {
+        files.add(filePath);
+      }
+    }
+  } catch {}
+
+  return Array.from(files);
+}
+
+export function getGitBranch(cwd: string): string {
+  try {
+    return execSync("git branch --show-current", { cwd, encoding: "utf-8", timeout: 2000, stdio: "pipe" }).trim();
+  } catch {
+    return "";
+  }
+}
+
+export function getGitDiffStats(cwd: string): Map<string, DiffStats> {
+  const stats = new Map<string, DiffStats>();
+  try {
+    // Get diff stats for modified files
+    const output = execSync("git diff --numstat HEAD", { cwd, encoding: "utf-8", timeout: 5000, stdio: "pipe" });
+    for (const line of output.split("\n")) {
+      const parts = line.split("\t");
+      if (parts.length >= 3) {
+        const additions = parseInt(parts[0], 10) || 0;
+        const deletions = parseInt(parts[1], 10) || 0;
+        const filePath = parts[2];
+        stats.set(filePath, { additions, deletions });
+      }
+    }
+    // Also get stats for staged files
+    const stagedOutput = execSync("git diff --numstat --cached", { cwd, encoding: "utf-8", timeout: 5000, stdio: "pipe" });
+    for (const line of stagedOutput.split("\n")) {
+      const parts = line.split("\t");
+      if (parts.length >= 3) {
+        const additions = parseInt(parts[0], 10) || 0;
+        const deletions = parseInt(parts[1], 10) || 0;
+        const filePath = parts[2];
+        const existing = stats.get(filePath);
+        if (existing) {
+          stats.set(filePath, {
+            additions: existing.additions + additions,
+            deletions: existing.deletions + deletions,
+          });
+        } else {
+          stats.set(filePath, { additions, deletions });
+        }
+      }
+    }
+  } catch {}
+  return stats;
+}

package/files-widget/index.ts

@@ -0,0 +1,140 @@
+/**
+ * Pi Editor Extension
+ *
+ * Provides an in-terminal file browser, viewer, and review workflow.
+ * Use /files to open the file browser, navigate with j/k, Enter to view.
+ */
+
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { execSync, spawnSync } from "node:child_process";
+import { join } from "node:path";
+
+import { createFileBrowser } from "./browser";
+import { POLL_INTERVAL_MS } from "./constants";
+import { formatCommentMessage } from "./comment";
+import { hasCommand } from "./utils";
+
+export default function editorExtension(pi: ExtensionAPI): void {
+  const cwd = process.cwd();
+  const agentModifiedFiles = new Set<string>();
+
+  pi.registerCommand("files", {
+    description: "Open file browser",
+    handler: async (_args, ctx) => {
+      await ctx.ui.custom<void>((tui, theme, _kb, done) => {
+        let pollInterval: ReturnType<typeof setInterval> | null = null;
+
+        const cleanup = () => {
+          if (pollInterval) {
+            clearInterval(pollInterval);
+            pollInterval = null;
+          }
+          done();
+        };
+
+        const requestComment = (payload: { relPath: string; lineRange: string; ext: string; selectedText: string }, comment: string) => {
+          pi.sendUserMessage(formatCommentMessage(payload, comment), {
+            deliverAs: "followUp",
+            streamingBehavior: "followUp" as any,
+          } as any);
+        };
+
+        const requestRender = () => tui.requestRender();
+        const browser = createFileBrowser(cwd, agentModifiedFiles, theme, cleanup, requestComment, requestRender);
+
+        pollInterval = setInterval(() => {
+          requestRender();
+        }, POLL_INTERVAL_MS);
+
+        return {
+          render: (w) => browser.render(w),
+          handleInput: (data) => {
+            browser.handleInput(data);
+            requestRender();
+          },
+          invalidate: () => browser.invalidate(),
+        };
+      });
+    },
+  });
+
+  pi.registerCommand("review", {
+    description: "Open tuicr to review changes and send feedback to agent",
+    handler: async (_args, ctx) => {
+      if (!hasCommand("tuicr")) {
+        ctx.ui.notify("Install tuicr: brew install agavra/tap/tuicr", "error");
+        return;
+      }
+
+      ctx.ui.notify("Opening tuicr... Press :wq or y to copy review", "info");
+
+      try {
+        spawnSync("tuicr", [], { cwd, stdio: "inherit" });
+
+        try {
+          const clipboard = execSync(
+            process.platform === "darwin" ? "pbpaste" : "xclip -selection clipboard -o",
+            { encoding: "utf-8", timeout: 5000 }
+          );
+
+          if (
+            clipboard.includes("## Review") ||
+            clipboard.includes("```") ||
+            clipboard.includes("[Issue]") ||
+            clipboard.includes("[Suggestion]")
+          ) {
+            pi.sendUserMessage(clipboard, { deliverAs: "steer" });
+            ctx.ui.notify("Review sent to agent", "success");
+          }
+        } catch {}
+      } catch (e: any) {
+        ctx.ui.notify(`tuicr error: ${e.message}`, "error");
+      }
+    },
+  });
+
+  pi.registerCommand("diff", {
+    description: "Open critique to view diffs",
+    handler: async (args, ctx) => {
+      if (!hasCommand("bun")) {
+        ctx.ui.notify("critique requires Bun: brew install oven-sh/bun/bun", "error");
+        return;
+      }
+
+      const critiqueArgs = args ? args.split(" ") : [];
+      ctx.ui.notify("Opening critique...", "info");
+
+      try {
+        spawnSync("bunx", ["critique", ...critiqueArgs], { cwd, stdio: "inherit" });
+      } catch (e: any) {
+        ctx.ui.notify(`critique error: ${e.message}`, "error");
+      }
+    },
+  });
+
+  pi.on("tool_result", async (event) => {
+    if (event.toolName === "write" || event.toolName === "edit") {
+      const filePath = event.input?.path as string | undefined;
+      if (filePath) {
+        agentModifiedFiles.add(join(cwd, filePath));
+      }
+    }
+  });
+
+  pi.on("session_start", async (_event, ctx) => {
+    const missing: string[] = [];
+    if (!hasCommand("bat")) missing.push("bat");
+    if (!hasCommand("delta")) missing.push("delta");
+    if (!hasCommand("glow")) missing.push("glow");
+
+    if (missing.length > 0) {
+      ctx.ui.notify(`Editor: install ${missing.join(", ")} for better experience`, "info");
+    }
+
+    agentModifiedFiles.clear();
+  });
+
+  pi.on("session_switch", async () => {
+    agentModifiedFiles.clear();
+  });
+}

package/files-widget/input-utils.ts

@@ -0,0 +1,3 @@
+export function isPrintableChar(data: string): boolean {
+  return data.length === 1 && data.charCodeAt(0) >= 32 && data.charCodeAt(0) < 127;
+}

package/files-widget/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@tmustier/pi-files-widget",
+  "version": "0.1.9",
+  "description": "In-terminal file browser and viewer for Pi.",
+  "license": "MIT",
+  "author": "Thomas Mustier",
+  "keywords": [
+    "pi-package"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tmustier/pi-extensions.git",
+    "directory": "files-widget"
+  },
+  "bugs": "https://github.com/tmustier/pi-extensions/issues",
+  "homepage": "https://github.com/tmustier/pi-extensions/tree/main/files-widget",
+  "pi": {
+    "extensions": [
+      "index.ts"
+    ]
+  }
+}

package/files-widget/types.ts

@@ -0,0 +1,28 @@
+export interface DiffStats {
+  additions: number;
+  deletions: number;
+}
+
+export interface FileNode {
+  name: string;
+  path: string;
+  isDirectory: boolean;
+  children?: FileNode[];
+  expanded?: boolean;
+  gitStatus?: string;
+  agentModified?: boolean;
+  lineCount?: number;
+  diffStats?: DiffStats;
+  hasChangedChildren?: boolean; // For directories
+  // Aggregated stats for directories
+  totalLines?: number;
+  totalAdditions?: number;
+  totalDeletions?: number;
+  lineCountComplete?: boolean;
+  loading?: boolean;
+}
+
+export interface FlatNode {
+  node: FileNode;
+  depth: number;
+}

package/files-widget/utils.ts

@@ -0,0 +1,26 @@
+import { execSync } from "node:child_process";
+
+export function hasCommand(cmd: string): boolean {
+  try {
+    execSync(`which ${cmd}`, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function isUntrackedStatus(status?: string): boolean {
+  return status === "?" || status === "??";
+}
+
+export function isIgnoredStatus(status?: string): boolean {
+  return status === "!" || status === "!!";
+}
+
+export function stripLeadingEmptyLines(lines: string[]): string[] {
+  let startIdx = 0;
+  while (startIdx < lines.length && !lines[startIdx].trim()) {
+    startIdx++;
+  }
+  return lines.slice(startIdx);
+}