codemaxxing 0.1.8 → 0.1.9

package/src/agent.ts

@@ -1,18 +1,63 @@
 import OpenAI from "openai";
+import Anthropic from "@anthropic-ai/sdk";
 import type {
   ChatCompletionMessageParam,
   ChatCompletionTool,
   ChatCompletionChunk,
 } from "openai/resources/chat/completions";
-import { FILE_TOOLS, executeTool } from "./tools/files.js";
+import { FILE_TOOLS, executeTool, generateDiff, getExistingContent } from "./tools/files.js";
 import { buildProjectContext, getSystemPrompt } from "./utils/context.js";
 import { isGitRepo, autoCommit } from "./utils/git.js";
-import { createSession, saveMessage, updateTokenEstimate, loadMessages } from "./utils/sessions.js";
+import { createSession, saveMessage, updateTokenEstimate, updateSessionCost, loadMessages } from "./utils/sessions.js";
 import type { ProviderConfig } from "./config.js";
 
 // Tools that can modify your project — require approval
 const DANGEROUS_TOOLS = new Set(["write_file", "run_command"]);
 
+// Cost per 1M tokens (input/output) for common models
+const MODEL_COSTS: Record<string, { input: number; output: number }> = {
+  // OpenAI
+  "gpt-4o": { input: 2.5, output: 10 },
+  "gpt-4o-mini": { input: 0.15, output: 0.6 },
+  "gpt-4-turbo": { input: 10, output: 30 },
+  "gpt-4": { input: 30, output: 60 },
+  "gpt-3.5-turbo": { input: 0.5, output: 1.5 },
+  "o1": { input: 15, output: 60 },
+  "o1-mini": { input: 3, output: 12 },
+  "o3-mini": { input: 1.1, output: 4.4 },
+  // Anthropic
+  "claude-3-5-sonnet-20241022": { input: 3, output: 15 },
+  "claude-3-5-sonnet": { input: 3, output: 15 },
+  "claude-sonnet-4-20250514": { input: 3, output: 15 },
+  "claude-3-5-haiku-20241022": { input: 0.8, output: 4 },
+  "claude-3-opus-20240229": { input: 15, output: 75 },
+  "claude-3-haiku-20240307": { input: 0.25, output: 1.25 },
+  // Qwen (typically free/cheap on local, but OpenRouter pricing)
+  "qwen/qwen-2.5-coder-32b-instruct": { input: 0.2, output: 0.2 },
+  "qwen/qwen-2.5-72b-instruct": { input: 0.35, output: 0.4 },
+  // DeepSeek
+  "deepseek/deepseek-chat": { input: 0.14, output: 0.28 },
+  "deepseek/deepseek-coder": { input: 0.14, output: 0.28 },
+  // Llama
+  "meta-llama/llama-3.1-70b-instruct": { input: 0.52, output: 0.75 },
+  "meta-llama/llama-3.1-8b-instruct": { input: 0.055, output: 0.055 },
+  // Google
+  "google/gemini-pro-1.5": { input: 1.25, output: 5 },
+  "google/gemini-flash-1.5": { input: 0.075, output: 0.3 },
+};
+
+function getModelCost(model: string): { input: number; output: number } {
+  // Direct match
+  if (MODEL_COSTS[model]) return MODEL_COSTS[model];
+  // Partial match (model name contains a known key)
+  const lower = model.toLowerCase();
+  for (const [key, cost] of Object.entries(MODEL_COSTS)) {
+    if (lower.includes(key) || key.includes(lower)) return cost;
+  }
+  // Default: $0 (local/unknown models)
+  return { input: 0, output: 0 };
+}
+
 export interface AgentOptions {
   provider: ProviderConfig;
   cwd: string;
@@ -22,8 +67,10 @@ export interface AgentOptions {
   onToolCall?: (name: string, args: Record<string, unknown>) => void;
   onToolResult?: (name: string, result: string) => void;
   onThinking?: (text: string) => void;
-  onToolApproval?: (name: string, args: Record<string, unknown>) => Promise<"yes" | "no" | "always">;
+  onToolApproval?: (name: string, args: Record<string, unknown>, diff?: string) => Promise<"yes" | "no" | "always">;
   onGitCommit?: (message: string) => void;
+  onContextCompressed?: (oldTokens: number, newTokens: number) => void;
+  contextCompressionThreshold?: number;
 }
 
 interface AssembledToolCall {
@@ -34,6 +81,8 @@ interface AssembledToolCall {
 
 export class CodingAgent {
   private client: OpenAI;
+  private anthropicClient: Anthropic | null = null;
+  private providerType: "openai" | "anthropic";
   private messages: ChatCompletionMessageParam[] = [];
   private tools: ChatCompletionTool[] = FILE_TOOLS;
   private cwd: string;
@@ -45,17 +94,33 @@ export class CodingAgent {
   private autoCommitEnabled: boolean = false;
   private repoMap: string = "";
   private sessionId: string = "";
+  private totalPromptTokens: number = 0;
+  private totalCompletionTokens: number = 0;
+  private totalCost: number = 0;
+  private systemPrompt: string = "";
+  private compressionThreshold: number;
 
   constructor(private options: AgentOptions) {
+    this.providerType = options.provider.type || "openai";
     this.client = new OpenAI({
       baseURL: options.provider.baseUrl,
       apiKey: options.provider.apiKey,
     });
+    if (this.providerType === "anthropic") {
+      this.anthropicClient = new Anthropic({
+        apiKey: options.provider.apiKey,
+      });
+    }
     this.cwd = options.cwd;
     this.maxTokens = options.maxTokens;
     this.autoApprove = options.autoApprove;
     this.model = options.provider.model;
+    // Default model for Anthropic
+    if (this.providerType === "anthropic" && (this.model === "auto" || !this.model)) {
+      this.model = "claude-sonnet-4-20250514";
+    }
     this.gitEnabled = isGitRepo(this.cwd);
+    this.compressionThreshold = options.contextCompressionThreshold ?? 80000;
   }
 
   /**
@@ -63,10 +128,10 @@ export class CodingAgent {
    */
   async init(): Promise<void> {
     const context = await buildProjectContext(this.cwd);
-    const systemPrompt = await getSystemPrompt(context);
+    this.systemPrompt = await getSystemPrompt(context);
 
     this.messages = [
-      { role: "system", content: systemPrompt },
+      { role: "system", content: this.systemPrompt },
     ];
 
     // Create a new session
@@ -116,6 +181,13 @@ export class CodingAgent {
     this.messages.push(userMsg);
     saveMessage(this.sessionId, userMsg);
 
+    // Check if context needs compression before sending
+    await this.maybeCompressContext();
+
+    if (this.providerType === "anthropic" && this.anthropicClient) {
+      return this.chatAnthropic(userMessage);
+    }
+
     let iterations = 0;
     const MAX_ITERATIONS = 20;
 
@@ -128,6 +200,7 @@ export class CodingAgent {
         tools: this.tools,
         max_tokens: this.maxTokens,
         stream: true,
+        stream_options: { include_usage: true },
       });
 
       // Accumulate the streamed response
@@ -135,8 +208,15 @@ export class CodingAgent {
       let thinkingText = "";
       let inThinking = false;
       const toolCalls: Map<number, AssembledToolCall> = new Map();
+      let chunkPromptTokens = 0;
+      let chunkCompletionTokens = 0;
 
       for await (const chunk of stream) {
+        // Capture usage from the final chunk
+        if ((chunk as any).usage) {
+          chunkPromptTokens = (chunk as any).usage.prompt_tokens ?? 0;
+          chunkCompletionTokens = (chunk as any).usage.completion_tokens ?? 0;
+        }
         const delta = chunk.choices?.[0]?.delta;
         if (!delta) continue;
 
@@ -195,6 +275,16 @@ export class CodingAgent {
       this.messages.push(assistantMessage);
       saveMessage(this.sessionId, assistantMessage);
 
+      // Track token usage and cost
+      if (chunkPromptTokens > 0 || chunkCompletionTokens > 0) {
+        this.totalPromptTokens += chunkPromptTokens;
+        this.totalCompletionTokens += chunkCompletionTokens;
+        const costs = getModelCost(this.model);
+        this.totalCost = (this.totalPromptTokens / 1_000_000) * costs.input +
+                         (this.totalCompletionTokens / 1_000_000) * costs.output;
+        updateSessionCost(this.sessionId, this.totalPromptTokens, this.totalCompletionTokens, this.totalCost);
+      }
+
       // If no tool calls, we're done — return the text
       if (toolCalls.size === 0) {
         updateTokenEstimate(this.sessionId, this.estimateTokens());
@@ -215,7 +305,15 @@ export class CodingAgent {
         // Check approval for dangerous tools
         if (DANGEROUS_TOOLS.has(toolCall.name) && !this.autoApprove && !this.alwaysApproved.has(toolCall.name)) {
           if (this.options.onToolApproval) {
-            const decision = await this.options.onToolApproval(toolCall.name, args);
+            // Generate diff for write_file if file already exists
+            let diff: string | undefined;
+            if (toolCall.name === "write_file" && args.path && args.content) {
+              const existing = getExistingContent(String(args.path), this.cwd);
+              if (existing !== null) {
+                diff = generateDiff(existing, String(args.content), String(args.path));
+              }
+            }
+            const decision = await this.options.onToolApproval(toolCall.name, args, diff);
             if (decision === "no") {
               const denied = `Tool call "${toolCall.name}" was denied by the user.`;
               this.options.onToolResult?.(toolCall.name, denied);
@@ -262,6 +360,198 @@ export class CodingAgent {
     return "Max iterations reached. The agent may be stuck in a loop.";
   }
 
+  /**
+   * Convert OpenAI-format tools to Anthropic tool format
+   */
+  private getAnthropicTools(): Anthropic.Tool[] {
+    return this.tools.map((t) => ({
+      name: t.function.name,
+      description: t.function.description ?? "",
+      input_schema: (t.function.parameters as Anthropic.Tool.InputSchema) ?? { type: "object" as const, properties: {} },
+    }));
+  }
+
+  /**
+   * Convert messages to Anthropic format (separate system from conversation)
+   */
+  private getAnthropicMessages(): Anthropic.MessageParam[] {
+    const msgs: Anthropic.MessageParam[] = [];
+    for (const msg of this.messages) {
+      if (msg.role === "system") continue; // system handled separately
+      if (msg.role === "user") {
+        msgs.push({ role: "user", content: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content) });
+      } else if (msg.role === "assistant") {
+        const content: Anthropic.ContentBlockParam[] = [];
+        if (msg.content) {
+          content.push({ type: "text", text: typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content) });
+        }
+        if ("tool_calls" in msg && Array.isArray((msg as any).tool_calls)) {
+          for (const tc of (msg as any).tool_calls) {
+            let input: Record<string, unknown> = {};
+            try { input = JSON.parse(tc.function.arguments); } catch {}
+            content.push({
+              type: "tool_use",
+              id: tc.id,
+              name: tc.function.name,
+              input,
+            });
+          }
+        }
+        if (content.length > 0) {
+          msgs.push({ role: "assistant", content });
+        }
+      } else if (msg.role === "tool") {
+        const toolCallId = (msg as any).tool_call_id;
+        const resultContent = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+        // Anthropic expects tool results as user messages with tool_result content
+        msgs.push({
+          role: "user",
+          content: [{
+            type: "tool_result",
+            tool_use_id: toolCallId,
+            content: resultContent,
+          }],
+        });
+      }
+    }
+    return msgs;
+  }
+
+  /**
+   * Anthropic-native streaming chat
+   */
+  private async chatAnthropic(_userMessage: string): Promise<string> {
+    const client = this.anthropicClient!;
+    let iterations = 0;
+    const MAX_ITERATIONS = 20;
+
+    while (iterations < MAX_ITERATIONS) {
+      iterations++;
+
+      const anthropicMessages = this.getAnthropicMessages();
+      const anthropicTools = this.getAnthropicTools();
+
+      const stream = client.messages.stream({
+        model: this.model,
+        max_tokens: this.maxTokens,
+        system: this.systemPrompt,
+        messages: anthropicMessages,
+        tools: anthropicTools,
+      });
+
+      let contentText = "";
+      const toolCalls: Array<{ id: string; name: string; input: Record<string, unknown> }> = [];
+      let currentToolId = "";
+      let currentToolName = "";
+      let currentToolInput = "";
+
+      stream.on("text", (text) => {
+        contentText += text;
+        this.options.onToken?.(text);
+      });
+
+      const finalMessage = await stream.finalMessage();
+
+      // Track usage
+      if (finalMessage.usage) {
+        const promptTokens = finalMessage.usage.input_tokens;
+        const completionTokens = finalMessage.usage.output_tokens;
+        this.totalPromptTokens += promptTokens;
+        this.totalCompletionTokens += completionTokens;
+        const costs = getModelCost(this.model);
+        this.totalCost = (this.totalPromptTokens / 1_000_000) * costs.input +
+                         (this.totalCompletionTokens / 1_000_000) * costs.output;
+        updateSessionCost(this.sessionId, this.totalPromptTokens, this.totalCompletionTokens, this.totalCost);
+      }
+
+      // Extract tool uses from content blocks
+      for (const block of finalMessage.content) {
+        if (block.type === "tool_use") {
+          toolCalls.push({
+            id: block.id,
+            name: block.name,
+            input: block.input as Record<string, unknown>,
+          });
+        }
+      }
+
+      // Build OpenAI-format assistant message for session storage
+      const assistantMessage: any = { role: "assistant", content: contentText || null };
+      if (toolCalls.length > 0) {
+        assistantMessage.tool_calls = toolCalls.map((tc) => ({
+          id: tc.id,
+          type: "function" as const,
+          function: { name: tc.name, arguments: JSON.stringify(tc.input) },
+        }));
+      }
+      this.messages.push(assistantMessage);
+      saveMessage(this.sessionId, assistantMessage);
+
+      // If no tool calls, we're done
+      if (toolCalls.length === 0) {
+        updateTokenEstimate(this.sessionId, this.estimateTokens());
+        return contentText || "(empty response)";
+      }
+
+      // Process tool calls
+      for (const toolCall of toolCalls) {
+        const args = toolCall.input;
+        this.options.onToolCall?.(toolCall.name, args);
+
+        // Check approval for dangerous tools
+        if (DANGEROUS_TOOLS.has(toolCall.name) && !this.autoApprove && !this.alwaysApproved.has(toolCall.name)) {
+          if (this.options.onToolApproval) {
+            let diff: string | undefined;
+            if (toolCall.name === "write_file" && args.path && args.content) {
+              const existing = getExistingContent(String(args.path), this.cwd);
+              if (existing !== null) {
+                diff = generateDiff(existing, String(args.content), String(args.path));
+              }
+            }
+            const decision = await this.options.onToolApproval(toolCall.name, args, diff);
+            if (decision === "no") {
+              const denied = `Tool call "${toolCall.name}" was denied by the user.`;
+              this.options.onToolResult?.(toolCall.name, denied);
+              const deniedMsg: ChatCompletionMessageParam = {
+                role: "tool",
+                tool_call_id: toolCall.id,
+                content: denied,
+              };
+              this.messages.push(deniedMsg);
+              saveMessage(this.sessionId, deniedMsg);
+              continue;
+            }
+            if (decision === "always") {
+              this.alwaysApproved.add(toolCall.name);
+            }
+          }
+        }
+
+        const result = await executeTool(toolCall.name, args, this.cwd);
+        this.options.onToolResult?.(toolCall.name, result);
+
+        // Auto-commit after successful write_file
+        if (this.gitEnabled && this.autoCommitEnabled && toolCall.name === "write_file" && result.startsWith("✅")) {
+          const path = String(args.path ?? "unknown");
+          const committed = autoCommit(this.cwd, path, "write");
+          if (committed) {
+            this.options.onGitCommit?.(`write ${path}`);
+          }
+        }
+
+        const toolMsg: ChatCompletionMessageParam = {
+          role: "tool",
+          tool_call_id: toolCall.id,
+          content: result,
+        };
+        this.messages.push(toolMsg);
+        saveMessage(this.sessionId, toolMsg);
+      }
+    }
+
+    return "Max iterations reached. The agent may be stuck in a loop.";
+  }
+
   /**
    * Switch to a different model mid-session
    */
@@ -315,6 +605,90 @@ export class CodingAgent {
     return Math.ceil(chars / 4);
   }
 
+  /**
+   * Check if context needs compression and compress if threshold exceeded
+   */
+  private async maybeCompressContext(): Promise<void> {
+    const currentTokens = this.estimateTokens();
+    if (currentTokens < this.compressionThreshold) return;
+
+    // Keep: system prompt (index 0) + last 10 messages
+    const keepCount = 10;
+    if (this.messages.length <= keepCount + 1) return; // Not enough to compress
+
+    const systemMsg = this.messages[0];
+    const middleMessages = this.messages.slice(1, this.messages.length - keepCount);
+    const recentMessages = this.messages.slice(this.messages.length - keepCount);
+
+    if (middleMessages.length === 0) return;
+
+    // Build a summary of the middle messages
+    const summaryParts: string[] = [];
+    for (const msg of middleMessages) {
+      if (msg.role === "user" && typeof msg.content === "string") {
+        summaryParts.push(`User: ${msg.content.slice(0, 200)}`);
+      } else if (msg.role === "assistant" && typeof msg.content === "string" && msg.content) {
+        summaryParts.push(`Assistant: ${msg.content.slice(0, 200)}`);
+      } else if (msg.role === "tool") {
+        // Skip tool messages in summary to save tokens
+      }
+    }
+
+    // Use the active model to summarize
+    const summaryPrompt = `Summarize this conversation history in 2-3 concise paragraphs. Focus on: what was discussed, what files were modified, what decisions were made, and any important context for continuing the conversation.\n\n${summaryParts.join("\n")}`;
+
+    try {
+      let summary: string;
+      if (this.providerType === "anthropic" && this.anthropicClient) {
+        const response = await this.anthropicClient.messages.create({
+          model: this.model,
+          max_tokens: 500,
+          messages: [{ role: "user", content: summaryPrompt }],
+        });
+        summary = response.content
+          .filter((b): b is Anthropic.TextBlock => b.type === "text")
+          .map((b) => b.text)
+          .join("");
+      } else {
+        const response = await this.client.chat.completions.create({
+          model: this.model,
+          max_tokens: 500,
+          messages: [{ role: "user", content: summaryPrompt }],
+        });
+        summary = response.choices[0]?.message?.content ?? "Previous conversation context.";
+      }
+
+      const compressedMsg: ChatCompletionMessageParam = {
+        role: "assistant",
+        content: `[Context compressed: ${summary}]`,
+      };
+
+      const oldTokens = currentTokens;
+      this.messages = [systemMsg, compressedMsg, ...recentMessages];
+      const newTokens = this.estimateTokens();
+
+      this.options.onContextCompressed?.(oldTokens, newTokens);
+    } catch {
+      // If summarization fails, just truncate without summary
+      const compressedMsg: ChatCompletionMessageParam = {
+        role: "assistant",
+        content: "[Context compressed: Earlier conversation history was removed to stay within token limits.]",
+      };
+      const oldTokens = currentTokens;
+      this.messages = [systemMsg, compressedMsg, ...recentMessages];
+      const newTokens = this.estimateTokens();
+      this.options.onContextCompressed?.(oldTokens, newTokens);
+    }
+  }
+
+  getCostInfo(): { promptTokens: number; completionTokens: number; totalCost: number } {
+    return {
+      promptTokens: this.totalPromptTokens,
+      completionTokens: this.totalCompletionTokens,
+      totalCost: this.totalCost,
+    };
+  }
+
   reset(): void {
     const systemMsg = this.messages[0];
     this.messages = [systemMsg];

package/src/config.ts

@@ -7,6 +7,7 @@ export interface ProviderConfig {
   baseUrl: string;
   apiKey: string;
   model: string;
+  type?: "openai" | "anthropic";
 }
 
 export interface ProviderProfile extends ProviderConfig {
@@ -20,6 +21,7 @@ export interface CodemaxxingConfig {
     autoApprove: boolean;
     contextFiles: number;
     maxTokens: number;
+    contextCompressionThreshold?: number;
   };
 }
 
@@ -135,6 +137,14 @@ export function applyOverrides(config: CodemaxxingConfig, args: CLIArgs): Codema
   if (args.provider && config.providers?.[args.provider]) {
     const profile = config.providers[args.provider];
     result.provider = { ...profile };
+    // Also check auth store for this provider
+    const authCred = getCredential(args.provider);
+    if (authCred) {
+      result.provider.baseUrl = authCred.baseUrl;
+      result.provider.apiKey = authCred.apiKey;
+    }
+    // Detect provider type
+    result.provider.type = detectProviderType(args.provider, result.provider.baseUrl);
   }
 
   // CLI flags override everything
@@ -142,6 +152,11 @@ export function applyOverrides(config: CodemaxxingConfig, args: CLIArgs): Codema
   if (args.apiKey) result.provider.apiKey = args.apiKey;
   if (args.baseUrl) result.provider.baseUrl = args.baseUrl;
 
+  // Auto-detect type from baseUrl if not set
+  if (!result.provider.type && result.provider.baseUrl) {
+    result.provider.type = detectProviderType(args.provider || "", result.provider.baseUrl);
+  }
+
   return result;
 }
 
@@ -218,7 +233,7 @@ export async function listModels(baseUrl: string, apiKey: string): Promise<strin
 export function resolveProvider(
   providerId: string,
   cliArgs: CLIArgs
-): { baseUrl: string; apiKey: string; model: string } | null {
+): ProviderConfig | null {
   // Check auth store first
   const authCred = getCredential(providerId);
   if (authCred) {
@@ -226,6 +241,7 @@ export function resolveProvider(
       baseUrl: authCred.baseUrl,
       apiKey: authCred.apiKey,
       model: cliArgs.model || "auto",
+      type: detectProviderType(providerId, authCred.baseUrl),
     };
   }
 
@@ -237,8 +253,19 @@ export function resolveProvider(
       baseUrl: provider.baseUrl,
       apiKey: cliArgs.apiKey || provider.apiKey,
       model: cliArgs.model || provider.model,
+      type: detectProviderType(providerId, provider.baseUrl),
     };
   }
 
   return null;
 }
+
+/**
+ * Detect provider type from ID or base URL
+ */
+function detectProviderType(providerId: string, baseUrl: string): "openai" | "anthropic" {
+  if (providerId === "anthropic" || baseUrl.includes("anthropic.com")) {
+    return "anthropic";
+  }
+  return "openai";
+}