woopcode 0.1.0 → 0.2.0

package/commands/agent.tsx

@@ -1,20 +1,13 @@
 import { Command } from "commander";
-import {
-  buildRepositoryContext,
-  getConfig,
-  getConversation,
-  saveConversation,
-} from "../config/config";
-import { createProviderClient } from "../config/client";
-import type { Message } from "../config/types";
+import { getConfig } from "../config/config";
 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";
+import { registerCommands } from "./slash";
 
 export const agentCommand = new Command("agent")
   .description("Runs the agent")
@@ -23,6 +16,9 @@ export const agentCommand = new Command("agent")
 
 /** Runs the interactive agent from either `woopcode` or `woopcode agent`. */
 export async function runAgent() {
+  // Register slash commands
+  registerCommands();
+
   // Ensure provider is configured (launches onboarding if needed)
   await ensureProviderConfigured();
 
@@ -32,48 +28,48 @@ export async function runAgent() {
   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();
+    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");
-      },
-
-      onError(error) {
-        store.finishAssistantMessage();
-        store.setStatus(`Error: ${error.message}`);
-      },
-
-      onCancel() {
-        store.finishAssistantMessage();
-        store.setStatus("Cancelled");
-
-        cancelStatusTimeout = setTimeout(() => {
-          store.setStatus("Ready");
-        }, 1000);
-      },
+      }, 1000);
+    },
   };
   const controller = new AgentController(provider, apiKey, callbacks);
   await controller.initialize();
@@ -102,7 +98,8 @@ export async function runAgent() {
 }
 
 async function buildHomeScreen(provider: string): Promise<HomeScreenData> {
-  const repository = process.cwd().split("/").filter(Boolean).at(-1) ?? "workspace";
+  const repository =
+    process.cwd().split("/").filter(Boolean).at(-1) ?? "workspace";
   const branch = await getBranch();
   const providerLabel = provider === "google" ? "Gemini" : titleCase(provider);
 
@@ -117,7 +114,15 @@ async function buildHomeScreen(provider: string): Promise<HomeScreenData> {
       "Optimize performance",
       "Add authentication",
     ],
-    capabilities: ["Build", "Review", "Explain", "Refactor", "Debug", "Test", "Document"],
+    capabilities: [
+      "Build",
+      "Review",
+      "Explain",
+      "Refactor",
+      "Debug",
+      "Test",
+      "Document",
+    ],
     repository,
     branch,
     providerName: providerLabel,

package/commands/slash/README.md

@@ -0,0 +1,104 @@
+# Slash Commands
+
+Local commands that execute instantly without invoking the LLM.
+
+## Available Commands
+
+### Session Commands
+
+- **`/new`** (aliases: `clear`, `reset`) - Start a new conversation
+- **`/exit`** (aliases: `quit`, `q`) - Exit Woopcode
+
+### Configuration Commands
+
+- **`/provider [name]`** (alias: `p`) - Show current provider or switch to another
+  - Without arguments: Shows current provider and all available providers
+  - With provider name: Switches to the specified provider (if configured)
+  
+- **`/model`** (alias: `m`) - Show current model and available models
+  - Currently read-only; model switching will be added in future versions
+
+### Workspace Commands
+
+- **`/workspace`** (alias: `ws`) - Show workspace information
+  - Displays: workspace name, path, git branch, file count
+
+- **`/status`** (alias: `info`) - Show comprehensive system status
+  - Displays: workspace info, provider, model, conversation stats, tools, version
+
+### Other Commands
+
+- **`/help`** (aliases: `h`, `?`) - Show all available commands
+- **`/version`** (alias: `v`) - Show Woopcode version
+
+## Discovery Mode
+
+Type `/` alone to see a quick list of all available commands.
+
+## Architecture
+
+The slash command system consists of:
+
+- **Parser** (`parser.ts`) - Parses user input into commands and arguments
+- **Registry** (`registry.ts`) - Manages command registration and lookup
+- **Handler** (`handler.ts`) - Executes commands and handles errors
+- **Commands** (`commands.ts`) - All command implementations
+
+### Adding New Commands
+
+1. Define command in `commands.ts`:
+
+```typescript
+const myCommand: SlashCommand = {
+  name: "mycommand",
+  aliases: ["mc", "mycmd"],
+  description: "Does something useful",
+  category: "other", // session | configuration | workspace | other
+  
+  async execute(context, args) {
+    // Implementation
+    return "Command output";
+  }
+};
+```
+
+2. Register in `registerCommands()`:
+
+```typescript
+export function registerCommands() {
+  // ... existing commands
+  registry.register(myCommand);
+}
+```
+
+That's it! The command will automatically appear in `/help` and support tab completion.
+
+## Integration
+
+Slash commands are intercepted in `tui/src/prompt.tsx` before being sent to the agent:
+
+```typescript
+const result = await handleSlashCommand(prompt, context);
+
+if (result.handled) {
+  // Command was executed, don't send to LLM
+  return;
+}
+
+// Otherwise continue to agent
+await controller.run(prompt);
+```
+
+## Testing
+
+Tests are located in `packages/tests/slash/`:
+
+- `parser.test.ts` - Parser logic
+- `registry.test.ts` - Command registry
+- `handler.test.ts` - Command execution
+
+Run tests:
+
+```bash
+bun test packages/tests/slash/
+```

package/commands/slash/commands.ts

@@ -0,0 +1,239 @@
+import type { SlashCommand, SlashCommandContext } from "./types";
+import { registry } from "./registry";
+import {
+  getConfig,
+  saveConfig,
+  getConversation,
+  saveConversation,
+} from "../../config/config";
+
+// Read version from package.json
+const packageJsonPath = `${import.meta.dir}/../../package.json`;
+const packageJson = await Bun.file(packageJsonPath).json();
+const version = packageJson.version as string;
+
+// Read models from models.json
+const modelsJsonPath = `${import.meta.dir}/../../config/models.json`;
+const modelsData = await Bun.file(modelsJsonPath).json();
+const models = modelsData as Array<{
+  id: string;
+  provider: string;
+  name: string;
+  contextWindow: number | string;
+}>;
+
+// ==================== SESSION COMMANDS ====================
+
+const helpCommand: SlashCommand = {
+  name: "help",
+  aliases: ["h", "?"],
+  description: "Show available commands",
+  category: "other",
+
+  async execute(context, args) {
+    return registry.generateHelp();
+  },
+};
+
+const newCommand: SlashCommand = {
+  name: "new",
+  aliases: ["clear", "reset"],
+  description: "Start a new conversation",
+  category: "session",
+
+  async execute(context, args) {
+    await saveConversation([]);
+    return "Started new conversation";
+  },
+};
+
+const exitCommand: SlashCommand = {
+  name: "exit",
+  aliases: ["quit", "q"],
+  description: "Exit Woopcode",
+  category: "session",
+
+  async execute(context, args) {
+    await context.onExit();
+    return "Exiting...";
+  },
+};
+
+// ==================== CONFIGURATION COMMANDS ====================
+
+const providerCommand: SlashCommand = {
+  name: "provider",
+  aliases: ["p"],
+  description: "Show or switch provider",
+  category: "configuration",
+  usage: "/provider [provider-name]",
+
+  async execute(context, args) {
+    const config = await getConfig();
+
+    if (args.length === 0) {
+      const current = config.defaultProvider;
+      const providers = Object.entries(config.providers)
+        .map(([name, details]: [string, any]) => {
+          const status = details.apiKey ? "✓" : "✗";
+          const active = name === current ? "(active)" : "";
+          return `  ${status} ${name} ${active}`;
+        })
+        .join("\n");
+
+      return `Current Provider: ${current}\n\nAvailable:\n${providers}`;
+    }
+
+    const newProvider = args[0];
+    if (!newProvider) {
+      return `Provider name required.\nUsage: /provider <provider-name>`;
+    }
+    
+    const available = Object.keys(config.providers);
+
+    if (!available.includes(newProvider)) {
+      return `Provider "${newProvider}" not found.\nAvailable: ${available.join(", ")}`;
+    }
+
+    const providerConfig = config.providers[newProvider];
+    if (!providerConfig || !providerConfig.apiKey) {
+      return `Provider "${newProvider}" not configured.\nRun: woopcode providers login -p ${newProvider}`;
+    }
+
+    config.defaultProvider = newProvider;
+    await saveConfig(config);
+
+    return `Switched to: ${newProvider}`;
+  },
+};
+
+const modelCommand: SlashCommand = {
+  name: "model",
+  aliases: ["m"],
+  description: "Show current model and available models",
+  category: "configuration",
+
+  async execute(context, args) {
+    const config = await getConfig();
+    const provider = config.defaultProvider;
+
+    // Show current model (read-only for now)
+    let output = `Current Model: gemini-3.5-flash-lite\n\n`;
+
+    // List available models for current provider
+    const providerModels = models.filter((m) => m.provider === provider);
+
+    if (providerModels.length > 0) {
+      output += `Available models for ${provider}:\n`;
+      providerModels.forEach((m) => {
+        output += `  ${m.id} - ${m.name}\n`;
+      });
+    }
+
+    return output.trim();
+  },
+};
+
+// ==================== WORKSPACE COMMANDS ====================
+
+const workspaceCommand: SlashCommand = {
+  name: "workspace",
+  aliases: ["ws"],
+  description: "Show workspace information",
+  category: "workspace",
+
+  async execute(context, args) {
+    const cwd = process.cwd();
+    const parts = cwd.split("/").filter(Boolean);
+    const repoName = parts[parts.length - 1] ?? "unknown";
+
+    let branch = "not a git repository";
+    try {
+      branch =
+        (await Bun.$`git branch --show-current`.text()).trim() || "detached";
+    } catch {}
+
+    let fileCount = 0;
+    try {
+      for await (const entry of new Bun.Glob("**/*").scan(cwd)) {
+        if (
+          !entry.startsWith("node_modules") &&
+          !entry.startsWith(".git") &&
+          !entry.startsWith("dist")
+        ) {
+          fileCount++;
+        }
+      }
+    } catch {}
+
+    return [
+      `Workspace: ${repoName}`,
+      `Path: ${cwd}`,
+      `Branch: ${branch}`,
+      `Files: ${fileCount > 0 ? fileCount : "counting..."}`,
+    ].join("\n");
+  },
+};
+
+const statusCommand: SlashCommand = {
+  name: "status",
+  aliases: ["info"],
+  description: "Show comprehensive system status",
+  category: "other",
+
+  async execute(context, args) {
+    const config = await getConfig();
+    const conversation = await getConversation();
+    const cwd = process.cwd();
+    const parts = cwd.split("/").filter(Boolean);
+    const repoName = parts[parts.length - 1] ?? "workspace";
+
+    let branch = "not a git repository";
+    try {
+      branch =
+        (await Bun.$`git branch --show-current`.text()).trim() || "detached";
+    } catch {}
+
+    const provider = config.defaultProvider;
+    const providerLabel = provider === "google" ? "Google Gemini" : provider;
+
+    return [
+      `Workspace: ${repoName}`,
+      `Path: ${cwd}`,
+      `Branch: ${branch}`,
+      ``,
+      `Provider: ${providerLabel}`,
+      `Model: gemini-3.5-flash-lite`,
+      ``,
+      `Conversation: ${conversation.length} messages`,
+      `Tools: 9 registered`,
+      `Version: ${version}`,
+    ].join("\n");
+  },
+};
+
+// ==================== OTHER COMMANDS ====================
+
+const versionCommand: SlashCommand = {
+  name: "version",
+  aliases: ["v"],
+  description: "Show Woopcode version",
+  category: "other",
+
+  async execute(context, args) {
+    return `Woopcode v${version}`;
+  },
+};
+
+// ==================== REGISTRATION ====================
+
+export function registerCommands() {
+  registry.register(helpCommand);
+  registry.register(newCommand);
+  registry.register(exitCommand);
+  registry.register(providerCommand);
+  registry.register(modelCommand);
+  registry.register(workspaceCommand);
+  registry.register(statusCommand);
+  registry.register(versionCommand);
+}

package/commands/slash/handler.ts

@@ -0,0 +1,40 @@
+import { parseInput } from "./parser";
+import { registry } from "./registry";
+import type { SlashCommandContext } from "./types";
+
+export async function handleSlashCommand(
+  input: string,
+  context: SlashCommandContext,
+): Promise<{ handled: boolean; output?: string }> {
+  const parsed = parseInput(input);
+
+  // Discovery mode: show available commands
+  if (parsed.type === "discovery") {
+    const output = registry.generateDiscoveryList();
+    context.onOutput(output);
+    return { handled: true, output };
+  }
+
+  if (parsed.type !== "command") {
+    return { handled: false };
+  }
+
+  const command = registry.get(parsed.command!);
+
+  if (!command) {
+    const output = `Unknown command "/${parsed.command}"\nRun /help to see available commands.`;
+    context.onOutput(output);
+    return { handled: true, output };
+  }
+
+  try {
+    const output = await command.execute(context, parsed.args!);
+    context.onOutput(output);
+    return { handled: true, output };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const output = `Error: ${message}`;
+    context.onOutput(output);
+    return { handled: true, output };
+  }
+}

package/commands/slash/index.ts

@@ -0,0 +1,9 @@
+export { handleSlashCommand } from "./handler";
+export { registry } from "./registry";
+export { registerCommands } from "./commands";
+export { parseInput } from "./parser";
+export type {
+  SlashCommand,
+  SlashCommandContext,
+  ParsedCommand,
+} from "./types";

package/commands/slash/parser.ts

@@ -0,0 +1,25 @@
+import type { ParsedCommand } from "./types";
+
+export function parseInput(input: string): ParsedCommand {
+  const trimmed = input.trim();
+
+  //discovery mode
+  if (trimmed === "/") {
+    return { type: "discovery", originalInput: input };
+  }
+
+  if (!trimmed.startsWith("/")) {
+    return { type: "text", originalInput: input };
+  }
+
+  const parts = trimmed.slice(1).split(/\s+/);
+  const command = parts[0]?.toLowerCase() || "";
+  const args = parts.slice(1);
+
+  return {
+    type: "command",
+    command,
+    args,
+    originalInput: input,
+  };
+}

package/commands/slash/registry.ts

@@ -0,0 +1,66 @@
+import type { SlashCommand } from "./types";
+
+export class SlashCommandRegistry {
+  private commands = new Map<string, SlashCommand>();
+  private aliases = new Map<string, string>();
+
+  register(command: SlashCommand): void {
+    this.commands.set(command.name, command);
+    
+    if (command.aliases) {
+      command.aliases.forEach((alias) => {
+        this.aliases.set(alias, command.name);
+      });
+    }
+  }
+
+  get(nameOrAlias: string): SlashCommand | undefined {
+    const name = this.aliases.get(nameOrAlias) ?? nameOrAlias;
+    return this.commands.get(name);
+  }
+
+  getAll(): SlashCommand[] {
+    return Array.from(this.commands.values());
+  }
+
+  getByCategory(category: string): SlashCommand[] {
+    return this.getAll().filter((cmd) => cmd.category === category);
+  }
+
+  // Auto-generated help
+  generateHelp(): string {
+    const categories = {
+      session: "Session",
+      configuration: "Configuration",
+      workspace: "Workspace",
+      other: "Other",
+    };
+
+    let output = "Available Commands:\n\n";
+
+    for (const [key, label] of Object.entries(categories)) {
+      const commands = this.getByCategory(key);
+      if (commands.length === 0) continue;
+
+      output += `${label}:\n`;
+      commands.forEach((cmd) => {
+        const aliases = cmd.aliases?.length
+          ? ` (${cmd.aliases.join(", ")})`
+          : "";
+        output += `  /${cmd.name}${aliases} - ${cmd.description}\n`;
+      });
+      output += "\n";
+    }
+
+    return output.trim();
+  }
+
+  // 🔥 Discovery list
+  generateDiscoveryList(): string {
+    return this.getAll()
+      .map((cmd) => `/${cmd.name}`)
+      .join("  ");
+  }
+}
+
+export const registry = new SlashCommandRegistry();

package/commands/slash/types.ts

@@ -0,0 +1,23 @@
+import type { AgentController } from "../agentController";
+
+export interface SlashCommandContext {
+  controller: AgentController;
+  onExit: () => Promise<void>;
+  onOutput: (message: string) => void;
+}
+
+export interface SlashCommand {
+  name: string;
+  aliases?: string[];
+  description: string;
+  category: "session" | "configuration" | "workspace" | "other";
+  usage?: string;
+  execute(context: SlashCommandContext, args: string[]): Promise<string>;
+}
+
+export interface ParsedCommand {
+  type: "command" | "text" | "discovery";
+  command?: string;
+  args?: string[];
+  originalInput?: string;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "woopcode",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "An autonomous AI coding assistant built for the terminal",
   "license": "MIT",
   "author": {
@@ -62,8 +62,7 @@
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
     "marked": "^18.0.7",
-    "react": "^19.2.7",
-    "woopcode": "file:woopcode-0.1.0.tgz"
+    "react": "^19.2.7"
   },
   "devDependencies": {
     "@stryker-mutator/core": "^9.6.1",

package/tui/src/prompt.tsx

@@ -2,6 +2,8 @@ import { Box, Text, useInput } from "ink";
 import TextInput from "ink-text-input";
 import { useRef } from "react";
 import type { AgentController } from "../../commands/agentController";
+import { handleSlashCommand } from "../../commands/slash";
+import { store } from "./store/ui-store";
 
 interface PromptProps {
   controller: AgentController;
@@ -42,6 +44,24 @@ export function Prompt({
     if (!prompt || controller.isBusy()) {
       return;
     }
+
+    // 🔥 Slash command interception
+    const context = {
+      controller,
+      onExit,
+      onOutput: (message: string) => {
+        store.addSystemMessage(message);
+      },
+    };
+
+    const result = await handleSlashCommand(prompt, context);
+
+    if (result.handled) {
+      onValueChange("");
+      return;
+    }
+
+    // Original flow
     if (prompt === "/exit") {
       await onExit();
       return;

package/tui/src/store/ui-store.ts

@@ -59,6 +59,22 @@ export class UIStore {
     this.emit();
   }
 
+  addSystemMessage(content: string) {
+    this.state = {
+      ...this.state,
+      timeline: [
+        ...this.state.timeline,
+        {
+          id: crypto.randomUUID(),
+          type: "system",
+          content,
+        },
+      ],
+    };
+
+    this.emit();
+  }
+
   startTool(tool: ToolCall) {
     this.state = {
       ...this.state,

package/tui/src/timeline.tsx

@@ -47,6 +47,18 @@ function TimelineItem({ item }: { item: TimeLineItem }) {
         </Box>
       );
 
+    case "system":
+      return (
+        <Box flexDirection="column" marginBottom={1}>
+          <Text bold color="yellow">
+            System
+          </Text>
+          <Box paddingLeft={1}>
+            <Text>{item.content}</Text>
+          </Box>
+        </Box>
+      );
+
     case "tool": {
       const label = toolLabel(item.name);
       const target = formatToolArgument(item.arguments);

package/tui/src/types.ts

@@ -10,6 +10,11 @@ export type TimeLineItem =
       content: string;
       streaming: boolean;
     }
+  | {
+      id: string;
+      type: "system";
+      content: string;
+    }
   | {
       id: string;
       type: "tool";