@console-agent/agent 1.1.0

package/dist/index.js

@@ -0,0 +1,850 @@
+import { createGoogleGenerativeAI } from '@ai-sdk/google';
+import { jsonSchema, Output, ToolLoopAgent } from 'ai';
+import chalk from 'chalk';
+import ora from 'ora';
+
+// src/personas/debugger.ts
+var debuggerPersona = {
+  name: "debugger",
+  icon: "\u{1F41B}",
+  label: "Debugging",
+  systemPrompt: `You are a senior debugging expert and performance engineer.
+
+Your role:
+- Analyze errors, stack traces, exceptions, and performance issues
+- Identify root causes with high confidence
+- Provide concrete fixes with code examples
+- Suggest preventive measures
+
+Output format:
+- Start with a one-line summary of the issue
+- Explain the root cause clearly
+- Provide a concrete fix (with code if applicable)
+- Rate severity: LOW / MEDIUM / HIGH / CRITICAL
+- Include confidence score (0-1)
+
+Always be concise, technical, and actionable. No fluff.`,
+  defaultTools: ["code_execution", "google_search"],
+  keywords: [
+    "slow",
+    "perf",
+    "performance",
+    "optimize",
+    "optimization",
+    "debug",
+    "error",
+    "bug",
+    "crash",
+    "exception",
+    "stack",
+    "trace",
+    "memory",
+    "leak",
+    "timeout",
+    "latency",
+    "bottleneck",
+    "hang",
+    "freeze",
+    "deadlock",
+    "race condition"
+  ]
+};
+
+// src/personas/security.ts
+var securityPersona = {
+  name: "security",
+  icon: "\u{1F6E1}\uFE0F",
+  label: "Security audit",
+  systemPrompt: `You are an OWASP security expert and penetration testing specialist.
+
+Your role:
+- Audit code and inputs for vulnerabilities (SQL injection, XSS, CSRF, SSRF, etc.)
+- Flag security risks immediately with severity ratings
+- Check for known CVEs in dependencies
+- Recommend secure coding practices
+
+Output format:
+- Start with overall risk level: SAFE / LOW RISK / MEDIUM RISK / HIGH RISK / CRITICAL
+- List each vulnerability found with:
+  - Type (e.g., SQL Injection, XSS)
+  - Location (where in the code/input)
+  - Impact (what an attacker could do)
+  - Fix (concrete remediation)
+- Include confidence score (0-1)
+
+Be thorough, explicit about risks, and always err on the side of caution.`,
+  defaultTools: ["google_search"],
+  keywords: [
+    "security",
+    "vuln",
+    "vulnerability",
+    "exploit",
+    "injection",
+    "xss",
+    "csrf",
+    "ssrf",
+    "sql injection",
+    "auth",
+    "authentication",
+    "authorization",
+    "permission",
+    "privilege",
+    "escalation",
+    "sanitize",
+    "escape",
+    "encrypt",
+    "decrypt",
+    "hash",
+    "token",
+    "secret",
+    "api key",
+    "password",
+    "credential",
+    "owasp",
+    "cve"
+  ]
+};
+
+// src/personas/architect.ts
+var architectPersona = {
+  name: "architect",
+  icon: "\u{1F3D7}\uFE0F",
+  label: "Architecture review",
+  systemPrompt: `You are a principal software engineer and system architect.
+
+Your role:
+- Review system design, API design, and code architecture
+- Evaluate scalability, maintainability, and performance characteristics
+- Identify design pattern opportunities and anti-patterns
+- Suggest architectural improvements with trade-off analysis
+
+Output format:
+- Start with an overall assessment: SOLID / NEEDS IMPROVEMENT / SIGNIFICANT CONCERNS
+- List strengths of the current design
+- List concerns with severity and impact
+- Provide concrete recommendations with:
+  - What to change
+  - Why (trade-offs)
+  - How (implementation guidance)
+- Include confidence score (0-1)
+
+Think like a senior architect reviewing a design doc. Be constructive, not pedantic.`,
+  defaultTools: ["google_search", "file_analysis"],
+  keywords: [
+    "design",
+    "architecture",
+    "architect",
+    "pattern",
+    "scalab",
+    "microservice",
+    "monolith",
+    "api design",
+    "schema",
+    "database",
+    "system design",
+    "infrastructure",
+    "deploy",
+    "ci/cd",
+    "pipeline",
+    "refactor",
+    "modular",
+    "coupling",
+    "cohesion",
+    "solid",
+    "clean architecture",
+    "domain driven",
+    "event driven"
+  ]
+};
+
+// src/personas/general.ts
+var generalPersona = {
+  name: "general",
+  icon: "\u{1F50D}",
+  label: "Analyzing",
+  systemPrompt: `You are a helpful senior full-stack engineer with broad expertise.
+
+Your role:
+- Provide actionable advice on any technical topic
+- Analyze code, data, configurations, and systems
+- Validate inputs, schemas, and data integrity
+- Answer questions with practical, real-world guidance
+
+Output format:
+- Start with a clear, one-line answer or summary
+- Provide supporting details and reasoning
+- Include code examples when relevant
+- List any caveats or edge cases
+- Include confidence score (0-1)
+
+Be balanced, practical, and concise. Prioritize actionable insights over theory.`,
+  defaultTools: ["code_execution", "google_search", "file_analysis"],
+  keywords: []
+  // General catches everything not matched by specific personas
+};
+
+// src/personas/index.ts
+var personas = {
+  debugger: debuggerPersona,
+  security: securityPersona,
+  architect: architectPersona,
+  general: generalPersona
+};
+function detectPersona(prompt, defaultPersona) {
+  const lower = prompt.toLowerCase();
+  for (const name of ["security", "debugger", "architect"]) {
+    const persona = personas[name];
+    if (persona.keywords.some((kw) => lower.includes(kw))) {
+      return persona;
+    }
+  }
+  return personas[defaultPersona];
+}
+function getPersona(name) {
+  return personas[name];
+}
+var currentLogLevel = "info";
+function setLogLevel(level) {
+  currentLogLevel = level;
+}
+function shouldLog(level) {
+  const levels = ["silent", "errors", "info", "debug"];
+  return levels.indexOf(currentLogLevel) >= levels.indexOf(level);
+}
+function startSpinner(persona, prompt) {
+  if (!shouldLog("info")) 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),
+    prefixText: chalk.gray("[AGENT]")
+  }).start();
+  return spinner;
+}
+function stopSpinner(spinner, success) {
+  if (!spinner) return;
+  if (success) {
+    spinner.succeed();
+  } else {
+    spinner.fail();
+  }
+}
+function formatResult(result, persona) {
+  if (!shouldLog("info")) return;
+  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");
+  console.log("");
+  console.log(`${prefix} ${persona.icon} ${chalk.bold(persona.label)} Complete`);
+  console.log(`${prefix} \u251C\u2500 ${statusIcon} ${chalk.white(result.summary)}`);
+  if (result.actions.length > 0) {
+    for (let i = 0; i < result.actions.length; i++) {
+      const connector = i < result.actions.length - 1 ? "\u251C\u2500" : "\u251C\u2500";
+      console.log(`${prefix} ${connector} ${chalk.dim("Tool:")} ${chalk.cyan(result.actions[i])}`);
+    }
+  }
+  const dataEntries = Object.entries(result.data);
+  if (dataEntries.length > 0) {
+    for (const [key, value] of dataEntries) {
+      const displayValue = typeof value === "string" ? value : JSON.stringify(value);
+      console.log(`${prefix} \u251C\u2500 ${chalk.dim(key + ":")} ${chalk.white(displayValue)}`);
+    }
+  }
+  if (result.reasoning) {
+    const reasoningLines = result.reasoning.split("\n").slice(0, 3);
+    console.log(`${prefix} \u251C\u2500 ${chalk.dim("Reasoning:")}`);
+    for (const line of reasoningLines) {
+      console.log(`${prefix} \u2502  ${chalk.dim(line.trim())}`);
+    }
+  }
+  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 cached = result.metadata.cached ? chalk.green(" (cached)") : "";
+  console.log(`${prefix} \u2514\u2500 ${confidence} | ${latency} | ${tokens}${cached}`);
+  console.log("");
+}
+function formatError(error, persona) {
+  if (!shouldLog("errors")) return;
+  const prefix = chalk.gray("[AGENT]");
+  console.log("");
+  console.log(`${prefix} ${persona.icon} ${chalk.red("Error:")} ${error.message}`);
+  if (shouldLog("debug") && error.stack) {
+    console.log(`${prefix} ${chalk.dim(error.stack)}`);
+  }
+  console.log("");
+}
+function formatBudgetWarning(reason) {
+  if (!shouldLog("errors")) return;
+  const prefix = chalk.gray("[AGENT]");
+  console.log(`${prefix} ${chalk.yellow("\u26A0 Budget limit:")} ${reason}`);
+}
+function formatRateLimitWarning() {
+  if (!shouldLog("errors")) 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) {
+  if (!shouldLog("info")) return;
+  const prefix = chalk.gray("[AGENT]");
+  console.log("");
+  console.log(`${prefix} ${chalk.magenta("DRY RUN")} ${persona.icon} ${persona.label}`);
+  console.log(`${prefix} \u251C\u2500 ${chalk.dim("Persona:")} ${persona.name}`);
+  console.log(`${prefix} \u251C\u2500 ${chalk.dim("Prompt:")} ${prompt}`);
+  if (context !== void 0) {
+    const contextStr = typeof context === "string" ? context : JSON.stringify(context, null, 2);
+    const lines = contextStr.split("\n").slice(0, 5);
+    console.log(`${prefix} \u251C\u2500 ${chalk.dim("Context:")}`);
+    for (const line of lines) {
+      console.log(`${prefix} \u2502  ${chalk.dim(line)}`);
+    }
+  }
+  console.log(`${prefix} \u2514\u2500 ${chalk.dim("(No API call made)")}`);
+  console.log("");
+}
+function logDebug(message) {
+  if (!shouldLog("debug")) return;
+  console.log(`${chalk.gray("[AGENT DEBUG]")} ${chalk.dim(message)}`);
+}
+
+// src/providers/google.ts
+var agentOutputSchema = jsonSchema({
+  type: "object",
+  properties: {
+    success: { type: "boolean", description: "Whether the task was completed successfully" },
+    summary: { type: "string", description: "One-line human-readable conclusion" },
+    reasoning: { type: "string", description: "Your thought process" },
+    data: {
+      type: "object",
+      description: "Structured findings as key-value pairs",
+      properties: {
+        result: { type: "string", description: "Primary result or finding" }
+      },
+      additionalProperties: true
+    },
+    actions: { type: "array", items: { type: "string" }, description: "List of tools/steps you used" },
+    confidence: { type: "number", minimum: 0, maximum: 1, description: "0-1 confidence score" }
+  },
+  required: ["success", "summary", "data", "actions", "confidence"],
+  additionalProperties: false
+});
+async function callGoogle(prompt, context, persona, config2, options) {
+  const startTime = Date.now();
+  const modelName = options?.model ?? config2.model;
+  logDebug(`Using model: ${modelName}`);
+  logDebug(`Persona: ${persona.name}`);
+  const google = createGoogleGenerativeAI({
+    apiKey: config2.apiKey ?? process.env.GEMINI_API_KEY ?? process.env.GOOGLE_GENERATIVE_AI_API_KEY
+  });
+  const providerOptions = {};
+  const googleOpts = {};
+  if (options?.thinking) {
+    const thinking = options.thinking;
+    if (thinking.budget !== void 0) {
+      googleOpts["thinkingConfig"] = { thinkingBudget: thinking.budget };
+    } else if (thinking.level) {
+      googleOpts["thinkingConfig"] = { thinkingLevel: thinking.level };
+    }
+  }
+  if (Object.keys(googleOpts).length > 0) {
+    providerOptions["google"] = googleOpts;
+  }
+  if (!config2.localOnly) {
+    const toolNames = options?.tools ?? persona.defaultTools;
+    logDebug(`Persona tools (informational): ${toolNames.join(", ")}`);
+  }
+  const userMessage = context ? `${prompt}
+
+--- Context ---
+${context}` : prompt;
+  const collectedToolCalls = [];
+  const useCustomSchema = !!(options?.schema || options?.responseFormat);
+  let outputConfig;
+  if (options?.schema) {
+    if (options.responseFormat) {
+      logDebug("Both schema (Zod) and responseFormat provided \u2014 using schema (Zod)");
+    }
+    logDebug("Using custom Zod schema for structured output");
+    outputConfig = Output.object({ schema: options.schema });
+  } else if (options?.responseFormat) {
+    logDebug("Using custom JSON Schema (responseFormat) for structured output");
+    outputConfig = Output.object({ schema: jsonSchema(options.responseFormat.schema) });
+  } else {
+    outputConfig = Output.object({ schema: agentOutputSchema });
+  }
+  const agent = new ToolLoopAgent({
+    model: google(modelName),
+    instructions: useCustomSchema ? `${persona.systemPrompt}
+
+IMPORTANT: You must respond with structured data matching the requested output schema. Do not include AgentResult wrapper fields \u2014 just return the data matching the schema.` : persona.systemPrompt,
+    maxOutputTokens: config2.budget.maxTokensPerCall,
+    output: outputConfig,
+    providerOptions: Object.keys(providerOptions).length > 0 ? providerOptions : void 0,
+    onStepFinish: (step) => {
+      if (step.toolCalls) {
+        for (const tc of step.toolCalls) {
+          collectedToolCalls.push({
+            name: tc.toolName,
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            args: tc.args ?? {},
+            result: tc.toolName
+          });
+        }
+      }
+      logDebug(`Step finished: ${step.finishReason}`);
+    }
+  });
+  const result = await agent.generate({
+    prompt: userMessage,
+    timeout: config2.timeout
+  });
+  const latencyMs = Date.now() - startTime;
+  const tokensUsed = result.usage?.totalTokens ?? 0;
+  logDebug(`Response received: ${latencyMs}ms, ${tokensUsed} tokens`);
+  if (useCustomSchema && result.output) {
+    const customData = result.output;
+    logDebug("Custom schema output received, wrapping in AgentResult");
+    return {
+      success: true,
+      summary: `Structured output returned (${Object.keys(customData).length} fields)`,
+      data: customData,
+      actions: collectedToolCalls.map((tc) => tc.name),
+      confidence: 1,
+      metadata: {
+        model: modelName,
+        tokensUsed,
+        latencyMs,
+        toolCalls: collectedToolCalls,
+        cached: false
+      }
+    };
+  }
+  if (result.output) {
+    const output = result.output;
+    return {
+      success: output.success,
+      summary: output.summary,
+      reasoning: output.reasoning,
+      data: output.data,
+      actions: output.actions,
+      confidence: output.confidence,
+      metadata: {
+        model: modelName,
+        tokensUsed,
+        latencyMs,
+        toolCalls: collectedToolCalls,
+        cached: false
+      }
+    };
+  }
+  const parsed = parseResponse(result.text);
+  return {
+    success: parsed?.success ?? true,
+    summary: parsed?.summary ?? result.text.substring(0, 200),
+    reasoning: parsed?.reasoning,
+    data: parsed?.data ?? { raw: result.text },
+    actions: parsed?.actions ?? collectedToolCalls.map((tc) => tc.name),
+    confidence: parsed?.confidence ?? 0.5,
+    metadata: {
+      model: modelName,
+      tokensUsed,
+      latencyMs,
+      toolCalls: collectedToolCalls,
+      cached: false
+    }
+  };
+}
+function parseResponse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    const jsonMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+    if (jsonMatch) {
+      try {
+        return JSON.parse(jsonMatch[1]);
+      } catch {
+      }
+    }
+    const objectMatch = text.match(/\{[\s\S]*\}/);
+    if (objectMatch) {
+      try {
+        return JSON.parse(objectMatch[0]);
+      } catch {
+      }
+    }
+    return {
+      success: true,
+      summary: text.substring(0, 200),
+      data: { raw: text },
+      actions: [],
+      confidence: 0.5
+    };
+  }
+}
+
+// src/utils/anonymize.ts
+var patterns = {
+  // API keys and tokens (long alphanumeric strings near sensitive keywords)
+  apiKey: /(?:api[_-]?key|token|secret|password|credential|auth)['":\s=]+['"]?([A-Za-z0-9_\-/.]{20,})['"]?/gi,
+  // Bearer tokens
+  bearer: /Bearer\s+[A-Za-z0-9_\-/.+]{20,}/gi,
+  // Email addresses
+  email: /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g,
+  // IPv4 addresses
+  ipv4: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g,
+  // IPv6 addresses (simplified)
+  ipv6: /(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}/g,
+  // AWS keys
+  awsKey: /(?:AKIA|ASIA)[A-Z0-9]{16}/g,
+  // Private keys
+  privateKey: /-----BEGIN (?:RSA )?PRIVATE KEY-----[\s\S]*?-----END (?:RSA )?PRIVATE KEY-----/g,
+  // Connection strings
+  connectionString: /(?:mongodb|postgres|mysql|redis|amqp):\/\/[^\s'"]+/gi,
+  // .env style secrets
+  envSecret: /^(?:DATABASE_URL|DB_PASSWORD|SECRET_KEY|PRIVATE_KEY|AWS_SECRET|STRIPE_KEY|SENDGRID_KEY)[=:].+$/gm
+};
+function anonymize(content) {
+  let result = content;
+  result = result.replace(patterns.privateKey, "[REDACTED_PRIVATE_KEY]");
+  result = result.replace(patterns.connectionString, "[REDACTED_CONNECTION_STRING]");
+  result = result.replace(patterns.awsKey, "[REDACTED_AWS_KEY]");
+  result = result.replace(patterns.bearer, "Bearer [REDACTED_TOKEN]");
+  result = result.replace(patterns.apiKey, (match, _key) => {
+    const colonIdx = match.search(/['":\s=]/);
+    const prefix = match.substring(0, colonIdx);
+    return `${prefix}: [REDACTED]`;
+  });
+  result = result.replace(patterns.envSecret, (match) => {
+    const eqIdx = match.search(/[=:]/);
+    const key = match.substring(0, eqIdx);
+    return `${key}=[REDACTED]`;
+  });
+  result = result.replace(patterns.email, "[EMAIL]");
+  result = result.replace(patterns.ipv4, "[IP]");
+  result = result.replace(patterns.ipv6, "[IP]");
+  return result;
+}
+function anonymizeValue(value) {
+  if (typeof value === "string") {
+    return anonymize(value);
+  }
+  if (Array.isArray(value)) {
+    return value.map(anonymizeValue);
+  }
+  if (value !== null && typeof value === "object") {
+    const result = {};
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = anonymizeValue(v);
+    }
+    return result;
+  }
+  return value;
+}
+
+// src/utils/rate-limit.ts
+var RateLimiter = class {
+  tokens;
+  maxTokens;
+  refillRate;
+  // tokens per millisecond
+  lastRefill;
+  /**
+   * @param maxCallsPerDay Maximum calls allowed per day
+   */
+  constructor(maxCallsPerDay) {
+    this.maxTokens = maxCallsPerDay;
+    this.tokens = maxCallsPerDay;
+    this.refillRate = maxCallsPerDay / (24 * 60 * 60 * 1e3);
+    this.lastRefill = Date.now();
+  }
+  /**
+   * Attempt to consume one token.
+   * @returns true if allowed, false if rate limited
+   */
+  tryConsume() {
+    this.refill();
+    if (this.tokens >= 1) {
+      this.tokens -= 1;
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Get remaining tokens (calls available)
+   */
+  remaining() {
+    this.refill();
+    return Math.floor(this.tokens);
+  }
+  /**
+   * Reset the limiter (e.g., for testing or manual override)
+   */
+  reset() {
+    this.tokens = this.maxTokens;
+    this.lastRefill = Date.now();
+  }
+  refill() {
+    const now = Date.now();
+    const elapsed = now - this.lastRefill;
+    const newTokens = elapsed * this.refillRate;
+    this.tokens = Math.min(this.maxTokens, this.tokens + newTokens);
+    this.lastRefill = now;
+  }
+};
+
+// src/utils/budget.ts
+var BudgetTracker = class {
+  callsToday = 0;
+  tokensToday = 0;
+  costToday = 0;
+  dayStart;
+  config;
+  constructor(config2) {
+    this.config = config2;
+    this.dayStart = this.getStartOfDay();
+  }
+  /**
+   * Check if a call is within budget. Resets counters at midnight UTC.
+   */
+  canMakeCall() {
+    this.maybeResetDay();
+    if (this.callsToday >= this.config.maxCallsPerDay) {
+      return {
+        allowed: false,
+        reason: `Daily call limit reached (${this.config.maxCallsPerDay} calls/day)`
+      };
+    }
+    if (this.costToday >= this.config.costCapDaily) {
+      return {
+        allowed: false,
+        reason: `Daily cost cap reached ($${this.config.costCapDaily.toFixed(2)})`
+      };
+    }
+    return { allowed: true };
+  }
+  /**
+   * Record a completed call's usage.
+   */
+  recordUsage(tokensUsed, costUsd) {
+    this.maybeResetDay();
+    this.callsToday += 1;
+    this.tokensToday += tokensUsed;
+    this.costToday += costUsd;
+  }
+  /**
+   * Get current usage stats.
+   */
+  getStats() {
+    this.maybeResetDay();
+    return {
+      callsToday: this.callsToday,
+      callsRemaining: Math.max(0, this.config.maxCallsPerDay - this.callsToday),
+      tokensToday: this.tokensToday,
+      costToday: this.costToday,
+      costRemaining: Math.max(0, this.config.costCapDaily - this.costToday)
+    };
+  }
+  /**
+   * Reset all counters (for testing).
+   */
+  reset() {
+    this.callsToday = 0;
+    this.tokensToday = 0;
+    this.costToday = 0;
+    this.dayStart = this.getStartOfDay();
+  }
+  /**
+   * Get the max tokens allowed per call.
+   */
+  get maxTokensPerCall() {
+    return this.config.maxTokensPerCall;
+  }
+  maybeResetDay() {
+    const currentDayStart = this.getStartOfDay();
+    if (currentDayStart > this.dayStart) {
+      this.callsToday = 0;
+      this.tokensToday = 0;
+      this.costToday = 0;
+      this.dayStart = currentDayStart;
+    }
+  }
+  getStartOfDay() {
+    const now = /* @__PURE__ */ new Date();
+    return Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate());
+  }
+};
+
+// src/agent.ts
+var DEFAULT_CONFIG = {
+  provider: "google",
+  model: "gemini-2.5-flash-lite",
+  persona: "general",
+  budget: {
+    maxCallsPerDay: 100,
+    maxTokensPerCall: 8e3,
+    costCapDaily: 1
+  },
+  mode: "fire-and-forget",
+  timeout: 1e4,
+  anonymize: true,
+  localOnly: false,
+  dryRun: false,
+  logLevel: "info",
+  safetySettings: []
+};
+var config = { ...DEFAULT_CONFIG };
+var rateLimiter = new RateLimiter(config.budget.maxCallsPerDay);
+var budgetTracker = new BudgetTracker(config.budget);
+function updateConfig(newConfig) {
+  config = { ...DEFAULT_CONFIG, ...newConfig };
+  if (newConfig.budget) {
+    config.budget = { ...DEFAULT_CONFIG.budget, ...newConfig.budget };
+  }
+  rateLimiter = new RateLimiter(config.budget.maxCallsPerDay);
+  budgetTracker = new BudgetTracker(config.budget);
+}
+function getConfig() {
+  return { ...config };
+}
+async function executeAgent(prompt, context, options) {
+  const personaName = options?.persona ?? config.persona;
+  const persona = options?.persona ? getPersona(options.persona) : detectPersona(prompt, personaName);
+  logDebug(`Selected persona: ${persona.name} (${persona.icon})`);
+  if (config.dryRun) {
+    formatDryRun(prompt, persona, context);
+    return createDryRunResult(persona.name);
+  }
+  if (!rateLimiter.tryConsume()) {
+    formatRateLimitWarning();
+    return createErrorResult("Rate limited \u2014 too many calls. Try again later.");
+  }
+  const budgetCheck = budgetTracker.canMakeCall();
+  if (!budgetCheck.allowed) {
+    formatBudgetWarning(budgetCheck.reason);
+    return createErrorResult(budgetCheck.reason);
+  }
+  let contextStr = "";
+  if (context !== void 0) {
+    const processed = config.anonymize ? anonymizeValue(context) : context;
+    contextStr = typeof processed === "string" ? processed : JSON.stringify(processed, null, 2);
+    if (context instanceof Error) {
+      const errObj = {
+        name: context.name,
+        message: context.message,
+        stack: context.stack,
+        ...typeof context === "object" ? Object.getOwnPropertyNames(context).reduce((acc, key) => {
+          acc[key] = context[key];
+          return acc;
+        }, {}) : {}
+      };
+      const processed2 = config.anonymize ? anonymizeValue(errObj) : errObj;
+      contextStr = typeof processed2 === "string" ? processed2 : JSON.stringify(processed2, null, 2);
+    }
+  }
+  const processedPrompt = config.anonymize ? anonymizeValue(prompt) : prompt;
+  const spinner = startSpinner(persona, processedPrompt);
+  try {
+    const result = await Promise.race([
+      callGoogle(processedPrompt, contextStr, persona, config, options),
+      createTimeout(config.timeout)
+    ]);
+    budgetTracker.recordUsage(
+      result.metadata.tokensUsed,
+      estimateCost(result.metadata.tokensUsed, result.metadata.model)
+    );
+    stopSpinner(spinner, result.success);
+    formatResult(result, persona);
+    return result;
+  } catch (error) {
+    stopSpinner(spinner, false);
+    const err = error instanceof Error ? error : new Error(String(error));
+    formatError(err, persona);
+    return createErrorResult(err.message);
+  }
+}
+function createTimeout(ms) {
+  return new Promise((_, reject) => {
+    setTimeout(() => reject(new Error(`Agent timed out after ${ms}ms`)), ms);
+  });
+}
+function createErrorResult(message) {
+  return {
+    success: false,
+    summary: message,
+    data: {},
+    actions: [],
+    confidence: 0,
+    metadata: {
+      model: config.model,
+      tokensUsed: 0,
+      latencyMs: 0,
+      toolCalls: [],
+      cached: false
+    }
+  };
+}
+function createDryRunResult(personaName) {
+  return {
+    success: true,
+    summary: `[DRY RUN] Would have executed with ${personaName} persona`,
+    data: { dryRun: true },
+    actions: [],
+    confidence: 1,
+    metadata: {
+      model: config.model,
+      tokensUsed: 0,
+      latencyMs: 0,
+      toolCalls: [],
+      cached: false
+    }
+  };
+}
+function estimateCost(tokens, model) {
+  const costPer1M = {
+    "gemini-2.5-flash-lite": 0.01,
+    "gemini-3-flash-preview": 0.03
+  };
+  const rate = costPer1M[model] ?? 0.01;
+  return tokens / 1e6 * rate;
+}
+
+// src/index.ts
+function init(config2 = {}) {
+  updateConfig(config2);
+  const fullConfig = getConfig();
+  setLogLevel(fullConfig.logLevel);
+  attachConsoleAgent();
+}
+function createAgentProxy() {
+  const agentFn = (prompt, context, options) => {
+    const config2 = getConfig();
+    if (config2.mode === "fire-and-forget" && !options?.mode) {
+      const promise = executeAgent(prompt, context, options);
+      promise.catch(() => {
+      });
+      return promise;
+    }
+    return executeAgent(prompt, context, options);
+  };
+  agentFn.security = (prompt, context, options) => {
+    return executeAgent(prompt, context, { ...options, persona: "security" });
+  };
+  agentFn.debug = (prompt, context, options) => {
+    return executeAgent(prompt, context, { ...options, persona: "debugger" });
+  };
+  agentFn.architect = (prompt, context, options) => {
+    return executeAgent(prompt, context, { ...options, persona: "architect" });
+  };
+  return agentFn;
+}
+var attached = false;
+function attachConsoleAgent() {
+  if (attached) return;
+  const agentProxy = createAgentProxy();
+  console.agent = agentProxy;
+  attached = true;
+}
+attachConsoleAgent();
+
+export { DEFAULT_CONFIG, init };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map