@fastino-ai/pioneer-cli 0.1.0 → 0.2.0

package/src/agent/FileResolver.ts

@@ -0,0 +1,321 @@
+/**
+ * FileResolver - Parse and resolve @file references in messages
+ * Similar to Claude Code's @ mention functionality
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+
+export interface FileReference {
+  original: string; // The original @path text
+  path: string; // Resolved absolute path
+  relativePath: string; // Path as typed by user
+  exists: boolean;
+  isDirectory: boolean;
+  content?: string;
+  error?: string;
+}
+
+export interface ResolvedMessage {
+  originalMessage: string;
+  cleanMessage: string; // Message with @refs replaced by placeholders
+  references: FileReference[];
+  contextBlock: string; // Formatted context to prepend to message
+}
+
+const MAX_FILE_SIZE = 1024 * 1024; // 1MB max per file
+const MAX_TOTAL_SIZE = 5 * 1024 * 1024; // 5MB total max
+const MAX_DIRECTORY_FILES = 50; // Max files to include from a directory
+
+export class FileResolver {
+  private basePath: string;
+
+  constructor(basePath: string = process.cwd()) {
+    this.basePath = basePath;
+  }
+
+  setBasePath(basePath: string): void {
+    this.basePath = basePath;
+  }
+
+  /**
+   * Parse a message and resolve all @file references
+   */
+  resolve(message: string): ResolvedMessage {
+    const references: FileReference[] = [];
+
+    // Match @path patterns - supports paths with extensions, slashes, etc.
+    // Matches: @file.ts, @src/file.ts, @./relative/path, @../parent/path
+    // Stops at whitespace, quotes, or common punctuation
+    const atPattern = /@((?:\.\.?\/)?[\w\-./]+(?:\.\w+)?)/g;
+
+    let match;
+    const foundPaths = new Set<string>();
+
+    while ((match = atPattern.exec(message)) !== null) {
+      const relativePath = match[1];
+
+      // Skip if we've already processed this path
+      if (foundPaths.has(relativePath)) continue;
+      foundPaths.add(relativePath);
+
+      const ref = this.resolveReference(relativePath, match[0]);
+      references.push(ref);
+    }
+
+    // Build context block from resolved files
+    const contextBlock = this.buildContextBlock(references);
+
+    // Create clean message (optionally replace @refs with indicators)
+    let cleanMessage = message;
+    for (const ref of references) {
+      if (ref.exists) {
+        // Keep the @reference in the message so the LLM knows what was referenced
+        // but the actual content is in the context block
+      }
+    }
+
+    return {
+      originalMessage: message,
+      cleanMessage,
+      references,
+      contextBlock,
+    };
+  }
+
+  private resolveReference(relativePath: string, original: string): FileReference {
+    // Resolve to absolute path
+    const absolutePath = path.isAbsolute(relativePath)
+      ? relativePath
+      : path.resolve(this.basePath, relativePath);
+
+    const ref: FileReference = {
+      original,
+      path: absolutePath,
+      relativePath,
+      exists: false,
+      isDirectory: false,
+    };
+
+    try {
+      if (!fs.existsSync(absolutePath)) {
+        ref.error = "File or directory not found";
+        return ref;
+      }
+
+      const stats = fs.statSync(absolutePath);
+      ref.exists = true;
+      ref.isDirectory = stats.isDirectory();
+
+      if (ref.isDirectory) {
+        ref.content = this.readDirectory(absolutePath);
+      } else {
+        if (stats.size > MAX_FILE_SIZE) {
+          ref.error = `File too large (${(stats.size / 1024).toFixed(1)}KB > ${MAX_FILE_SIZE / 1024}KB limit)`;
+          return ref;
+        }
+        ref.content = this.readFile(absolutePath);
+      }
+    } catch (err) {
+      ref.error = err instanceof Error ? err.message : String(err);
+    }
+
+    return ref;
+  }
+
+  private readFile(filePath: string): string {
+    try {
+      return fs.readFileSync(filePath, "utf-8");
+    } catch (err) {
+      throw new Error(`Failed to read file: ${err instanceof Error ? err.message : err}`);
+    }
+  }
+
+  private readDirectory(dirPath: string): string {
+    const entries: string[] = [];
+    const files = this.listDirectoryRecursive(dirPath, "", 0, 3);
+
+    // Build a tree-like structure
+    let output = `Directory: ${dirPath}\n`;
+    output += "```\n";
+    output += files.join("\n");
+    output += "\n```";
+
+    return output;
+  }
+
+  private listDirectoryRecursive(
+    basePath: string,
+    relativePath: string,
+    depth: number,
+    maxDepth: number
+  ): string[] {
+    const results: string[] = [];
+    const fullPath = path.join(basePath, relativePath);
+
+    try {
+      const entries = fs.readdirSync(fullPath, { withFileTypes: true });
+
+      // Sort: directories first, then files
+      entries.sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory()) return -1;
+        if (!a.isDirectory() && b.isDirectory()) return 1;
+        return a.name.localeCompare(b.name);
+      });
+
+      for (const entry of entries) {
+        // Skip hidden files and common ignored directories
+        if (entry.name.startsWith(".")) continue;
+        if (["node_modules", "__pycache__", "dist", "build", ".git"].includes(entry.name)) continue;
+
+        const indent = "  ".repeat(depth);
+        const entryRelPath = path.join(relativePath, entry.name);
+
+        if (entry.isDirectory()) {
+          results.push(`${indent}${entry.name}/`);
+          if (depth < maxDepth) {
+            results.push(...this.listDirectoryRecursive(basePath, entryRelPath, depth + 1, maxDepth));
+          }
+        } else {
+          results.push(`${indent}${entry.name}`);
+        }
+
+        if (results.length >= MAX_DIRECTORY_FILES) {
+          results.push(`${indent}... (truncated)`);
+          break;
+        }
+      }
+    } catch {
+      // Skip inaccessible directories
+    }
+
+    return results;
+  }
+
+  private buildContextBlock(references: FileReference[]): string {
+    if (references.length === 0) return "";
+
+    const successfulRefs = references.filter((r) => r.exists && r.content);
+    if (successfulRefs.length === 0) return "";
+
+    let totalSize = 0;
+    const blocks: string[] = [];
+
+    blocks.push("<referenced_files>");
+
+    for (const ref of successfulRefs) {
+      if (!ref.content) continue;
+
+      // Check total size limit
+      if (totalSize + ref.content.length > MAX_TOTAL_SIZE) {
+        blocks.push(`\n<!-- Skipped ${ref.relativePath}: would exceed total size limit -->`);
+        continue;
+      }
+
+      totalSize += ref.content.length;
+
+      if (ref.isDirectory) {
+        blocks.push(`\n<directory path="${ref.relativePath}">`);
+        blocks.push(ref.content);
+        blocks.push("</directory>");
+      } else {
+        const ext = path.extname(ref.relativePath).slice(1) || "txt";
+        blocks.push(`\n<file path="${ref.relativePath}">`);
+        blocks.push("```" + ext);
+        blocks.push(ref.content);
+        blocks.push("```");
+        blocks.push("</file>");
+      }
+    }
+
+    blocks.push("\n</referenced_files>\n");
+
+    // Add any errors
+    const errors = references.filter((r) => r.error);
+    if (errors.length > 0) {
+      blocks.push("\n<!-- File reference errors:");
+      for (const err of errors) {
+        blocks.push(`  ${err.original}: ${err.error}`);
+      }
+      blocks.push("-->\n");
+    }
+
+    return blocks.join("\n");
+  }
+
+  /**
+   * Get file suggestions for autocomplete
+   * Handles: "" (list cwd), "src/" (list src dir), "src/a" (filter by prefix)
+   */
+  getSuggestions(partial: string, limit = 15): string[] {
+    const suggestions: string[] = [];
+
+    let searchDir: string;
+    let prefix: string;
+    let dirPrefix: string;
+
+    if (!partial || partial === "") {
+      // Empty: list current directory
+      searchDir = this.basePath;
+      prefix = "";
+      dirPrefix = "";
+    } else if (partial.endsWith("/")) {
+      // Ends with /: list that directory
+      searchDir = path.resolve(this.basePath, partial);
+      prefix = "";
+      dirPrefix = partial;
+    } else if (partial.includes("/")) {
+      // Has / but doesn't end with it: filter in parent dir
+      searchDir = path.resolve(this.basePath, path.dirname(partial));
+      prefix = path.basename(partial).toLowerCase();
+      dirPrefix = path.dirname(partial) + "/";
+    } else {
+      // No slash: filter in current dir
+      searchDir = this.basePath;
+      prefix = partial.toLowerCase();
+      dirPrefix = "";
+    }
+
+    try {
+      if (!fs.existsSync(searchDir) || !fs.statSync(searchDir).isDirectory()) {
+        return [];
+      }
+
+      const entries = fs.readdirSync(searchDir, { withFileTypes: true });
+
+      // Sort: directories first, then alphabetically
+      entries.sort((a, b) => {
+        if (a.isDirectory() && !b.isDirectory()) return -1;
+        if (!a.isDirectory() && b.isDirectory()) return 1;
+        return a.name.localeCompare(b.name);
+      });
+
+      for (const entry of entries) {
+        if (entry.name.startsWith(".")) continue;
+        if (["node_modules", "__pycache__", "dist", "build", ".git", "venv"].includes(entry.name)) continue;
+
+        if (!prefix || entry.name.toLowerCase().startsWith(prefix)) {
+          const relativePath = dirPrefix + entry.name;
+          suggestions.push(entry.isDirectory() ? `${relativePath}/` : relativePath);
+        }
+
+        if (suggestions.length >= limit) break;
+      }
+    } catch {
+      // Ignore errors
+    }
+
+    return suggestions;
+  }
+}
+
+// Singleton for easy access
+let defaultResolver: FileResolver | null = null;
+
+export function getFileResolver(basePath?: string): FileResolver {
+  if (!defaultResolver || basePath) {
+    defaultResolver = new FileResolver(basePath);
+  }
+  return defaultResolver;
+}
+