@fresh-editor/fresh-editor 0.1.75 → 0.1.77

package/plugins/git_blame.ts

@@ -1,4 +1,4 @@
-/// <reference path="../types/fresh.d.ts" />
+/// <reference path="./lib/fresh.d.ts" />
 const editor = getEditor();
 
 
@@ -664,14 +664,9 @@ globalThis.git_blame_copy_hash = function(): void {
     return;
   }
 
-  // Use spawn to copy to clipboard
-  editor.spawnProcess("sh", ["-c", `echo -n "${hash}" | xclip -selection clipboard 2>/dev/null || echo -n "${hash}" | pbcopy 2>/dev/null || echo -n "${hash}" | xsel --clipboard 2>/dev/null`])
-    .then(() => {
-      editor.setStatus(editor.t("status.hash_copied", { short: hash.slice(0, 7), full: hash }));
-    })
-    .catch(() => {
-      editor.setStatus(editor.t("status.hash_display", { hash }));
-    });
+  // Copy hash to clipboard
+  editor.copyToClipboard(hash);
+  editor.setStatus(editor.t("status.hash_copied", { short: hash.slice(0, 7), full: hash }));
 };
 
 // =============================================================================

package/plugins/git_explorer.ts

@@ -0,0 +1,159 @@
+/// <reference path="../types/fresh.d.ts" />
+const editor = getEditor();
+
+/**
+ * Git Explorer Decorations
+ *
+ * Adds VS Code-style status badges (M/A/U/D/...) to the file explorer.
+ */
+
+const NAMESPACE = "git-explorer";
+
+const COLORS = {
+  added: [80, 250, 123] as [number, number, number],
+  modified: [255, 184, 108] as [number, number, number],
+  deleted: [255, 85, 85] as [number, number, number],
+  renamed: [139, 233, 253] as [number, number, number],
+  untracked: [241, 250, 140] as [number, number, number],
+  conflicted: [255, 121, 198] as [number, number, number],
+};
+
+const PRIORITY = {
+  conflicted: 90,
+  deleted: 80,
+  added: 60,
+  modified: 50,
+  renamed: 40,
+  untracked: 30,
+};
+
+let refreshInFlight = false;
+
+function statusToDecoration(status: string, staged: boolean) {
+  switch (status) {
+    case "A":
+      return { symbol: "A", color: COLORS.added, priority: PRIORITY.added };
+    case "M":
+      return {
+        symbol: "M",
+        color: staged ? COLORS.added : COLORS.modified,
+        priority: PRIORITY.modified + (staged ? 2 : 0),
+      };
+    case "D":
+      return { symbol: "D", color: COLORS.deleted, priority: PRIORITY.deleted };
+    case "R":
+      return { symbol: "R", color: COLORS.renamed, priority: PRIORITY.renamed };
+    case "C":
+      return { symbol: "C", color: COLORS.renamed, priority: PRIORITY.renamed };
+    case "U":
+      return { symbol: "!", color: COLORS.conflicted, priority: PRIORITY.conflicted };
+    default:
+      return null;
+  }
+}
+
+function parseStatusOutput(output: string, repoRoot: string) {
+  const separator = output.includes("\0") ? "\0" : "\n";
+  const entries = output
+    .split(separator)
+    .map((entry) => entry.replace(/\r$/, ""))
+    .filter((entry) => entry.length > 0);
+  const byPath = new Map<string, { path: string; symbol: string; color: [number, number, number]; priority: number }>();
+
+  for (let i = 0; i < entries.length; i++) {
+    const entry = entries[i];
+    if (entry.length < 3) {
+      continue;
+    }
+    const x = entry[0];
+    const y = entry[1];
+    let path = entry.slice(3);
+
+    if ((x === "R" || x === "C") && separator === "\0" && i + 1 < entries.length) {
+      i += 1;
+      path = entries[i];
+    } else if (entry.includes(" -> ") && (x === "R" || x === "C" || y === "R" || y === "C")) {
+      path = entry.split(" -> ").pop() ?? path;
+    }
+
+    let decoration = null;
+    if (x === "?" && y === "?") {
+      decoration = { symbol: "U", color: COLORS.untracked, priority: PRIORITY.untracked };
+    } else if (x !== " " && x !== "?") {
+      decoration = statusToDecoration(x, true);
+    } else if (y !== " ") {
+      decoration = statusToDecoration(y, false);
+    }
+
+    if (!decoration) {
+      continue;
+    }
+
+    const absolutePath = editor.pathJoin(repoRoot, path);
+    const existing = byPath.get(absolutePath);
+    if (!existing || decoration.priority >= existing.priority) {
+      byPath.set(absolutePath, { path: absolutePath, ...decoration });
+    }
+  }
+
+  return Array.from(byPath.values());
+}
+
+async function refreshGitExplorerDecorations() {
+  if (refreshInFlight) {
+    return;
+  }
+  refreshInFlight = true;
+  try {
+    const cwd = editor.getCwd();
+    const rootResult = await editor.spawnProcess("git", ["rev-parse", "--show-toplevel"], cwd);
+    if (rootResult.exit_code !== 0) {
+      editor.clearFileExplorerDecorations(NAMESPACE);
+      return;
+    }
+    const repoRoot = rootResult.stdout.trim();
+    if (!repoRoot) {
+      editor.clearFileExplorerDecorations(NAMESPACE);
+      return;
+    }
+
+    const statusResult = await editor.spawnProcess(
+      "git",
+      ["status", "--porcelain"],
+      repoRoot
+    );
+    if (statusResult.exit_code !== 0) {
+      editor.clearFileExplorerDecorations(NAMESPACE);
+      return;
+    }
+
+    const decorations = parseStatusOutput(statusResult.stdout, repoRoot);
+    if (decorations.length === 0) {
+      editor.clearFileExplorerDecorations(NAMESPACE);
+    } else {
+      editor.setFileExplorerDecorations(NAMESPACE, decorations);
+    }
+  } catch (_err) {
+    editor.clearFileExplorerDecorations(NAMESPACE);
+  } finally {
+    refreshInFlight = false;
+  }
+}
+
+globalThis.onGitExplorerAfterFileOpen = () => {
+  refreshGitExplorerDecorations();
+};
+
+globalThis.onGitExplorerAfterFileSave = () => {
+  refreshGitExplorerDecorations();
+};
+
+globalThis.onGitExplorerEditorInitialized = () => {
+  refreshGitExplorerDecorations();
+};
+
+editor.on("after_file_open", "onGitExplorerAfterFileOpen");
+editor.on("after_file_save", "onGitExplorerAfterFileSave");
+editor.on("editor_initialized", "onGitExplorerEditorInitialized");
+
+refreshGitExplorerDecorations();

package/plugins/git_find_file.ts

@@ -1,287 +1,65 @@
-/// <reference path="../types/fresh.d.ts" />
-const editor = getEditor();
-
+/// <reference path="./lib/fresh.d.ts" />
 
 /**
  * Git Find File Plugin
  *
  * Provides interactive file finding functionality with fuzzy search
- * for git-tracked files. Uses the prompt API for interactive selection.
+ * for git-tracked files. Uses the Finder abstraction with filter mode.
  */
 
-// State management
-let allFiles: string[] = [];
-let filteredFiles: string[] = [];
-let isLoading = false;
-
-// Simple fuzzy filter function
-function fuzzyMatch(str: string, pattern: string): boolean {
-  if (pattern === "") {
-    return true;
-  }
-
-  str = str.toLowerCase();
-  pattern = pattern.toLowerCase();
-
-  let strIdx = 0;
-  let patIdx = 0;
-
-  while (strIdx < str.length && patIdx < pattern.length) {
-    if (str[strIdx] === pattern[patIdx]) {
-      patIdx++;
-    }
-    strIdx++;
-  }
-
-  return patIdx >= pattern.length;
-}
-
-// Score a fuzzy match (higher is better)
-function fuzzyScore(str: string, pattern: string): number {
-  if (pattern === "") return 0;
-
-  str = str.toLowerCase();
-  pattern = pattern.toLowerCase();
-
-  let score = 0;
-  let strIdx = 0;
-  let patIdx = 0;
-  let consecutiveMatches = 0;
-  let lastMatchIdx = -1;
-
-  while (strIdx < str.length && patIdx < pattern.length) {
-    if (str[strIdx] === pattern[patIdx]) {
-      // Bonus for consecutive matches
-      if (lastMatchIdx === strIdx - 1) {
-        consecutiveMatches++;
-        score += consecutiveMatches * 10;
-      } else {
-        consecutiveMatches = 1;
-        score += 1;
-      }
-
-      // Bonus for matching at start of path segments
-      if (strIdx === 0 || str[strIdx - 1] === "/" || str[strIdx - 1] === "_" || str[strIdx - 1] === "-") {
-        score += 15;
-      }
+import { Finder } from "./lib/finder.ts";
 
-      // Bonus for matching filename (after last /)
-      const lastSlash = str.lastIndexOf("/");
-      if (strIdx > lastSlash) {
-        score += 5;
-      }
-
-      lastMatchIdx = strIdx;
-      patIdx++;
-    }
-    strIdx++;
-  }
-
-  // Penalty for longer paths
-  score -= str.length * 0.1;
-
-  return patIdx >= pattern.length ? score : -1;
-}
-
-// Filter and sort files by query using fuzzy matching
-function filterFiles(files: string[], query: string): string[] {
-  if (query === "" || query.trim() === "") {
-    // Return first 100 files for empty query
-    return files.slice(0, 100);
-  }
-
-  const scored: Array<{ file: string; score: number }> = [];
-
-  for (const file of files) {
-    const score = fuzzyScore(file, query);
-    if (score > 0) {
-      scored.push({ file, score });
-    }
-
-    // Stop early if we have enough high-quality matches
-    if (scored.length >= 500) {
-      break;
-    }
-  }
-
-  // Sort by score descending
-  scored.sort((a, b) => b.score - a.score);
-
-  // Return top 100 results
-  return scored.slice(0, 100).map((s) => s.file);
-}
-
-// Load git-tracked files asynchronously
-async function loadGitFiles(): Promise<void> {
-  if (isLoading) {
-    return;
-  }
-
-  isLoading = true;
-  editor.setStatus(editor.t("status.loading"));
-
-  try {
-    const result = await editor.spawnProcess("git", ["ls-files"]);
-
-    if (result.exit_code === 0) {
-      allFiles = result.stdout.split("\n").filter((line) => line.trim() !== "");
+const editor = getEditor();
 
-      editor.debug(`Loaded ${allFiles.length} git-tracked files`);
-      editor.setStatus(editor.t("status.indexed", { count: String(allFiles.length) }));
-    } else {
-      editor.debug(`Failed to load git files: ${result.stderr}`);
-      editor.setStatus(editor.t("status.error_loading", { error: result.stderr }));
-      allFiles = [];
-    }
-  } catch (e) {
-    editor.debug(`Exception loading git files: ${e}`);
-    editor.setStatus(editor.t("status.failed_load"));
-    allFiles = [];
-  } finally {
-    isLoading = false;
+// Create the finder instance with filter mode
+const finder = new Finder<string>(editor, {
+  id: "git-find-file",
+  format: (file) => ({
+    label: file,
+    location: { file, line: 1, column: 1 },
+  }),
+  preview: false, // No preview for file finder
+  maxResults: 100,
+});
+
+// Load git-tracked files
+async function loadGitFiles(): Promise<string[]> {
+  const result = await editor.spawnProcess("git", ["ls-files"]);
+
+  if (result.exit_code === 0) {
+    return result.stdout.split("\n").filter((line) => line.trim() !== "");
   }
-}
 
-// Convert filtered files to prompt suggestions
-function filesToSuggestions(files: string[]): PromptSuggestion[] {
-  return files.map((file) => {
-    return {
-      text: file,
-      description: undefined,
-      value: file,
-      disabled: false,
-    };
-  });
+  editor.debug(`Failed to load git files: ${result.stderr}`);
+  return [];
 }
 
 // Global function to start file finder
-globalThis.start_git_find_file = async function (): Promise<void> {
-  // Load files if not already loaded
-  if (allFiles.length === 0 && !isLoading) {
-    await loadGitFiles();
-  }
-
-  if (allFiles.length === 0) {
-    editor.setStatus(editor.t("status.no_files"));
-    return;
-  }
-
-  // Clear previous results
-  filteredFiles = [];
-
-  // Start the prompt
-  editor.startPrompt(editor.t("prompt.find_file"), "git-find-file");
-
-  // Show initial suggestions (first 100 files)
-  const initial = filterFiles(allFiles, "");
-  filteredFiles = initial;
-  editor.setPromptSuggestions(filesToSuggestions(initial));
-  editor.setStatus(editor.t("status.files_available", { count: String(allFiles.length) }));
-};
-
-// React to prompt input changes
-globalThis.onGitFindFilePromptChanged = function (args: { prompt_type: string; input: string }): boolean {
-  if (args.prompt_type !== "git-find-file") {
-    return true; // Not our prompt
-  }
-
-  const query = args.input;
-
-  // Filter files based on query
-  const matches = filterFiles(allFiles, query);
-  filteredFiles = matches;
-
-  // Update suggestions
-  editor.setPromptSuggestions(filesToSuggestions(matches));
-
-  // Update status
-  if (matches.length > 0) {
-    if (query.trim() === "") {
-      editor.setStatus(editor.t("status.showing_first", { shown: String(matches.length), total: String(allFiles.length) }));
-    } else {
-      editor.setStatus(editor.t("status.found_matching", { count: String(matches.length), query }));
-    }
-  } else {
-    editor.setStatus(editor.t("status.no_matching", { query }));
-  }
-
-  return true;
-};
-
-// Handle prompt confirmation (user pressed Enter)
-globalThis.onGitFindFilePromptConfirmed = function (args: {
-  prompt_type: string;
-  selected_index: number | null;
-  input: string;
-}): boolean {
-  if (args.prompt_type !== "git-find-file") {
-    return true; // Not our prompt
-  }
-
-  editor.debug(`git-find-file confirmed: selected_index=${args.selected_index}, input=${args.input}`);
-
-  // Check if user selected a suggestion
-  if (args.selected_index !== null && filteredFiles[args.selected_index]) {
-    const selectedFile = filteredFiles[args.selected_index];
-
-    editor.debug(`Opening file: ${selectedFile}`);
-
-    // Open the file at line 1
-    editor.openFile(selectedFile, 1, 1);
-    editor.setStatus(editor.t("status.opened", { file: selectedFile }));
-  } else if (args.input.trim() !== "") {
-    // Try to open input directly if it's a valid file path
-    const inputFile = args.input.trim();
-
-    // Check if the exact input matches any file
-    if (allFiles.includes(inputFile)) {
-      editor.openFile(inputFile, 1, 1);
-      editor.setStatus(editor.t("status.opened", { file: inputFile }));
-    } else {
-      editor.setStatus(editor.t("status.file_not_found", { file: inputFile }));
-    }
-  } else {
-    editor.setStatus(editor.t("status.no_selection"));
-  }
-
-  return true;
-};
-
-// Handle prompt cancellation (user pressed Escape)
-globalThis.onGitFindFilePromptCancelled = function (args: { prompt_type: string }): boolean {
-  if (args.prompt_type !== "git-find-file") {
-    return true; // Not our prompt
-  }
-
-  // Clear results
-  filteredFiles = [];
-  editor.setStatus(editor.t("status.cancelled"));
-
-  return true;
+globalThis.start_git_find_file = function (): void {
+  finder.prompt({
+    title: editor.t("prompt.find_file"),
+    source: {
+      mode: "filter",
+      load: loadGitFiles,
+      // Uses built-in fuzzy filter by default
+    },
+  });
 };
 
-// Register event handlers
-editor.on("prompt_changed", "onGitFindFilePromptChanged");
-editor.on("prompt_confirmed", "onGitFindFilePromptConfirmed");
-editor.on("prompt_cancelled", "onGitFindFilePromptCancelled");
-
 // Reload git files command
 globalThis.git_reload_files = async function (): Promise<void> {
-  allFiles = [];
-  await loadGitFiles();
-};
-
-// Show file count command
-globalThis.git_file_count = function (): void {
-  if (allFiles.length === 0) {
-    editor.setStatus(editor.t("status.no_files_loaded"));
-  } else {
-    editor.setStatus(editor.t("status.indexed", { count: String(allFiles.length) }));
-  }
+  // Just re-trigger the prompt which will reload
+  globalThis.start_git_find_file();
+  editor.setStatus(editor.t("status.reloading"));
 };
 
 // Register commands
-editor.registerCommand("%cmd.find", "%cmd.find_desc", "start_git_find_file", "normal");
+editor.registerCommand(
+  "%cmd.find",
+  "%cmd.find_desc",
+  "start_git_find_file",
+  "normal"
+);
 
 editor.registerCommand(
   "%cmd.reload",
@@ -290,11 +68,5 @@ editor.registerCommand(
   "normal"
 );
 
-editor.registerCommand("%cmd.count", "%cmd.count_desc", "git_file_count", "normal");
-
-// Note: We don't load git files on plugin init because spawning processes requires async context
-// Files will be loaded lazily on first use
-
-editor.debug("Git Find File plugin loaded successfully (TypeScript)");
-editor.debug("Usage: Call start_git_find_file() or use command palette 'Git Find File'");
+editor.debug("Git Find File plugin loaded (using Finder abstraction)");
 editor.setStatus(editor.t("status.ready"));