@fresh-editor/fresh-editor 0.1.4

package/plugins/git_find_file.ts

@@ -0,0 +1,298 @@
+/// <reference path="../types/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.
+ */
+
+// 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;
+      }
+
+      // 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("Loading git files...");
+
+  try {
+    const result = await editor.spawnProcess("git", ["ls-files"]);
+
+    if (result.exit_code === 0) {
+      allFiles = result.stdout.split("\n").filter((line) => line.trim() !== "");
+
+      editor.debug(`Loaded ${allFiles.length} git-tracked files`);
+      editor.setStatus(`Git Find File: ${allFiles.length} files indexed`);
+    } else {
+      editor.debug(`Failed to load git files: ${result.stderr}`);
+      editor.setStatus(`Error loading git files: ${result.stderr}`);
+      allFiles = [];
+    }
+  } catch (e) {
+    editor.debug(`Exception loading git files: ${e}`);
+    editor.setStatus("Failed to load git files");
+    allFiles = [];
+  } finally {
+    isLoading = false;
+  }
+}
+
+// Convert filtered files to prompt suggestions
+function filesToSuggestions(files: string[]): PromptSuggestion[] {
+  return files.map((file) => {
+    return {
+      text: file,
+      description: undefined,
+      value: file,
+      disabled: false,
+    };
+  });
+}
+
+// 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("No git-tracked files found");
+    return;
+  }
+
+  // Clear previous results
+  filteredFiles = [];
+
+  // Start the prompt
+  editor.startPrompt("Find file: ", "git-find-file");
+
+  // Show initial suggestions (first 100 files)
+  const initial = filterFiles(allFiles, "");
+  filteredFiles = initial;
+  editor.setPromptSuggestions(filesToSuggestions(initial));
+  editor.setStatus(`${allFiles.length} files available - type to filter`);
+};
+
+// 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(`Showing first ${matches.length} of ${allFiles.length} files`);
+    } else {
+      editor.setStatus(`Found ${matches.length} files matching "${query}"`);
+    }
+  } else {
+    editor.setStatus(`No files 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(`Opened ${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(`Opened ${inputFile}`);
+    } else {
+      editor.setStatus(`File not found: ${inputFile}`);
+    }
+  } else {
+    editor.setStatus("No file selected");
+  }
+
+  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("File finder cancelled");
+
+  return true;
+};
+
+// 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("No git files loaded. Use 'Git Find File: Reload' to index files.");
+  } else {
+    editor.setStatus(`${allFiles.length} git-tracked files indexed`);
+  }
+};
+
+// Register commands
+editor.registerCommand("Git Find File", "Find and open a git-tracked file", "start_git_find_file", "normal");
+
+editor.registerCommand(
+  "Git Find File: Reload",
+  "Reload the git file index",
+  "git_reload_files",
+  "normal"
+);
+
+editor.registerCommand("Git Find File: Count", "Show number of indexed git files", "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.setStatus("Git Find File plugin ready");

package/plugins/git_grep.ts

@@ -0,0 +1,188 @@
+/// <reference path="../types/fresh.d.ts" />
+
+/**
+ * Git Grep Plugin
+ *
+ * Provides interactive git grep functionality with live search results.
+ */
+
+interface GrepMatch {
+  file: string;
+  line: number;
+  column: number;
+  content: string;
+}
+
+// State management
+let gitGrepResults: GrepMatch[] = [];
+
+// Parse git grep output line
+// Format: file:line:column:content
+function parseGitGrepLine(line: string): GrepMatch | null {
+  const match = line.match(/^([^:]+):(\d+):(\d+):(.*)$/);
+  if (match) {
+    return {
+      file: match[1],
+      line: parseInt(match[2], 10),
+      column: parseInt(match[3], 10),
+      content: match[4].trimStart(),
+    };
+  }
+  return null;
+}
+
+// Parse git grep output into suggestions
+function parseGitGrepOutput(stdout: string): {
+  results: GrepMatch[];
+  suggestions: PromptSuggestion[];
+} {
+  const results: GrepMatch[] = [];
+  const suggestions: PromptSuggestion[] = [];
+
+  for (const line of stdout.split("\n")) {
+    if (!line.trim()) continue;
+    const match = parseGitGrepLine(line);
+    if (match) {
+      results.push(match);
+      suggestions.push({
+        text: `${match.file}:${match.line}:${match.column}`,
+        description: match.content,
+        value: `${match.file}:${match.line}:${match.column}`,
+        disabled: false,
+      });
+
+      // Limit to 100 results for performance
+      if (results.length >= 100) {
+        break;
+      }
+    }
+  }
+
+  return { results, suggestions };
+}
+
+// Global function to start git grep
+globalThis.start_git_grep = function(): void {
+  // Clear previous results
+  gitGrepResults = [];
+
+  // Start the prompt
+  editor.startPrompt("Git grep: ", "git-grep");
+  editor.setStatus("Type to search...");
+};
+
+// React to prompt input changes
+globalThis.onGitGrepPromptChanged = function(args: {
+  prompt_type: string;
+  input: string;
+}): boolean {
+  if (args.prompt_type !== "git-grep") {
+    return true; // Not our prompt
+  }
+
+  const query = args.input;
+
+  // Don't search for empty queries
+  if (!query || query.trim() === "") {
+    editor.setPromptSuggestions([]);
+    return true;
+  }
+
+  // Spawn git grep asynchronously
+  editor.spawnProcess("git", ["grep", "-n", "--column", "-I", "--", query])
+    .then((result) => {
+      if (result.exit_code === 0) {
+        // Parse results and update suggestions
+        const { results, suggestions } = parseGitGrepOutput(result.stdout);
+        gitGrepResults = results;
+
+        // Update prompt with suggestions
+        editor.setPromptSuggestions(suggestions);
+
+        // Update status
+        if (results.length > 0) {
+          editor.setStatus(`Found ${results.length} matches`);
+        } else {
+          editor.setStatus("No matches found");
+        }
+      } else if (result.exit_code === 1) {
+        // No matches found (git grep returns 1)
+        gitGrepResults = [];
+        editor.setPromptSuggestions([]);
+        editor.setStatus("No matches found");
+      } else {
+        // Error occurred
+        editor.setStatus(`Git grep error: ${result.stderr}`);
+      }
+    })
+    .catch((e) => {
+      editor.setStatus(`Git grep error: ${e}`);
+    });
+
+  return true;
+};
+
+// Handle prompt confirmation (user pressed Enter)
+globalThis.onGitGrepPromptConfirmed = function(args: {
+  prompt_type: string;
+  selected_index: number | null;
+  input: string;
+}): boolean {
+  if (args.prompt_type !== "git-grep") {
+    return true; // Not our prompt
+  }
+
+  editor.debug(
+    `prompt-confirmed: selected_index=${args.selected_index}, num_results=${gitGrepResults.length}`
+  );
+
+  // Check if user selected a suggestion
+  if (args.selected_index !== null && gitGrepResults[args.selected_index]) {
+    const selected = gitGrepResults[args.selected_index];
+
+    editor.debug(`Opening file: ${selected.file}:${selected.line}:${selected.column}`);
+
+    // Open the file at the specific location
+    editor.openFile(selected.file, selected.line, selected.column);
+    editor.setStatus(`Opened ${selected.file}:${selected.line}:${selected.column}`);
+  } else {
+    // No selection
+    editor.debug("No file selected - selected_index is null or out of bounds");
+    editor.setStatus("No file selected");
+  }
+
+  return true;
+};
+
+// Handle prompt cancellation (user pressed Escape)
+globalThis.onGitGrepPromptCancelled = function(args: {
+  prompt_type: string;
+}): boolean {
+  if (args.prompt_type !== "git-grep") {
+    return true; // Not our prompt
+  }
+
+  // Clear results
+  gitGrepResults = [];
+  editor.setStatus("Git grep cancelled");
+
+  return true;
+};
+
+// Register event handlers
+editor.on("prompt_changed", "onGitGrepPromptChanged");
+editor.on("prompt_confirmed", "onGitGrepPromptConfirmed");
+editor.on("prompt_cancelled", "onGitGrepPromptCancelled");
+
+// Register command
+editor.registerCommand(
+  "Git Grep",
+  "Search for text in git-tracked files",
+  "start_git_grep",
+  "normal"
+);
+
+// Log that plugin loaded successfully
+editor.debug("Git Grep plugin loaded successfully (TypeScript)");
+editor.debug("Usage: Call start_git_grep() or use command palette 'Git Grep'");
+editor.setStatus("Git Grep plugin ready");