@stacksjs/ai 0.70.87 → 0.70.90

package/dist/agents/claude/index.js

@@ -0,0 +1,197 @@
+let promptCount = 0;
+function formatToolUsage(toolName, input) {
+  switch (toolName) {
+    case "Read": {
+      const filePath = input.file_path || "";
+      return `
+\uD83D\uDCD6 Reading: ${filePath.split("/").pop() || filePath}
+`;
+    }
+    case "Glob":
+      return `
+\uD83D\uDD0D Searching files: ${input.pattern || ""}
+`;
+    case "Grep":
+      return `
+\uD83D\uDD0E Searching for: "${input.pattern || ""}"
+`;
+    case "Edit": {
+      const filePath = input.file_path || "";
+      return `
+\u270F\uFE0F Editing: ${filePath.split("/").pop() || filePath}
+`;
+    }
+    case "Write": {
+      const filePath = input.file_path || "";
+      return `
+\uD83D\uDCDD Writing: ${filePath.split("/").pop() || filePath}
+`;
+    }
+    case "Bash": {
+      const cmd = (input.command || "").substring(0, 50);
+      return `
+\uD83D\uDCBB Running: ${cmd}${cmd.length >= 50 ? "..." : ""}
+`;
+    }
+    case "Task":
+      return `
+\uD83D\uDE80 Launching agent: ${input.description || "task"}
+`;
+    default:
+      return `
+\uD83D\uDD27 Using: ${toolName}
+`;
+  }
+}
+export function createClaudeLocalAgent(config = {}) {
+  return {
+    name: "Claude CLI (Local)",
+    async process(command, context, _history) {
+      const { $: _$ } = await import("bun");
+      if ((await _$`which claude`.quiet().nothrow()).exitCode !== 0)
+        throw Error("Claude CLI not found. Install it with: npm install -g @anthropic-ai/claude-code");
+      const fullPrompt = context ? `Context:
+${context}
+
+User request: ${command}` : command, cwd = config.cwd || process.cwd();
+      try {
+        return (await _$`cd ${cwd} && claude --print --dangerously-skip-permissions ${fullPrompt}`.quiet()).text().trim();
+      } catch {
+        try {
+          return (await _$`cd ${cwd} && claude --print --allowedTools "Write,Edit,Bash" ${fullPrompt}`.quiet()).text().trim();
+        } catch (innerError) {
+          throw Error(`Claude CLI error: ${innerError.message}`);
+        }
+      }
+    }
+  };
+}
+export function createClaudeEC2Agent(config) {
+  const {
+    ec2Host = process.env.BUDDY_EC2_HOST,
+    ec2User = process.env.BUDDY_EC2_USER || "ubuntu",
+    ec2Key = process.env.BUDDY_EC2_KEY
+  } = config;
+  return {
+    name: "Claude CLI (EC2)",
+    async process(command, context, _history) {
+      const { $: _$ } = await import("bun");
+      if (!ec2Host)
+        throw Error("BUDDY_EC2_HOST environment variable not set. Set it to your EC2 instance IP/hostname.");
+      const escapedPrompt = (context ? `Context:
+${context}
+
+User request: ${command}` : command).replace(/'/g, "'\\''"), sshArgs = ec2Key ? `-i ${ec2Key}` : "", sshTarget = `${ec2User}@${ec2Host}`;
+      try {
+        return (await _$`ssh ${sshArgs} ${sshTarget} "claude --print '${escapedPrompt}'"`.quiet()).text().trim();
+      } catch (error) {
+        throw Error(`EC2 Claude CLI error: ${error.message}. Make sure SSH is configured and claude CLI is installed on EC2.`);
+      }
+    }
+  };
+}
+export async function processCommandStreaming(command, cwd) {
+  const { spawn } = await import("bun"), proc = spawn([
+    "claude",
+    "--print",
+    "--verbose",
+    "--output-format",
+    "stream-json",
+    "--dangerously-skip-permissions",
+    command
+  ], {
+    cwd,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  let fullResponse = "";
+  const decoder = new TextDecoder, encoder = new TextEncoder, stream = new ReadableStream({
+    async start(controller) {
+      try {
+        const reader = proc.stdout.getReader();
+        let buffer = "", lastSentText = "", result = await reader.read();
+        while (!result.done) {
+          buffer += decoder.decode(result.value, { stream: !0 });
+          const lines = buffer.split(`
+`);
+          buffer = lines.pop() || "";
+          for (const line of lines) {
+            if (!line.trim())
+              continue;
+            try {
+              const event = JSON.parse(line);
+              let textContent = "";
+              if (event.type === "system" && event.subtype === "init")
+                promptCount++;
+              else if (event.type === "content_block_start" && event.content_block?.text)
+                textContent = event.content_block.text;
+              else if (event.type === "content_block_delta" && event.delta?.text)
+                textContent = event.delta.text;
+              else if (event.type === "assistant" && event.message?.content) {
+                for (const block of event.message.content)
+                  if (block.type === "text" && block.text)
+                    textContent += block.text;
+                  else if (block.type === "tool_use" && block.name)
+                    textContent += formatToolUsage(block.name, block.input || {});
+              } else if (event.type === "user" && event.message?.content) {
+                for (const block of event.message.content)
+                  if (block.type === "tool_result")
+                    textContent += `   \u2713 done
+`;
+              } else if (event.type === "result" && event.result) {
+                fullResponse = event.result;
+                const resultPrefix = event.result.substring(0, Math.min(50, event.result.length));
+                if (!lastSentText.includes(resultPrefix))
+                  textContent = event.result;
+              }
+              if (textContent) {
+                if (event.type === "content_block_delta") {
+                  lastSentText += textContent;
+                  controller.enqueue(encoder.encode(textContent));
+                } else if (!lastSentText.endsWith(textContent)) {
+                  lastSentText += textContent;
+                  controller.enqueue(encoder.encode(textContent));
+                }
+              }
+            } catch {
+              if (!lastSentText.includes(line)) {
+                lastSentText += line;
+                fullResponse += line;
+                controller.enqueue(encoder.encode(line));
+              }
+            }
+          }
+          result = await reader.read();
+        }
+        if (buffer.trim())
+          try {
+            const event = JSON.parse(buffer);
+            if (event.result && !fullResponse)
+              fullResponse = event.result;
+          } catch {
+            if (!lastSentText.includes(buffer)) {
+              fullResponse += buffer;
+              controller.enqueue(encoder.encode(buffer));
+            }
+          }
+        await proc.exited;
+        controller.close();
+      } catch (error) {
+        controller.error(error);
+      }
+    }
+  }), fullResponsePromise = (async () => {
+    await proc.exited;
+    return fullResponse.trim();
+  })();
+  return { stream, fullResponse: fullResponsePromise };
+}
+export function resetPromptCount() {
+  promptCount = 0;
+}
+export const claudeAgent = {
+  createLocal: createClaudeLocalAgent,
+  createEC2: createClaudeEC2Agent,
+  processStreaming: processCommandStreaming,
+  resetPromptCount
+};

package/dist/agents/index.js

@@ -0,0 +1 @@
+export * from "./claude";

package/dist/buddy.js

@@ -0,0 +1,393 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { claudeAgent } from "./agents";
+import { createAnthropicDriver, createClaudeAgentSDKDriver, createOllamaDriver, createOpenAIDriver } from "./drivers";
+export const CONFIG = {
+  workDir: join(homedir(), "Code", ".buddy-repos"),
+  commitMessage: "chore: wip",
+  ollamaHost: process.env.OLLAMA_HOST || "http://localhost:11434",
+  ollamaModel: process.env.OLLAMA_MODEL || "llama3.2"
+}, apiKeys = {
+  anthropic: process.env.ANTHROPIC_API_KEY,
+  openai: process.env.OPENAI_API_KEY,
+  claudeCliHost: process.env.BUDDY_EC2_HOST
+};
+const state = {
+  repo: null,
+  conversationHistory: [],
+  currentDriver: "claude-cli-local",
+  github: null
+};
+if (!existsSync(CONFIG.workDir))
+  mkdirSync(CONFIG.workDir, { recursive: !0 });
+export const buddyState = {
+  getState: () => state,
+  setRepo: (repo) => {
+    state.repo = repo;
+  },
+  setCurrentDriver: (driver) => {
+    state.currentDriver = driver;
+  },
+  setGitHub: (github) => {
+    state.github = github;
+  },
+  addToHistory: (message) => {
+    state.conversationHistory.push(message);
+  },
+  clearHistory: () => {
+    state.conversationHistory = [];
+  }
+};
+export function buildSystemPrompt(context) {
+  return `You are Buddy, an AI code assistant that helps users modify codebases through voice commands.
+
+${state.repo ? `You are working on the repository: ${state.repo.name}
+Branch: ${state.repo.branch}
+Path: ${state.repo.path}
+
+${context}` : "No repository is currently open."}
+
+When the user gives you a command:
+1. Analyze what they want to do
+2. Identify the files that need to be modified
+3. Generate the exact code changes needed
+4. Respond with a structured format showing:
+  - Summary of changes
+  - Files to modify/create with full content
+  - Any additional notes
+
+Format file changes as:
+FILE: path/to/file.ts
+\`\`\`typescript
+// Full file content
+\`\`\`
+
+Be concise but thorough. The user will review and commit your changes.`;
+}
+function createMockDriver() {
+  return {
+    name: "Mock",
+    async process(command) {
+      await new Promise((resolve) => setTimeout(resolve, 1000));
+      const lowerCommand = command.toLowerCase();
+      if (lowerCommand.includes("readme") || lowerCommand.includes("documentation"))
+        return `I'll update the README.md file for you.
+
+Analyzing the repository structure...
+
+FILE: README.md
+\`\`\`markdown
+# Project Name
+
+## Installation
+
+\`\`\`bash
+npm install
+# or
+bun install
+\`\`\`
+
+## Usage
+
+\`\`\`bash
+npm run start
+\`\`\`
+\`\`\`
+
+File modified: README.md
+Lines added: 12`;
+      if (lowerCommand.includes("fix") || lowerCommand.includes("bug"))
+        return `I'll analyze and fix the issue.
+
+Scanning for potential bugs...
+
+FILE: src/utils.ts
+\`\`\`typescript
+export function getData(data: { value?: string }) {
+  return data?.value ?? 'default';
+}
+\`\`\`
+
+Files modified: src/utils.ts
+Lines changed: 4`;
+      return `I understand you want to: "${command}"
+
+I'll analyze the repository and implement this change.
+
+FILE: src/main.ts
+\`\`\`typescript
+// Updated based on your request
+export function main() {
+  console.log('Changes applied');
+}
+\`\`\`
+
+Files modified: 1`;
+    }
+  };
+}
+export function getDriver(driverName) {
+  const currentState = buddyState.getState();
+  switch (driverName) {
+    case "claude-cli-local":
+      return claudeAgent.createLocal({ cwd: currentState.repo?.path });
+    case "claude-cli-ec2":
+      return claudeAgent.createEC2({
+        cwd: currentState.repo?.path,
+        ec2Host: apiKeys.claudeCliHost
+      });
+    case "claude":
+    case "anthropic":
+      if (!apiKeys.anthropic)
+        throw Error("Anthropic API key not set. Configure your API key in settings.");
+      return createAnthropicDriver({ apiKey: apiKeys.anthropic });
+    case "openai":
+      if (!apiKeys.openai)
+        throw Error("OpenAI API key not set. Configure your API key in settings.");
+      return createOpenAIDriver({ apiKey: apiKeys.openai });
+    case "ollama":
+      return createOllamaDriver({
+        host: CONFIG.ollamaHost,
+        model: CONFIG.ollamaModel
+      });
+    case "claude-sdk":
+    case "claude-agent-sdk":
+      return createClaudeAgentSDKDriver({
+        cwd: currentState.repo?.path,
+        maxTurns: 25,
+        permissionMode: "bypassPermissions"
+      });
+    case "mock":
+      return createMockDriver();
+    default:
+      throw Error(`Unknown driver: ${driverName}. Available: claude-cli-local, claude-cli-ec2, claude, claude-sdk, openai, ollama, mock`);
+  }
+}
+export function getAvailableDrivers() {
+  return ["claude-cli-local", "claude-cli-ec2", "claude", "claude-sdk", "openai", "ollama", "mock"];
+}
+export async function getRepoContext(repoPath) {
+  const { $: _$ } = await import("bun"), files = (await _$`cd ${repoPath} && find . -type f -not -path "*/node_modules/*" -not -path "*/.git/*" -not -name "*.lock" | head -50`.quiet()).text().trim();
+  let readme = "";
+  const readmePath = join(repoPath, "README.md");
+  if (existsSync(readmePath))
+    readme = readFileSync(readmePath, "utf-8").slice(0, 2000);
+  let packageJson = "";
+  const packagePath = join(repoPath, "package.json");
+  if (existsSync(packagePath))
+    packageJson = readFileSync(packagePath, "utf-8");
+  return `
+Repository Structure:
+${files}
+
+${readme ? `README.md (excerpt):
+${readme}
+` : ""}
+${packageJson ? `package.json:
+${packageJson}
+` : ""}
+`.trim();
+}
+export async function openRepository(input) {
+  const { $: _$ } = await import("bun");
+  let repoPath, repoName;
+  if (input.includes("github.com") || input.startsWith("git@")) {
+    repoName = input.split("/").pop()?.replace(".git", "") || "repo";
+    repoPath = join(CONFIG.workDir, repoName);
+    if (existsSync(repoPath))
+      await _$`cd ${repoPath} && git pull --rebase`.quiet();
+    else
+      await _$`git clone ${input} ${repoPath}`.quiet();
+  } else {
+    repoPath = input.startsWith("~") ? input.replace("~", homedir()) : input;
+    if (!existsSync(repoPath))
+      throw Error(`Local path does not exist: ${repoPath}`);
+    if (!existsSync(join(repoPath, ".git")))
+      throw Error(`Not a git repository: ${repoPath}`);
+    repoName = repoPath.split("/").pop() || "repo";
+  }
+  const branch = (await _$`cd ${repoPath} && git branch --show-current`.quiet()).text().trim(), hasChanges = (await _$`cd ${repoPath} && git status --porcelain`.quiet()).text().trim().length > 0, lastCommit = (await _$`cd ${repoPath} && git log -1 --format="%h %s"`.quiet()).text().trim(), repoState = {
+    path: repoPath,
+    name: repoName,
+    branch,
+    hasChanges,
+    lastCommit
+  };
+  buddyState.setRepo(repoState);
+  buddyState.clearHistory();
+  return repoState;
+}
+export async function applyChanges(aiResponse) {
+  const currentState = buddyState.getState();
+  if (!currentState.repo)
+    throw Error("No repository opened");
+  const modifiedFiles = [], filePattern = /FILE:\s*([^\n]+)\n```\w*\n([\s\S]*?)```/g;
+  for (const match of aiResponse.matchAll(filePattern)) {
+    const filePath = match[1].trim(), content = match[2], fullPath = join(currentState.repo.path, filePath), dir = dirname(fullPath);
+    if (!existsSync(dir))
+      mkdirSync(dir, { recursive: !0 });
+    writeFileSync(fullPath, content);
+    modifiedFiles.push(filePath);
+  }
+  if (modifiedFiles.length > 0 && currentState.repo)
+    currentState.repo.hasChanges = !0;
+  return modifiedFiles;
+}
+export async function configureGitUser() {
+  const currentState = buddyState.getState();
+  if (!currentState.repo || !currentState.github)
+    return;
+  const { $: _$ } = await import("bun"), { name, email } = currentState.github;
+  await _$`cd ${currentState.repo.path} && git config user.name ${name}`.quiet();
+  await _$`cd ${currentState.repo.path} && git config user.email ${email}`.quiet();
+}
+export async function commitChanges() {
+  const currentState = buddyState.getState();
+  if (!currentState.repo)
+    throw Error("No repository opened");
+  const { $: _$ } = await import("bun");
+  if (currentState.github)
+    await configureGitUser();
+  await _$`cd ${currentState.repo.path} && git add -A`.quiet();
+  await _$`cd ${currentState.repo.path} && git commit -m ${CONFIG.commitMessage}`.quiet();
+  const commitHash = (await _$`cd ${currentState.repo.path} && git rev-parse --short HEAD`.quiet()).text().trim();
+  currentState.repo.hasChanges = !1;
+  currentState.repo.lastCommit = commitHash;
+  return commitHash;
+}
+export async function pushChanges() {
+  const currentState = buddyState.getState();
+  if (!currentState.repo)
+    throw Error("No repository opened");
+  const { $: _$ } = await import("bun");
+  await _$`cd ${currentState.repo.path} && git push`.quiet();
+}
+export async function processCommand(command, driverName) {
+  const currentState = buddyState.getState();
+  if (!currentState.repo)
+    throw Error("No repository opened");
+  const normalizedDriver = driverName || currentState.currentDriver, driver = getDriver(normalizedDriver);
+  if (driverName)
+    buddyState.setCurrentDriver(driverName);
+  const context = await getRepoContext(currentState.repo.path), systemPrompt = buildSystemPrompt(context), response = await driver.process(command, systemPrompt, currentState.conversationHistory);
+  buddyState.addToHistory({ role: "user", content: command });
+  buddyState.addToHistory({ role: "assistant", content: response });
+  return response;
+}
+export async function buddyProcessStreaming(command, driverName, history) {
+  const currentState = buddyState.getState();
+  if (!currentState.repo)
+    throw Error("No repository opened");
+  const normalizedDriver = driverName || currentState.currentDriver, streamingDrivers = ["claude-cli-local", "claude-sdk"];
+  if (!streamingDrivers.includes(normalizedDriver))
+    throw Error(`Streaming only supported for ${streamingDrivers.join(", ")} drivers. Current: ${normalizedDriver}`);
+  if (driverName)
+    buddyState.setCurrentDriver(driverName);
+  let contextualCommand = command;
+  if (history && history.length > 0) {
+    let conversationContext = `## Previous Conversation
+Here is our conversation so far:
+
+`;
+    for (const msg of history) {
+      const role = msg.role === "user" ? "User" : "Assistant";
+      conversationContext += `**${role}:** ${msg.content}
+
+`;
+    }
+    conversationContext += `---
+
+## Current Request
+`;
+    contextualCommand = conversationContext + command;
+  }
+  const result = await claudeAgent.processStreaming(contextualCommand, currentState.repo.path);
+  result.fullResponse.then((response) => {
+    buddyState.addToHistory({ role: "user", content: command });
+    buddyState.addToHistory({ role: "assistant", content: response });
+  });
+  return result;
+}
+export async function buddyStreamSimple(command, history) {
+  if (!apiKeys.anthropic)
+    throw Error("Anthropic API key not set. Configure your API key in settings.");
+  const messages = [];
+  if (history && history.length > 0)
+    for (const msg of history)
+      messages.push({
+        role: msg.role,
+        content: msg.content
+      });
+  messages.push({ role: "user", content: command });
+  const systemPrompt = `You are a helpful AI assistant. Answer questions naturally and conversationally.
+You can discuss any topic - technology, science, philosophy, everyday questions, or anything else the user asks about.
+Be concise but thorough. If the user asks about coding or their project specifically, help with that too.`, encoder = new TextEncoder;
+  let fullResponse = "", resolveFullResponse;
+  const fullResponsePromise = new Promise((resolve) => {
+    resolveFullResponse = resolve;
+  });
+  return {
+    stream: new ReadableStream({
+      async start(controller) {
+        try {
+          const response = await fetch("https://api.anthropic.com/v1/messages", {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              "x-api-key": apiKeys.anthropic,
+              "anthropic-version": "2023-06-01"
+            },
+            body: JSON.stringify({
+              model: "claude-sonnet-4-20250514",
+              max_tokens: 4096,
+              system: systemPrompt,
+              stream: !0,
+              messages
+            })
+          });
+          if (!response.ok) {
+            const error = await response.text();
+            throw Error(`Claude API error: ${error}`);
+          }
+          const reader = response.body?.getReader();
+          if (!reader)
+            throw Error("No response body");
+          const decoder = new TextDecoder;
+          let buffer = "";
+          while (!0) {
+            const { done, value } = await reader.read();
+            if (done)
+              break;
+            buffer += decoder.decode(value, { stream: !0 });
+            const lines = buffer.split(`
+`);
+            buffer = lines.pop() || "";
+            for (const line of lines)
+              if (line.startsWith("data: ")) {
+                const data = line.slice(6);
+                if (data === "[DONE]")
+                  continue;
+                try {
+                  const event = JSON.parse(data);
+                  if (event.type === "content_block_delta" && event.delta?.text) {
+                    const text = event.delta.text;
+                    fullResponse += text;
+                    controller.enqueue(encoder.encode(text));
+                  }
+                } catch {}
+              }
+          }
+          buddyState.addToHistory({ role: "user", content: command });
+          buddyState.addToHistory({ role: "assistant", content: fullResponse });
+          resolveFullResponse(fullResponse);
+          controller.close();
+        } catch (error) {
+          resolveFullResponse(fullResponse);
+          controller.error(error);
+        }
+      }
+    }),
+    fullResponse: fullResponsePromise
+  };
+}