@console-agent/agent 1.2.0 → 1.2.2

package/dist/index.js

@@ -1,8 +1,17 @@
 import { createGoogleGenerativeAI } from '@ai-sdk/google';
 import { jsonSchema, generateText, stepCountIs, Output, ToolLoopAgent } from 'ai';
+import { existsSync, readFileSync } from 'fs';
+import { extname, resolve, basename } from 'path';
 import chalk from 'chalk';
 import ora from 'ora';
 
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/personas/debugger.ts
 var debuggerPersona = {
   name: "debugger",
@@ -204,6 +213,16 @@ function getPersona(name) {
   return personas[name];
 }
 
+// src/tools/file-analysis.ts
+function prepareFileContent(fileData, mimeType) {
+  const base64 = Buffer.from(fileData).toString("base64");
+  return {
+    type: "file",
+    data: base64,
+    mimeType
+  };
+}
+
 // src/tools/index.ts
 var TOOLS_MIN_TIMEOUT = 3e4;
 function resolveTools(tools, google) {
@@ -228,6 +247,144 @@ function resolveTools(tools, google) {
 function hasExplicitTools(options) {
   return !!(options?.tools && options.tools.length > 0);
 }
+var MAX_FILE_SIZE = 100 * 1024;
+var SOURCE_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".rb",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".c",
+  ".cpp",
+  ".h",
+  ".hpp",
+  ".cs",
+  ".swift",
+  ".vue",
+  ".svelte",
+  ".astro",
+  ".json",
+  ".yaml",
+  ".yml",
+  ".toml",
+  ".env",
+  ".sql",
+  ".graphql",
+  ".gql",
+  ".md",
+  ".txt",
+  ".html",
+  ".css",
+  ".scss"
+]);
+var INTERNAL_PATTERNS = [
+  "/console-agent/",
+  "/console_agent/",
+  "@console-agent/",
+  "/node_modules/",
+  "node:internal/",
+  "node:async_hooks",
+  "<anonymous>"
+];
+function normalizeFilePath(filePath) {
+  if (filePath.startsWith("file://")) {
+    try {
+      return new URL(filePath).pathname;
+    } catch {
+      return filePath.replace(/^file:\/\//, "");
+    }
+  }
+  return filePath;
+}
+function parseStackFrames(stack) {
+  const frames = [];
+  const lines = stack.split("\n");
+  for (const line of lines) {
+    const match = line.match(/at\s+(?:.*?\s+)?\(?([^()]+):(\d+):(\d+)\)?/);
+    if (match) {
+      frames.push({
+        file: match[1],
+        line: parseInt(match[2], 10),
+        column: parseInt(match[3], 10)
+      });
+    }
+  }
+  return frames;
+}
+function isInternalFrame(filePath) {
+  return INTERNAL_PATTERNS.some((pattern) => filePath.includes(pattern));
+}
+function isSourceFile(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  return SOURCE_EXTENSIONS.has(ext);
+}
+function getCallerFile(skipFrames = 0) {
+  const err = new Error();
+  if (!err.stack) return null;
+  const frames = parseStackFrames(err.stack);
+  for (const frame of frames) {
+    if (isInternalFrame(frame.file)) continue;
+    if (!isSourceFile(frame.file)) continue;
+    return readSourceFile(frame.file, frame.line, frame.column);
+  }
+  return null;
+}
+function getErrorSourceFile(error) {
+  if (!error.stack) return null;
+  const frames = parseStackFrames(error.stack);
+  for (const frame of frames) {
+    if (frame.file.includes("node:internal/") || frame.file.includes("<anonymous>")) continue;
+    if (!isSourceFile(frame.file)) continue;
+    return readSourceFile(frame.file, frame.line, frame.column);
+  }
+  return null;
+}
+function readSourceFile(filePath, line, column) {
+  try {
+    const normalizedPath = normalizeFilePath(filePath);
+    const resolvedPath = resolve(normalizedPath);
+    if (!existsSync(resolvedPath)) return null;
+    const { statSync } = __require("fs");
+    const stats = statSync(resolvedPath);
+    if (stats.size > MAX_FILE_SIZE) {
+      const content2 = readFileSync(resolvedPath, "utf-8").substring(0, MAX_FILE_SIZE);
+      return {
+        filePath: resolvedPath,
+        fileName: basename(resolvedPath),
+        line,
+        column,
+        content: content2 + "\n\n// [TRUNCATED \u2014 file exceeds 100KB limit]"
+      };
+    }
+    const content = readFileSync(resolvedPath, "utf-8");
+    return {
+      filePath: resolvedPath,
+      fileName: basename(resolvedPath),
+      line,
+      column,
+      content
+    };
+  } catch {
+    return null;
+  }
+}
+function formatSourceForContext(source) {
+  const lines = source.content.split("\n");
+  const numbered = lines.map((line, i) => {
+    const lineNum = i + 1;
+    const marker = lineNum === source.line ? " \u2192 " : "   ";
+    return `${marker}${String(lineNum).padStart(4)} | ${line}`;
+  });
+  return `--- Source File: ${source.fileName} (line ${source.line}) ---
+${numbered.join("\n")}`;
+}
 var currentLogLevel = "info";
 function setLogLevel(level) {
   currentLogLevel = level;
@@ -236,8 +393,9 @@ function shouldLog(level) {
   const levels = ["silent", "errors", "info", "debug"];
   return levels.indexOf(currentLogLevel) >= levels.indexOf(level);
 }
-function startSpinner(persona, prompt) {
+function startSpinner(persona, prompt, verbose = false) {
   if (!shouldLog("info")) return null;
+  if (!verbose) return null;
   const truncated = prompt.length > 60 ? prompt.substring(0, 57) + "..." : prompt;
   const spinner = ora({
     text: chalk.cyan(`${persona.icon} ${persona.label}... `) + chalk.dim(truncated),
@@ -253,8 +411,29 @@ function stopSpinner(spinner, success) {
     spinner.fail();
   }
 }
-function formatResult(result, persona) {
+function formatResult(result, persona, verbose = false) {
   if (!shouldLog("info")) return;
+  if (!verbose) {
+    formatResultQuiet(result);
+    return;
+  }
+  formatResultVerbose(result, persona);
+}
+function formatResultQuiet(result) {
+  console.log("");
+  console.log(result.summary);
+  const dataEntries = Object.entries(result.data);
+  const hasMeaningfulData = dataEntries.length > 0 && !(dataEntries.length === 1 && dataEntries[0][0] === "raw");
+  if (hasMeaningfulData) {
+    for (const [key, value] of dataEntries) {
+      if (key === "raw") continue;
+      const displayValue = typeof value === "string" ? value : JSON.stringify(value);
+      console.log(`${chalk.dim(key + ":")} ${displayValue}`);
+    }
+  }
+  console.log("");
+}
+function formatResultVerbose(result, persona) {
   const prefix = chalk.gray("[AGENT]");
   const confidenceColor = result.confidence >= 0.8 ? chalk.green : result.confidence >= 0.5 ? chalk.yellow : chalk.red;
   const statusIcon = result.success ? chalk.green("\u2713") : chalk.red("\u2717");
@@ -284,12 +463,20 @@ function formatResult(result, persona) {
   const confidence = confidenceColor(`confidence: ${result.confidence.toFixed(2)}`);
   const latency = chalk.dim(`${result.metadata.latencyMs}ms`);
   const tokens = chalk.dim(`${result.metadata.tokensUsed} tokens`);
+  const model = chalk.dim(`model: ${result.metadata.model}`);
   const cached = result.metadata.cached ? chalk.green(" (cached)") : "";
-  console.log(`${prefix} \u2514\u2500 ${confidence} | ${latency} | ${tokens}${cached}`);
+  const toolNames = result.metadata.toolCalls.length > 0 ? chalk.dim(` | tools: ${result.metadata.toolCalls.map((t) => t.name).join(", ")}`) : "";
+  console.log(`${prefix} \u2514\u2500 ${confidence} | ${latency} | ${tokens} | ${model}${cached}${toolNames}`);
   console.log("");
 }
-function formatError(error, persona) {
+function formatError(error, persona, verbose = false) {
   if (!shouldLog("errors")) return;
+  if (!verbose) {
+    console.log("");
+    console.log(chalk.red(`Error: ${error.message}`));
+    console.log("");
+    return;
+  }
   const prefix = chalk.gray("[AGENT]");
   console.log("");
   console.log(`${prefix} ${persona.icon} ${chalk.red("Error:")} ${error.message}`);
@@ -298,18 +485,32 @@ function formatError(error, persona) {
   }
   console.log("");
 }
-function formatBudgetWarning(reason) {
+function formatBudgetWarning(reason, verbose = false) {
   if (!shouldLog("errors")) return;
+  if (!verbose) {
+    console.log(chalk.yellow(`Budget limit: ${reason}`));
+    return;
+  }
   const prefix = chalk.gray("[AGENT]");
   console.log(`${prefix} ${chalk.yellow("\u26A0 Budget limit:")} ${reason}`);
 }
-function formatRateLimitWarning() {
+function formatRateLimitWarning(verbose = false) {
   if (!shouldLog("errors")) return;
+  if (!verbose) {
+    console.log(chalk.yellow("Rate limited: Too many calls. Try again later."));
+    return;
+  }
   const prefix = chalk.gray("[AGENT]");
   console.log(`${prefix} ${chalk.yellow("\u26A0 Rate limited:")} Too many calls. Try again later.`);
 }
-function formatDryRun(prompt, persona, context) {
+function formatDryRun(prompt, persona, context, verbose = false) {
   if (!shouldLog("info")) return;
+  if (!verbose) {
+    console.log("");
+    console.log(chalk.magenta("[DRY RUN]") + ` Would execute with ${persona.name} persona`);
+    console.log("");
+    return;
+  }
   const prefix = chalk.gray("[AGENT]");
   console.log("");
   console.log(`${prefix} ${chalk.magenta("DRY RUN")} ${persona.icon} ${persona.label}`);
@@ -357,7 +558,32 @@ var JSON_RESPONSE_INSTRUCTION = `
 IMPORTANT: You MUST respond with ONLY a valid JSON object (no markdown, no code fences, no extra text).
 Use this exact format:
 {"success": true, "summary": "one-line conclusion", "reasoning": "your thought process", "data": {"result": "primary finding"}, "actions": ["tools/steps used"], "confidence": 0.95}`;
-async function callGoogle(prompt, context, persona, config2, options) {
+function buildMessages(prompt, context, sourceFile, files) {
+  const parts = [];
+  parts.push({ type: "text", text: prompt });
+  if (context) {
+    parts.push({ type: "text", text: `
+--- Context ---
+${context}` });
+  }
+  if (sourceFile) {
+    const formatted = formatSourceForContext(sourceFile);
+    parts.push({ type: "text", text: `
+${formatted}` });
+  }
+  if (files && files.length > 0) {
+    for (const file of files) {
+      const prepared = prepareFileContent(file.data, file.mediaType);
+      if (file.fileName) {
+        parts.push({ type: "text", text: `
+--- Attached File: ${file.fileName} ---` });
+      }
+      parts.push(prepared);
+    }
+  }
+  return [{ role: "user", content: parts }];
+}
+async function callGoogle(prompt, context, persona, config2, options, sourceFile, files) {
   const startTime = Date.now();
   const modelName = options?.model ?? config2.model;
   logDebug(`Using model: ${modelName}`);
@@ -381,24 +607,21 @@ async function callGoogle(prompt, context, persona, config2, options) {
   const useTools = hasExplicitTools(options) && !config2.localOnly;
   if (useTools) {
     logDebug("Tools requested \u2014 using generateText path (no structured output)");
-    return callWithTools(prompt, context, persona, config2, options, google, modelName, startTime, providerOptions);
+    return callWithTools(prompt, context, persona, config2, options, google, modelName, startTime, providerOptions, sourceFile, files);
   }
   logDebug("No tools \u2014 using ToolLoopAgent with structured output");
-  return callWithStructuredOutput(prompt, context, persona, config2, options, google, modelName, startTime, providerOptions);
+  return callWithStructuredOutput(prompt, context, persona, config2, options, google, modelName, startTime, providerOptions, sourceFile, files);
 }
-async function callWithTools(prompt, context, persona, config2, options, google, modelName, startTime, providerOptions) {
+async function callWithTools(prompt, context, persona, config2, options, google, modelName, startTime, providerOptions, sourceFile, files) {
   const resolvedTools = resolveTools(options.tools, google);
   const toolNames = Object.keys(resolvedTools);
   logDebug(`Tools enabled: ${toolNames.join(", ")}`);
   const effectiveTimeout = Math.max(config2.timeout, TOOLS_MIN_TIMEOUT);
-  const userMessage = context ? `${prompt}
-
---- Context ---
-${context}` : prompt;
+  const messages = buildMessages(prompt, context, sourceFile, files);
   const result = await generateText({
     model: google(modelName),
     system: persona.systemPrompt + JSON_RESPONSE_INSTRUCTION,
-    prompt: userMessage,
+    messages,
     tools: resolvedTools,
     stopWhen: stepCountIs(5),
     // Allow multi-step: tool invocation → response
@@ -442,11 +665,8 @@ ${context}` : prompt;
     }
   };
 }
-async function callWithStructuredOutput(prompt, context, persona, config2, options, google, modelName, startTime, providerOptions) {
-  const userMessage = context ? `${prompt}
-
---- Context ---
-${context}` : prompt;
+async function callWithStructuredOutput(prompt, context, persona, config2, options, google, modelName, startTime, providerOptions, sourceFile, files) {
+  const messages = buildMessages(prompt, context, sourceFile, files);
   const collectedToolCalls = [];
   const useCustomSchema = !!(options?.schema || options?.responseFormat);
   let outputConfig;
@@ -485,7 +705,7 @@ IMPORTANT: You must respond with structured data matching the requested output s
     }
   });
   const result = await agent.generate({
-    prompt: userMessage,
+    messages,
     timeout: config2.timeout
   });
   const latencyMs = Date.now() - startTime;
@@ -780,7 +1000,9 @@ var DEFAULT_CONFIG = {
   localOnly: false,
   dryRun: false,
   logLevel: "info",
-  safetySettings: []
+  verbose: false,
+  safetySettings: [],
+  includeCallerSource: true
 };
 var config = { ...DEFAULT_CONFIG };
 var rateLimiter = new RateLimiter(config.budget.maxCallsPerDay);
@@ -799,18 +1021,19 @@ function getConfig() {
 async function executeAgent(prompt, context, options) {
   const personaName = options?.persona ?? config.persona;
   const persona = options?.persona ? getPersona(options.persona) : detectPersona(prompt, personaName);
+  const verbose = options?.verbose ?? config.verbose;
   logDebug(`Selected persona: ${persona.name} (${persona.icon})`);
   if (config.dryRun) {
-    formatDryRun(prompt, persona, context);
+    formatDryRun(prompt, persona, context, verbose);
     return createDryRunResult(persona.name);
   }
   if (!rateLimiter.tryConsume()) {
-    formatRateLimitWarning();
+    formatRateLimitWarning(verbose);
     return createErrorResult("Rate limited \u2014 too many calls. Try again later.");
   }
   const budgetCheck = budgetTracker.canMakeCall();
   if (!budgetCheck.allowed) {
-    formatBudgetWarning(budgetCheck.reason);
+    formatBudgetWarning(budgetCheck.reason, verbose);
     return createErrorResult(budgetCheck.reason);
   }
   let contextStr = "";
@@ -832,10 +1055,27 @@ async function executeAgent(prompt, context, options) {
     }
   }
   const processedPrompt = config.anonymize ? anonymizeValue(prompt) : prompt;
-  const spinner = startSpinner(persona, processedPrompt);
+  const shouldIncludeSource = options?.includeCallerSource ?? config.includeCallerSource;
+  let sourceFile = null;
+  if (shouldIncludeSource) {
+    if (context instanceof Error) {
+      sourceFile = getErrorSourceFile(context);
+      if (sourceFile) {
+        logDebug(`Auto-detected error source file: ${sourceFile.fileName} (line ${sourceFile.line})`);
+      }
+    }
+    if (!sourceFile) {
+      sourceFile = getCallerFile();
+      if (sourceFile) {
+        logDebug(`Auto-detected caller file: ${sourceFile.fileName} (line ${sourceFile.line})`);
+      }
+    }
+  }
+  const files = options?.files;
+  const spinner = startSpinner(persona, processedPrompt, verbose);
   try {
     const result = await Promise.race([
-      callGoogle(processedPrompt, contextStr, persona, config, options),
+      callGoogle(processedPrompt, contextStr, persona, config, options, sourceFile, files),
       createTimeout(config.timeout)
     ]);
     budgetTracker.recordUsage(
@@ -843,12 +1083,12 @@ async function executeAgent(prompt, context, options) {
       estimateCost(result.metadata.tokensUsed, result.metadata.model)
     );
     stopSpinner(spinner, result.success);
-    formatResult(result, persona);
+    formatResult(result, persona, verbose);
     return result;
   } catch (error) {
     stopSpinner(spinner, false);
     const err = error instanceof Error ? error : new Error(String(error));
-    formatError(err, persona);
+    formatError(err, persona, verbose);
     return createErrorResult(err.message);
   }
 }