woopcode 0.1.0

package/config/config.ts

@@ -0,0 +1,118 @@
+import type { Message } from "./types";
+import { getProvidersConfigPath, getConversationPath, initializeConfig } from "./paths";
+
+export async function getConfig() {
+  await initializeConfig();
+  const configPath = getProvidersConfigPath();
+  return JSON.parse(await Bun.file(configPath).text());
+}
+
+export async function saveConfig(config: any) {
+  await initializeConfig();
+  const configPath = getProvidersConfigPath();
+  await Bun.write(configPath, JSON.stringify(config, null, 2));
+}
+
+// for storing and apending the conversation history
+export async function getConversation() {
+  await initializeConfig();
+  const conversationPath = getConversationPath();
+  const file = Bun.file(conversationPath);
+
+  if (!(await file.exists())) {
+    return [];
+  }
+
+  return JSON.parse(await file.text());
+}
+
+export async function saveConversation(messages: Message[]) {
+  await initializeConfig();
+  const conversationPath = getConversationPath();
+  await Bun.write(
+    conversationPath,
+    JSON.stringify(messages, null, 2),
+  );
+}
+
+export async function appendMessage(message: any) {
+  const conversation = await getConversation();
+
+  conversation.push(message);
+
+  await saveConversation(conversation);
+}
+
+// for context building
+export async function readPackageJson() {
+  const file = Bun.file(`${process.cwd()}/package.json`);
+
+  if (!(await file.exists())) {
+    return "";
+  }
+
+  return await file.text();
+}
+
+export async function readReadme() {
+  const file = Bun.file(`${process.cwd()}/README.md`);
+
+  if (!(await file.exists())) {
+    return "";
+  }
+
+  return await file.text();
+}
+
+export async function listRepositoryFiles() {
+  const root = process.cwd();
+
+  const files: string[] = [];
+
+  for await (const entry of new Bun.Glob("**/*").scan(root)) {
+    if (
+      entry.startsWith("node_modules") ||
+      entry.startsWith(".git") ||
+      entry.startsWith("dist")
+    ) {
+      continue;
+    }
+
+    files.push(entry);
+  }
+
+  return files;
+}
+
+export async function buildRepositoryContext() {
+  const packageJson = await readPackageJson();
+  const readme = await readReadme();
+  const files = await listRepositoryFiles();
+
+  return `Repository Context\n\nPackage.json:\n${packageJson}\n\nREADME:\n${readme}\n\nFiles:\n${files.join("\n")}`;
+}
+
+export function recentMessages(
+  message: Message[],
+  maxTurns: number,
+): Message[] {
+  if (maxTurns <= 0 || message.length === 0) {
+    return [];
+  }
+
+  let userTurn = 0;
+  let startIndex = 0;
+
+  for (let i = message.length - 1; i >= 0; i--) {
+    if (message[i]?.role === "user") {
+      userTurn++;
+
+      if (userTurn == maxTurns) {
+        startIndex = i;
+        break;
+      }
+    }
+  }
+
+  return message.slice(startIndex);
+}

package/config/conversation.json

@@ -0,0 +1 @@
+[]

package/config/models.json

@@ -0,0 +1,50 @@
+[
+  {
+    "id": "gpt-5.5",
+    "provider": "openai",
+    "name": "GPT-5.5",
+    "contextWindow": "400000"
+  },
+
+  {
+    "id": "claud-sonnet-4",
+    "provider": "anthropic",
+    "name": "Claude Sonnet 4",
+    "contextWindow": "200000"
+  },
+
+  {
+    "id": "gpt-5.5",
+    "provider": "openai",
+    "name": "GPT-5.5",
+    "contextWindow": "400000"
+  },
+
+  {
+    "id": "gemini-2.5-flash",
+    "provider": "google",
+    "name": "Gemini 2.5 Flash",
+    "contextWindow": 1000000
+  },
+
+  {
+    "id": "gemini-2.5-flash-lite",
+    "provider": "google",
+    "name": "Gemini 2.5 Flash Lite",
+    "contextWindow": 1000000
+  },
+
+  {
+    "id": "gemini-2.0-flash",
+    "provider": "google",
+    "name": "Gemini 2.0 Flash",
+    "contextWindow": 1000000
+  },
+
+  {
+    "id": "gemini-2.0-flash-lite",
+    "provider": "google",
+    "name": "Gemini 2.0 Flash Lite",
+    "contextWindow": 1000000
+  }
+]

package/config/paths.ts

@@ -0,0 +1,96 @@
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, mkdirSync } from "fs";
+
+/**
+ * Returns the user configuration directory for Woopcode.
+ * Creates the directory if it doesn't exist.
+ * 
+ * Location:
+ * - macOS/Linux: ~/.config/woopcode/
+ * - Windows: %LOCALAPPDATA%\woopcode\
+ */
+export function getConfigDir(): string {
+  const home = homedir();
+  
+  let configDir: string;
+  
+  if (process.platform === "win32") {
+    // Windows: Use LOCALAPPDATA
+    const localAppData = process.env.LOCALAPPDATA || join(home, "AppData", "Local");
+    configDir = join(localAppData, "woopcode");
+  } else {
+    // macOS/Linux: Use XDG Base Directory Specification
+    const xdgConfigHome = process.env.XDG_CONFIG_HOME || join(home, ".config");
+    configDir = join(xdgConfigHome, "woopcode");
+  }
+  
+  // Ensure directory exists
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  
+  return configDir;
+}
+
+/**
+ * Get the path to providers.json
+ */
+export function getProvidersConfigPath(): string {
+  return join(getConfigDir(), "providers.json");
+}
+
+/**
+ * Get the path to conversation.json
+ */
+export function getConversationPath(): string {
+  return join(getConfigDir(), "conversation.json");
+}
+
+/**
+ * Get the path to models.json
+ */
+export function getModelsPath(): string {
+  return join(getConfigDir(), "models.json");
+}
+
+/**
+ * Initialize configuration directory with default files if they don't exist.
+ */
+export async function initializeConfig(): Promise<void> {
+  const configDir = getConfigDir();
+  const providersPath = getProvidersConfigPath();
+  const conversationPath = getConversationPath();
+  
+  // Create default providers.json if it doesn't exist
+  if (!existsSync(providersPath)) {
+    const defaultProviders = {
+      defaultProvider: "google",
+      providers: {
+        google: {
+          type: "api",
+          apiKey: ""
+        },
+        groq: {
+          type: "api",
+          apiKey: ""
+        },
+        openai: {
+          type: "api",
+          apiKey: ""
+        },
+        anthropic: {
+          type: "api",
+          apiKey: ""
+        }
+      }
+    };
+    
+    await Bun.write(providersPath, JSON.stringify(defaultProviders, null, 2));
+  }
+  
+  // Create empty conversation.json if it doesn't exist
+  if (!existsSync(conversationPath)) {
+    await Bun.write(conversationPath, JSON.stringify([], null, 2));
+  }
+}

package/config/providers.json

@@ -0,0 +1,21 @@
+{
+  "defaultProvider": "google",
+  "providers": {
+    "google": {
+      "type": "api",
+      "apiKey": ""
+    },
+    "groq": {
+      "type": "api",
+      "apiKey": ""
+    },
+    "openai": {
+      "type": "api",
+      "apiKey": ""
+    },
+    "anthropic": {
+      "type": "api",
+      "apiKey": ""
+    }
+  }
+}

package/config/runtime.ts

@@ -0,0 +1,130 @@
+import { getTool } from "../tools";
+import { recentMessages } from "./config";
+import type {
+  AgentCallbacks,
+  Message,
+  ProviderClient,
+  StreamEvent,
+} from "./types";
+
+export async function agentLoop(
+  client: ProviderClient,
+  messages: Message[],
+  repoContext: string,
+  callbacks: AgentCallbacks,
+  signal?: AbortSignal,
+) {
+  const MAX_ITERATIONS = 10;
+  const MAX_TURNS = 8;
+  const executedTools = new Set<string>();
+
+  let iterations = 0;
+
+  try {
+    while (iterations < MAX_ITERATIONS) {
+      iterations++;
+
+      let assistantText = "";
+      let toolCall: Extract<StreamEvent, { type: "tool_call" }> | null = null;
+
+      for await (const event of client.stream(
+        recentMessages(messages, MAX_TURNS),
+        repoContext,
+        signal,
+      )) {
+        switch (event.type) {
+          case "text":
+            assistantText += event.content;
+            callbacks.onText?.(event.content);
+            break;
+
+          case "tool_call":
+            toolCall = event;
+            break;
+
+          case "done":
+            break;
+        }
+      }
+
+      if (signal?.aborted) {
+        callbacks.onCancel?.();
+        return "";
+      }
+
+      if (!toolCall) {
+        messages.push({
+          role: "assistant",
+          content: assistantText,
+        });
+
+        callbacks.onDone?.();
+
+        return assistantText;
+      }
+
+      const tool = getTool(toolCall.name);
+
+      if (!tool) {
+        throw new Error(`Unknown tool: ${toolCall.name}`);
+      }
+
+      const toolKey = `${toolCall.name}:${JSON.stringify(toolCall.arguments)}`;
+
+      if (executedTools.has(toolKey)) {
+        throw new Error("Tool loop detected");
+      }
+
+      executedTools.add(toolKey);
+      callbacks.onToolStart?.({
+        id: toolCall.id,
+        name: toolCall.name,
+        arguments: toolCall.arguments,
+      });
+
+      messages.push({
+        role: "assistant_tool_call",
+        toolName: toolCall.name,
+        toolCallId: toolCall.id,
+        arguments: toolCall.arguments,
+        thoughtSignature: toolCall.thoughtSignature,
+      });
+
+      const result = await tool.execute(toolCall.arguments);
+      const MAX_TOOL_RESULT = 4000;
+      const toolResult =
+        result.length > MAX_TOOL_RESULT
+          ? result.slice(0, MAX_TOOL_RESULT) + "\n\n...output truncated..."
+          : result;
+
+      callbacks.onToolFinish?.({
+        id: toolCall.id,
+        name: toolCall.name,
+        arguments: toolCall.arguments,
+        output: toolResult,
+      });
+
+      messages.push({
+        role: "tool",
+        toolName: toolCall.name,
+        toolCallId: toolCall.id,
+        content: toolResult,
+      } as Message);
+    }
+
+    throw new Error(
+      `Agent exceeded the maximum number of iterations (${MAX_ITERATIONS}).`,
+    );
+  } catch (error) {
+    if (signal?.aborted) {
+      callbacks.onCancel?.();
+      return "";
+    }
+
+    const agentError =
+      error instanceof Error ? error : new Error(String(error));
+
+    callbacks.onError?.(agentError);
+    throw agentError;
+  }
+}

package/config/systemPrompt.ts

@@ -0,0 +1,54 @@
+export const SYSTEM_PROMPT = `
+You are WoopCode, an autonomous software engineering agent.
+
+Your goal is to solve software engineering tasks accurately and safely.
+
+Always gather enough information before making decisions. Never invent code, file contents, terminal output, repository structure, or test results.
+
+You have access to tools. Use them whenever additional information is required.
+
+Decision process:
+
+1. Understand the user's request.
+2. Decide whether you already have enough information.
+3. If not, choose the most appropriate tool.
+4. Continue gathering information until you are confident.
+5. Only then provide the final answer.
+
+Tool selection rules:
+
+- If the user is looking for a filename, directory, or files matching a name (for example: "find every runtime file", "locate client.ts", or "find config files"), ALWAYS use find_files first.
+- If the user is looking for a symbol, function, class, interface, variable, import, TODO, or any text inside files, use grep.
+- Never use grep when the goal is to find files by name.
+- Use read_file only after you have identified the correct file to inspect.
+- To inspect a file, use read_file.
+- To create a new file, use create_file.
+- To overwrite an entire file, use write_file.
+- To modify part of an existing file, use edit_file.
+- To execute shell commands, inspect git status, install packages, build projects, or run programs, use run_terminal.
+- To run the project's test suite, prefer run_tests.
+- If find_files already returned the requested files, answer the user instead of searching again.
+- Use grep only when you need to search file contents.
+- If a tool fully answers the user's request, respond to the user immediately.
+- Do not call another tool to verify the same information unless the previous tool result explicitly indicates that more searching is required.
+- For filename searches, use find_files. If find_files returns the matching files, answer the user instead of calling grep.
+
+General rules:
+
+- Never fabricate information.
+- Never claim to have read a file unless you actually used read_file.
+- Never claim to know repository contents unless they are provided or discovered using tools.
+- Never claim terminal output unless it comes from run_terminal.
+- Never claim test results unless they come from run_tests.
+- Prefer using tools over making assumptions.
+- If a tool provides insufficient information, use additional tools.
+- Use as many tool calls as necessary before producing a final answer.
+- Be concise but complete.
+- Preserve existing code style when editing files.
+- Make the smallest correct change that solves the user's request.
+- Do not modify unrelated code.
+- Explain what changed after completing a task.
+- Do not call the same tool twice with identical arguments unless the previous result was insufficient.
+
+Continue using tools until the task is complete or no additional information can be obtained.
+`;

package/config/types.ts

@@ -0,0 +1,88 @@
+export type ModelResponse =
+  | {
+      type: "message";
+      content: string;
+    }
+  | {
+      type: "tool_call";
+      id: string;
+      name: string;
+      arguments: Record<string, unknown>;
+      thoughtSignature?: string;
+    };
+
+export interface ProviderClient {
+  stream(
+    message: Message[],
+    repoContext: string,
+    signal?: AbortSignal,
+  ): AsyncGenerator<StreamEvent>;
+}
+
+export type Message =
+  | {
+      role: "user";
+      content: string;
+    }
+  | {
+      role: "assistant";
+      content: string;
+    }
+  | {
+      role: "assistant_tool_call";
+      toolName: string;
+      toolCallId: string;
+      arguments: Record<string, unknown>;
+      thoughtSignature?: string;
+    }
+  | {
+      role: "tool";
+      toolName: string;
+      toolCallId: string;
+      content: string;
+    };
+
+export interface ToolParameter {
+  name: string;
+  description: string;
+  required: boolean;
+}
+
+export interface ToolCall {
+  id: string;
+  name: string;
+  arguments: Record<string, unknown>;
+}
+
+export interface ToolResult extends ToolCall {
+  output: string;
+}
+
+export interface AgentCallbacks {
+  onStatus?(status: string): void;
+  onText?(text: string): void;
+  onToolStart?(tool: ToolCall): void;
+  onToolFinish?(tool: ToolResult): void;
+  onDone?(): void;
+  onError?(error: Error): void;
+  onCancel?(): void;
+}
+
+export interface Tool {
+  name: string;
+  description: string;
+  parameters: ToolParameter[];
+
+  execute(args: Record<string, unknown>): Promise<string>;
+}
+
+export type StreamEvent =
+  | { type: "text"; content: string }
+  | {
+      type: "tool_call";
+      id: string;
+      name: string;
+      arguments: Record<string, unknown>;
+      thoughtSignature?: string;
+    }
+  | { type: "done" };