woopcode 0.1.0

package/commands/agent.tsx

@@ -0,0 +1,139 @@
+import { Command } from "commander";
+import {
+  buildRepositoryContext,
+  getConfig,
+  getConversation,
+  saveConversation,
+} from "../config/config";
+import { createProviderClient } from "../config/client";
+import type { Message } from "../config/types";
+import type { AgentCallbacks } from "../config/types";
+import { agentLoop } from "../config/runtime";
+import { App, store } from "../tui/src";
+import { render } from "ink";
+import { AgentController } from "./agentController";
+import { ACTIVE_PROVIDER_MODELS } from "../config/client";
+import type { HomeScreenData } from "../tui/src/components/HomeScreen";
+import { ensureProviderConfigured } from "../onboarding";
+
+export const agentCommand = new Command("agent")
+  .description("Runs the agent")
+  .option("-p, --prompt <prompt>", "prompt", "")
+  .action(runAgent);
+
+/** Runs the interactive agent from either `woopcode` or `woopcode agent`. */
+export async function runAgent() {
+  // Ensure provider is configured (launches onboarding if needed)
+  await ensureProviderConfigured();
+
+  let cancelStatusTimeout: ReturnType<typeof setTimeout> | undefined;
+  const config = await getConfig();
+  const provider = config.defaultProvider;
+  const apiKey = config.providers[provider].apiKey;
+
+  const callbacks: AgentCallbacks = {
+      onStatus(status) {
+        if (cancelStatusTimeout) {
+          clearTimeout(cancelStatusTimeout);
+          cancelStatusTimeout = undefined;
+        }
+        store.setStatus(status);
+      },
+
+      onToolStart(tool) {
+        store.finishAssistantMessage();
+        store.startTool(tool);
+        store.setStatus(`Running ${tool.name}...`);
+      },
+
+      onToolFinish(tool) {
+        store.finishTool(tool.id);
+        store.setStatus("Thinking...");
+      },
+
+      onText(text) {
+        store.appendAssistantText(text);
+      },
+
+      onDone() {
+        //console.log("onDone received");
+        store.finishAssistantMessage();
+        store.setStatus("Ready");
+      },
+
+      onError(error) {
+        store.finishAssistantMessage();
+        store.setStatus(`Error: ${error.message}`);
+      },
+
+      onCancel() {
+        store.finishAssistantMessage();
+        store.setStatus("Cancelled");
+
+        cancelStatusTimeout = setTimeout(() => {
+          store.setStatus("Ready");
+        }, 1000);
+      },
+  };
+  const controller = new AgentController(provider, apiKey, callbacks);
+  await controller.initialize();
+  const homeScreen = await buildHomeScreen(provider);
+
+  const { unmount } = render(
+    <App controller={controller} onExit={handleExit} homeScreen={homeScreen} />,
+    { exitOnCtrlC: false },
+  );
+
+  let exiting = false;
+
+  async function handleExit() {
+    if (exiting) return;
+    exiting = true;
+
+    controller.cancel();
+    await controller.dispose();
+    unmount();
+    process.exit(0);
+  }
+
+  process.once("SIGINT", () => {
+    void handleExit();
+  });
+}
+
+async function buildHomeScreen(provider: string): Promise<HomeScreenData> {
+  const repository = process.cwd().split("/").filter(Boolean).at(-1) ?? "workspace";
+  const branch = await getBranch();
+  const providerLabel = provider === "google" ? "Gemini" : titleCase(provider);
+
+  return {
+    logoWord: "WOOPCODE",
+    subtitle: "AI software engineering agent",
+    promptExamples: [
+      "Explain this repository",
+      "Review recent changes",
+      "Find duplicate code",
+      "Generate tests",
+      "Optimize performance",
+      "Add authentication",
+    ],
+    capabilities: ["Build", "Review", "Explain", "Refactor", "Debug", "Test", "Document"],
+    repository,
+    branch,
+    providerName: providerLabel,
+    provider: ACTIVE_PROVIDER_MODELS[provider] ?? providerLabel,
+  };
+}
+
+async function getBranch(): Promise<string> {
+  try {
+    const branch = (await Bun.$`git branch --show-current`.text()).trim();
+    return branch || "detached";
+  } catch {
+    return "not a git repository";
+  }
+}
+
+function titleCase(value: string) {
+  return value.replace(/\b\w/g, (letter) => letter.toUpperCase());
+}

package/commands/agentController.ts

@@ -0,0 +1,138 @@
+import { createProviderClient } from "../config/client";
+import {
+  buildRepositoryContext,
+  getConversation,
+  saveConversation,
+} from "../config/config";
+import { agentLoop } from "../config/runtime";
+import type { AgentCallbacks, Message } from "../config/types";
+import { store } from "../tui/src";
+
+export class AgentController {
+  private conversation: Message[] = [];
+  private repoContext = "";
+  private pendingAssistantText: string | null = null;
+  private pendingUserMessage: Extract<Message, { role: "user" }> | null = null;
+  private abortController: AbortController | null = null;
+  private isRunning = false;
+  private wasCancelled = false;
+
+  constructor(
+    private readonly provider: string,
+    private readonly apiKey: string,
+    private readonly callbacks: AgentCallbacks,
+  ) {}
+
+  async run(prompt: string) {
+    if (this.isRunning) {
+      return;
+    }
+
+    this.isRunning = true;
+    this.abortController = new AbortController();
+    this.wasCancelled = false;
+
+    const userMessage: Extract<Message, { role: "user" }> = {
+      role: "user",
+      content: prompt,
+    };
+
+    this.conversation.push(userMessage);
+    this.pendingUserMessage = userMessage;
+
+    const conversation = [...this.conversation];
+    this.pendingAssistantText = "";
+
+    // Update UI before starting the agent
+    store.addUserMessage(prompt);
+    store.setStatus("Thinking...");
+
+    const client = createProviderClient(this.provider, this.apiKey);
+
+    let response = "";
+
+    try {
+      response = await agentLoop(
+        client,
+        conversation,
+        this.repoContext,
+        {
+          ...this.callbacks,
+          onText: (text) => {
+            this.pendingAssistantText += text;
+            this.callbacks.onText?.(text);
+          },
+          onCancel: () => {
+            this.wasCancelled = true;
+            this.callbacks.onCancel?.();
+          },
+        },
+        this.abortController.signal,
+      );
+
+      const assistantText = response || this.pendingAssistantText;
+
+      if (!this.wasCancelled && assistantText?.trim()) {
+        this.conversation.push({
+          role: "assistant",
+          content: assistantText,
+        });
+      }
+    } finally {
+      this.abortController = null;
+      this.isRunning = false;
+    }
+    this.pendingAssistantText = null;
+    if (this.wasCancelled) {
+      this.removePendingUserMessage();
+    } else {
+      this.pendingUserMessage = null;
+    }
+
+    return response;
+  }
+
+  async initialize() {
+    this.conversation = await getConversation();
+    this.repoContext = await buildRepositoryContext();
+  }
+
+  async dispose() {
+    if (this.wasCancelled) {
+      this.pendingAssistantText = null;
+      this.removePendingUserMessage();
+    } else if (this.pendingAssistantText?.trim()) {
+      this.conversation.push({
+        role: "assistant",
+        content: this.pendingAssistantText,
+      });
+      this.pendingAssistantText = null;
+    }
+
+    await saveConversation(this.conversation);
+  }
+
+  cancel() {
+    if (!this.isRunning) {
+      return;
+    }
+
+    this.wasCancelled = true;
+    this.abortController?.abort();
+  }
+
+  isBusy() {
+    return this.isRunning;
+  }
+
+  private removePendingUserMessage() {
+    if (!this.pendingUserMessage) {
+      return;
+    }
+
+    this.conversation = this.conversation.filter(
+      (message) => message !== this.pendingUserMessage,
+    );
+    this.pendingUserMessage = null;
+  }
+}

package/commands/models.ts

@@ -0,0 +1,21 @@
+import { Command } from "commander";
+import models from "../config/models.json";
+
+export const modelsCommand = new Command("models")
+  .description("Returns all the supported models")
+  .option("-m, --model <modelName>", "name of the model", "all")
+  .action((options) => {
+    if (options.model === "all") {
+      console.table(models);
+      return;
+    }
+
+    const model = models.find((m) => m.id === options.model);
+
+    if (!model) {
+      console.error(`Model "${options.model}" not found.`);
+      return;
+    }
+    console.table([model]);
+    console.log(options);
+  });

package/commands/providers/index.ts

@@ -0,0 +1,12 @@
+import { Command } from "commander";
+import { loginCommand } from "./login";
+import { logoutCommand } from "./logout";
+import { setProviderCommand } from "./setProvider";
+import { listCommand } from "./listProviders";
+
+export const providerCommand = new Command("providers")
+  .description("Provider related information")
+  .addCommand(loginCommand)
+  .addCommand(logoutCommand)
+  .addCommand(setProviderCommand)
+  .addCommand(listCommand);

package/commands/providers/listProviders.ts

@@ -0,0 +1,28 @@
+import { Command } from "commander";
+import { getConfig } from "../../config/config";
+
+export const listCommand = new Command("list")
+  .description("Returns all the Providers with their default & auth status)")
+  .option(
+    "-p, --provider <providerName>",
+    "Name of the provider (gemini, claude etc)",
+    "",
+  )
+  .action(async () => {
+    const config = await getConfig();
+
+    const rows = Object.entries(config.providers).map(
+      ([provider, details]: [string, any]) => {
+        const loggedIn = !!details.apiKey;
+        const isDefault = config.defaultProvider === provider;
+
+        return {
+          provider,
+          status: loggedIn ? "Logged in" : "Not Logged in",
+          default: isDefault ? "✔︎" : "",
+        };
+      },
+    );
+
+    console.table(rows);
+  });

package/commands/providers/login.ts

@@ -0,0 +1,28 @@
+import { Command } from "commander";
+import { loginProvider } from "../../config/authProvider";
+import { getConfig, saveConfig } from "../../config/config";
+
+export const loginCommand = new Command("login")
+  .description("Lets user login into the provider (use it as default)")
+  .option(
+    "-p, --provider <providerName>",
+    "Name of the provider (gemini, claude etc)",
+    "",
+  )
+  .option("-a, --api-key <apiKey>", "Your api key", "")
+  .action(async (options) => {
+    const success = await loginProvider(options.provider, options.apiKey);
+
+    if (!success) {
+      console.error(" Invalid API key");
+      process.exit(1);
+    }
+
+    const config = await getConfig();
+
+    config.defaultProvider = options.provider;
+    config.providers[options.provider].apiKey = options.apiKey;
+    await saveConfig(config);
+
+    console.log("logging into " + options.provider);
+  });

package/commands/providers/logout.ts

@@ -0,0 +1,33 @@
+import { Command } from "commander";
+import { getConfig, saveConfig } from "../../config/config";
+
+export const logoutCommand = new Command("logout")
+  .description("Lets user logout from the provider")
+  .option(
+    "-p, --provider <providerName>",
+    "Name of the provider (gemini, claude etc)",
+    "",
+  )
+  .action(async (options) => {
+    const config = await getConfig();
+
+    if (!config.providers[options.provider]) {
+      console.error(`Unknown Provider ${options.provider}`);
+      return;
+    }
+
+    if (!config.providers[options.provider].apiKey) {
+      console.error(`${options.provider} is not logged in`);
+      return;
+    }
+
+    delete config.providers[options.provider].apiKey;
+
+    if (config.defaultProvider === options.provider) {
+      config.defaultProviders === "";
+    }
+
+    await saveConfig(config);
+
+    console.log("logging out for provider " + options.provider);
+  });

package/commands/providers/setProvider.ts

@@ -0,0 +1,34 @@
+import { Command } from "commander";
+import { getConfig, saveConfig } from "../../config/config";
+
+export const setProviderCommand = new Command("set")
+  .description("Lets user set the default provider")
+  .option(
+    "-p, --provider <providerName>",
+    "Name of the provider (gemini, claude etc)",
+    "",
+  )
+  .action(async (options) => {
+    const config = await getConfig();
+    console.log("provider is  " + JSON.stringify(options));
+
+    if (!config.providers[options.provider]) {
+      console.error(`${options.provider} does not exist`);
+      return;
+    }
+
+    if (!config.providers[options.provider].apiKey) {
+      console.error(`${options.provider} is not logged in`);
+      return;
+    }
+
+    if (config.defaultProvider === options.provider) {
+      console.log(`${options.provider} is already default provider`);
+      return;
+    }
+
+    config.defaultProvider = options.provider;
+
+    await saveConfig(config);
+    console.log(`Default provider set to ${options.provider}`);
+  });

package/config/authProvider.ts

@@ -0,0 +1,54 @@
+import { fetch } from "bun";
+
+export async function loginProvider(provider: string, apiKey: string) {
+  switch (provider) {
+    case "google":
+      return verifyGemini(apiKey);
+    case "groq":
+      return verifyGroq(apiKey);
+    case "openai":
+      return verifyOpenai(apiKey);
+    case "anthropic":
+      return verifyAnthropic(apiKey);
+    default:
+      throw new Error(`Unsupported provider: ${provider}`);
+  }
+}
+
+async function verifyGemini(apiKey: string) {
+  const key = apiKey.trim();
+  const res = await fetch(
+    `https://generativelanguage.googleapis.com/v1beta/models?key=${key}`,
+  );
+  return res.ok;
+}
+
+async function verifyGroq(apiKey: string) {
+  const key = apiKey.trim();
+  const res = await fetch("https://api.groq.com/openai/v1/models", {
+    headers: {
+      Authorization: `Bearer ${key}`,
+    },
+  });
+  return res.ok;
+}
+
+async function verifyOpenai(apiKey: string) {
+  const res = await fetch("https://api.openai.com/v1/models", {
+    headers: {
+      Authorization: `Bearer ${apiKey}`,
+    },
+  });
+
+  return res.ok;
+}
+async function verifyAnthropic(apiKey: string) {
+  const res = await fetch("https://api.anthropic.com/v1/models", {
+    headers: {
+      "x-api-key": apiKey,
+      "anthropic-version": "2023-06-01",
+    },
+  });
+
+  return res.ok;
+}

package/config/client.ts

@@ -0,0 +1,163 @@
+import { GoogleGenAI, Type } from "@google/genai";
+import { toolRegistery } from "../tools";
+import { SYSTEM_PROMPT } from "./systemPrompt";
+import type { Message, ProviderClient, StreamEvent } from "./types";
+
+export const ACTIVE_PROVIDER_MODELS: Record<string, string> = {
+  google: "Gemini 3.5 Flash Lite",
+};
+
+export function geminiClient(apiKey: string): ProviderClient {
+  const ai = new GoogleGenAI({ apiKey });
+
+  return {
+    async *stream(
+      messages: Message[],
+      repoContext: string,
+      signal?: AbortSignal,
+    ): AsyncGenerator<StreamEvent> {
+      const contents = messages.map((message) => {
+        switch (message.role) {
+          case "user":
+            return {
+              role: "user",
+              parts: [{ text: message.content }],
+            };
+
+          case "assistant":
+            return {
+              role: "model",
+              parts: [{ text: message.content }],
+            };
+
+          case "assistant_tool_call":
+            return {
+              role: "model",
+              parts: [
+                {
+                  functionCall: {
+                    id: message.toolCallId,
+                    name: message.toolName,
+                    args: message.arguments,
+                  },
+                  thoughtSignature: message.thoughtSignature,
+                },
+              ],
+            };
+
+          case "tool":
+            return {
+              role: "user",
+              parts: [
+                {
+                  functionResponse: {
+                    name: message.toolName,
+                    response: {
+                      result: message.content,
+                    },
+                  },
+                },
+              ],
+            };
+        }
+      });
+      const tools = [
+        {
+          functionDeclarations: toolRegistery.map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            parameters: {
+              type: Type.OBJECT,
+              properties: Object.fromEntries(
+                tool.parameters.map((param) => [
+                  param.name,
+                  {
+                    type: Type.STRING,
+                    description: param.description,
+                  },
+                ]),
+              ),
+              required: tool.parameters
+                .filter((param) => param.required)
+                .map((param) => param.name),
+            },
+          })),
+        },
+      ];
+      // console.time("generateContentStream");
+      // console.log("Repo Context:", repoContext.length);
+      // console.log("Messages:", JSON.stringify(contents).length);
+      // console.log("System:", SYSTEM_PROMPT.length);
+      const stream = await ai.models.generateContentStream({
+        model: "gemini-3.5-flash-lite",
+        contents,
+
+        config: {
+          systemInstruction: `${SYSTEM_PROMPT}\n\nRepository Context:\n${repoContext}`,
+          tools,
+          abortSignal: signal,
+        },
+      });
+      // console.timeEnd("generateContentStream");
+
+      for await (const chunk of stream) {
+        // console.time("first-sdk-chunk");
+        // console.timeEnd("first-sdk-chunk");
+        const part = chunk.candidates?.[0]?.content?.parts?.find(
+          (p) => p.functionCall,
+        );
+
+        if (part?.functionCall) {
+          yield {
+            type: "tool_call",
+            id: part.functionCall.id ?? crypto.randomUUID(),
+            name: part.functionCall.name!,
+            arguments: part.functionCall.args ?? {},
+            thoughtSignature: part.thoughtSignature,
+          };
+
+          continue;
+        }
+        const text = chunk.text;
+
+        if (text) {
+          yield {
+            type: "text",
+            content: text,
+          };
+        }
+      }
+
+      yield {
+        type: "done",
+      };
+    },
+  };
+}
+
+export function groqClient(apiKey: string) {}
+export function openAIClient(apiKey: string) {}
+export function anthropicClient(apiKey: string) {}
+
+export function createProviderClient(
+  provider: string,
+  apiKey: string,
+): ProviderClient {
+  switch (provider) {
+    case "google":
+
+    case "gemini":
+      return geminiClient(apiKey);
+    // case "groq":
+    //   return groqClient(apiKey);
+
+    // case "openai":
+    //   return openAIClient(apiKey);
+
+    // case "anthropic":
+    //   return anthropicClient(apiKey);
+
+    default:
+      throw new Error(`Unsupported provider: ${provider}`);
+  }
+}