@tmustier/pi-files-widget 0.1.0

package/file-tree.ts

@@ -0,0 +1,156 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { basename, join, relative } from "node:path";
+
+import { MAX_TREE_DEPTH } from "./constants";
+import type { DiffStats, FileNode, FlatNode } from "./types";
+
+export function getFileLineCount(filePath: string): number {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    return content.split("\n").length;
+  } catch {
+    return 0;
+  }
+}
+
+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 buildFileTree(
+  dir: string,
+  cwd: string,
+  gitStatus: Map<string, string>,
+  diffStats: Map<string, DiffStats>,
+  ignored: Set<string>,
+  agentModified: Set<string>,
+  depth = 0
+): FileNode | null {
+  if (depth > MAX_TREE_DEPTH) return null;
+
+  const name = basename(dir) || dir;
+  if (ignored.has(name)) return null;
+
+  const node: FileNode = {
+    name: depth === 0 ? "." : name,
+    path: dir,
+    isDirectory: true,
+    children: [],
+    expanded: depth < 1,
+    hasChangedChildren: false,
+  };
+
+  try {
+    const entries = readdirSync(dir);
+    const dirs: FileNode[] = [];
+    const files: FileNode[] = [];
+
+    for (const entry of entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()))) {
+      if (ignored.has(entry) || entry.startsWith(".")) continue;
+
+      const fullPath = join(dir, entry);
+      let stat;
+      try {
+        stat = statSync(fullPath);
+      } catch {
+        continue;
+      }
+
+      if (stat.isDirectory()) {
+        const child = buildFileTree(fullPath, cwd, gitStatus, diffStats, ignored, agentModified, depth + 1);
+        if (child) {
+          dirs.push(child);
+          // Propagate hasChangedChildren up
+          if (child.hasChangedChildren || child.gitStatus) {
+            node.hasChangedChildren = true;
+          }
+        }
+      } else {
+        const relPath = relative(cwd, fullPath);
+        const fileGitStatus = gitStatus.get(relPath);
+        const fileDiffStats = diffStats.get(relPath);
+
+        if (fileGitStatus) {
+          node.hasChangedChildren = true;
+        }
+
+        files.push({
+          name: entry,
+          path: fullPath,
+          isDirectory: false,
+          gitStatus: fileGitStatus,
+          agentModified: agentModified.has(fullPath),
+          lineCount: getFileLineCount(fullPath),
+          diffStats: fileDiffStats,
+        });
+      }
+    }
+
+    node.children = [...dirs, ...files];
+
+    // Calculate aggregated stats for this directory
+    let totalLines = 0;
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+
+    for (const child of node.children) {
+      if (child.isDirectory) {
+        totalLines += child.totalLines || 0;
+        totalAdditions += child.totalAdditions || 0;
+        totalDeletions += child.totalDeletions || 0;
+      } else {
+        totalLines += child.lineCount || 0;
+        if (child.diffStats) {
+          totalAdditions += child.diffStats.additions;
+          totalDeletions += child.diffStats.deletions;
+        }
+      }
+    }
+
+    node.totalLines = totalLines;
+    node.totalAdditions = totalAdditions;
+    node.totalDeletions = totalDeletions;
+  } catch {}
+
+  return node;
+}
+
+export function flattenTree(node: FileNode, depth = 0, isRoot = true): 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));
+    }
+    return result;
+  }
+
+  result.push({ node, depth });
+
+  if (node.isDirectory && node.expanded && node.children) {
+    for (const child of node.children) {
+      result.push(...flattenTree(child, depth + 1, false));
+    }
+  }
+
+  return result;
+}

package/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/git.ts

@@ -0,0 +1,72 @@
+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): Map<string, string> {
+  const status = new Map<string, string>();
+  try {
+    // Include ignored files with --ignored flag
+    const output = execSync("git status --porcelain --ignored", { 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 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/index.ts

@@ -0,0 +1,139 @@
+/**
+ * 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 browser = createFileBrowser(cwd, agentModifiedFiles, theme, cleanup, requestComment);
+
+        pollInterval = setInterval(() => {
+          tui.requestRender();
+        }, POLL_INTERVAL_MS);
+
+        return {
+          render: (w) => browser.render(w),
+          handleInput: (data) => {
+            browser.handleInput(data);
+            tui.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/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/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@tmustier/pi-files-widget",
+  "version": "0.1.0",
+  "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/types.ts

@@ -0,0 +1,26 @@
+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;
+}
+
+export interface FlatNode {
+  node: FileNode;
+  depth: number;
+}

package/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);
+}