@fastino-ai/pioneer-cli 0.1.0 → 0.2.1

package/src/agent/BudgetManager.ts

@@ -0,0 +1,167 @@
+/**
+ * Budget Manager - Track and enforce token/time/cost budgets
+ */
+
+import type { Budget, BudgetUsage, TokenUsage } from "./types.js";
+
+export interface BudgetCheckResult {
+  withinBudget: boolean;
+  warnings: string[];
+  tokensRemaining?: number;
+  costRemaining?: number;
+  timeRemaining?: number;
+  iterationsRemaining?: number;
+}
+
+export class BudgetManager {
+  private budget: Budget;
+  private usage: BudgetUsage;
+  private startTime: number;
+  private costPerMillion: { input: number; output: number };
+
+  constructor(budget: Budget = {}, costPerMillion = { input: 3, output: 15 }) {
+    this.budget = budget;
+    this.costPerMillion = costPerMillion;
+    this.usage = {
+      tokensUsed: 0,
+      costUsed: 0,
+      timeUsed: 0,
+      iterationsUsed: 0,
+    };
+    this.startTime = Date.now();
+  }
+
+  recordUsage(tokenUsage: TokenUsage): void {
+    this.usage.tokensUsed += tokenUsage.totalTokens;
+    this.usage.costUsed +=
+      (tokenUsage.inputTokens * this.costPerMillion.input +
+        tokenUsage.outputTokens * this.costPerMillion.output) /
+      1_000_000;
+    this.usage.timeUsed = (Date.now() - this.startTime) / 1000;
+  }
+
+  recordIteration(): void {
+    this.usage.iterationsUsed += 1;
+  }
+
+  checkBudget(): BudgetCheckResult {
+    const warnings: string[] = [];
+    let withinBudget = true;
+
+    // Update time
+    this.usage.timeUsed = (Date.now() - this.startTime) / 1000;
+
+    // Check tokens
+    if (this.budget.maxTokens !== undefined) {
+      const tokensRemaining = this.budget.maxTokens - this.usage.tokensUsed;
+      if (tokensRemaining <= 0) {
+        withinBudget = false;
+        warnings.push(`Token budget exhausted (${this.usage.tokensUsed}/${this.budget.maxTokens})`);
+      } else if (tokensRemaining < this.budget.maxTokens * 0.1) {
+        warnings.push(`Low token budget: ${tokensRemaining} remaining`);
+      }
+    }
+
+    // Check cost
+    if (this.budget.maxCost !== undefined) {
+      const costRemaining = this.budget.maxCost - this.usage.costUsed;
+      if (costRemaining <= 0) {
+        withinBudget = false;
+        warnings.push(`Cost budget exhausted ($${this.usage.costUsed.toFixed(4)}/$${this.budget.maxCost})`);
+      } else if (costRemaining < this.budget.maxCost * 0.1) {
+        warnings.push(`Low cost budget: $${costRemaining.toFixed(4)} remaining`);
+      }
+    }
+
+    // Check time
+    if (this.budget.maxTime !== undefined) {
+      const timeRemaining = this.budget.maxTime - this.usage.timeUsed;
+      if (timeRemaining <= 0) {
+        withinBudget = false;
+        warnings.push(`Time budget exhausted (${this.usage.timeUsed.toFixed(0)}s/${this.budget.maxTime}s)`);
+      } else if (timeRemaining < this.budget.maxTime * 0.1) {
+        warnings.push(`Low time budget: ${timeRemaining.toFixed(0)}s remaining`);
+      }
+    }
+
+    // Check iterations
+    if (this.budget.maxIterations !== undefined) {
+      const iterationsRemaining = this.budget.maxIterations - this.usage.iterationsUsed;
+      if (iterationsRemaining <= 0) {
+        withinBudget = false;
+        warnings.push(`Iteration limit reached (${this.usage.iterationsUsed}/${this.budget.maxIterations})`);
+      }
+    }
+
+    return {
+      withinBudget,
+      warnings,
+      tokensRemaining: this.budget.maxTokens
+        ? Math.max(0, this.budget.maxTokens - this.usage.tokensUsed)
+        : undefined,
+      costRemaining: this.budget.maxCost
+        ? Math.max(0, this.budget.maxCost - this.usage.costUsed)
+        : undefined,
+      timeRemaining: this.budget.maxTime
+        ? Math.max(0, this.budget.maxTime - this.usage.timeUsed)
+        : undefined,
+      iterationsRemaining: this.budget.maxIterations
+        ? Math.max(0, this.budget.maxIterations - this.usage.iterationsUsed)
+        : undefined,
+    };
+  }
+
+  getUsage(): BudgetUsage {
+    this.usage.timeUsed = (Date.now() - this.startTime) / 1000;
+    return { ...this.usage };
+  }
+
+  getBudget(): Budget {
+    return { ...this.budget };
+  }
+
+  formatUsageSummary(): string {
+    const usage = this.getUsage();
+    const parts: string[] = [];
+
+    parts.push(`Tokens: ${usage.tokensUsed.toLocaleString()}`);
+    if (this.budget.maxTokens) {
+      parts[parts.length - 1] += `/${this.budget.maxTokens.toLocaleString()}`;
+    }
+
+    parts.push(`Cost: $${usage.costUsed.toFixed(4)}`);
+    if (this.budget.maxCost) {
+      parts[parts.length - 1] += `/$${this.budget.maxCost.toFixed(2)}`;
+    }
+
+    parts.push(`Time: ${usage.timeUsed.toFixed(1)}s`);
+    if (this.budget.maxTime) {
+      parts[parts.length - 1] += `/${this.budget.maxTime}s`;
+    }
+
+    if (this.budget.maxIterations) {
+      parts.push(`Iterations: ${usage.iterationsUsed}/${this.budget.maxIterations}`);
+    }
+
+    return parts.join(" | ");
+  }
+
+  reset(): void {
+    this.usage = {
+      tokensUsed: 0,
+      costUsed: 0,
+      timeUsed: 0,
+      iterationsUsed: 0,
+    };
+    this.startTime = Date.now();
+  }
+
+  updateBudget(budget: Partial<Budget>): void {
+    this.budget = { ...this.budget, ...budget };
+  }
+
+  setCostPerMillion(costs: { input: number; output: number }): void {
+    this.costPerMillion = costs;
+  }
+}
+

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;
+}
+