@hasna/oldpal 0.1.7 → 0.1.9

package/dist/index.js

@@ -20450,12 +20450,12 @@ var exports_anthropic = {};
 __export(exports_anthropic, {
   AnthropicClient: () => AnthropicClient
 });
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
+import { readFileSync as readFileSync2, existsSync as existsSync4 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
 function loadApiKeyFromSecrets() {
-  const secretsPath = join4(homedir3(), ".secrets");
-  if (existsSync2(secretsPath)) {
+  const secretsPath = join6(homedir5(), ".secrets");
+  if (existsSync4(secretsPath)) {
     try {
       const content = readFileSync2(secretsPath, "utf-8");
       const match = content.match(/export\s+ANTHROPIC_API_KEY\s*=\s*["']?([^"'\n]+)["']?/);
@@ -29187,6 +29187,194 @@ class FilesystemTools {
   };
 }
 
+// packages/core/src/tools/web.ts
+class WebFetchTool {
+  static tool = {
+    name: "web_fetch",
+    description: "Fetch content from a URL and return the text content. Useful for reading web pages, documentation, API responses, etc.",
+    parameters: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to fetch content from"
+        },
+        extract_type: {
+          type: "string",
+          description: 'What to extract: "text" for readable text, "html" for raw HTML, "json" for JSON response',
+          enum: ["text", "html", "json"],
+          default: "text"
+        },
+        timeout: {
+          type: "number",
+          description: "Timeout in milliseconds (default: 30000)"
+        }
+      },
+      required: ["url"]
+    }
+  };
+  static executor = async (input) => {
+    const url = input.url;
+    const extractType = input.extract_type || "text";
+    const timeout = input.timeout || 30000;
+    try {
+      const parsedUrl = new URL(url);
+      const hostname = parsedUrl.hostname;
+      if (hostname === "localhost" || hostname === "127.0.0.1" || hostname.startsWith("192.168.") || hostname.startsWith("10.") || hostname.startsWith("172.")) {
+        return "Error: Cannot fetch from local/private network addresses for security reasons";
+      }
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const response = await fetch(url, {
+        signal: controller.signal,
+        headers: {
+          "User-Agent": "oldpal/1.0 (AI Assistant)",
+          Accept: extractType === "json" ? "application/json" : "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        }
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        return `Error: HTTP ${response.status} ${response.statusText}`;
+      }
+      const contentType = response.headers.get("content-type") || "";
+      if (extractType === "json") {
+        try {
+          const json = await response.json();
+          return JSON.stringify(json, null, 2);
+        } catch {
+          return "Error: Response is not valid JSON";
+        }
+      }
+      const html = await response.text();
+      if (extractType === "html") {
+        const maxLength2 = 50000;
+        if (html.length > maxLength2) {
+          return html.slice(0, maxLength2) + `
+
+[Content truncated...]`;
+        }
+        return html;
+      }
+      const text = extractReadableText(html);
+      const maxLength = 30000;
+      if (text.length > maxLength) {
+        return text.slice(0, maxLength) + `
+
+[Content truncated...]`;
+      }
+      return text || "No readable content found on page";
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.name === "AbortError") {
+          return `Error: Request timed out after ${timeout}ms`;
+        }
+        return `Error: ${error.message}`;
+      }
+      return `Error: ${String(error)}`;
+    }
+  };
+}
+
+class WebSearchTool {
+  static tool = {
+    name: "web_search",
+    description: "Search the web using DuckDuckGo and return results. Useful for finding current information, documentation, news, etc.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query"
+        },
+        max_results: {
+          type: "number",
+          description: "Maximum number of results to return (default: 5, max: 10)"
+        }
+      },
+      required: ["query"]
+    }
+  };
+  static executor = async (input) => {
+    const query = input.query;
+    const maxResults = Math.min(input.max_results || 5, 10);
+    try {
+      const searchUrl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
+      const response = await fetch(searchUrl, {
+        headers: {
+          "User-Agent": "oldpal/1.0 (AI Assistant)",
+          Accept: "text/html"
+        }
+      });
+      if (!response.ok) {
+        return `Error: Search request failed with HTTP ${response.status}`;
+      }
+      const html = await response.text();
+      const results = parseDuckDuckGoResults(html, maxResults);
+      if (results.length === 0) {
+        return `No results found for "${query}"`;
+      }
+      let output = `Search results for "${query}":
+
+`;
+      for (let i = 0;i < results.length; i++) {
+        const r = results[i];
+        output += `${i + 1}. ${r.title}
+`;
+        output += `   ${r.url}
+`;
+        if (r.snippet) {
+          output += `   ${r.snippet}
+`;
+        }
+        output += `
+`;
+      }
+      return output.trim();
+    } catch (error) {
+      return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  };
+}
+function extractReadableText(html) {
+  let text = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "").replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "").replace(/<noscript[^>]*>[\s\S]*?<\/noscript>/gi, "").replace(/<nav[^>]*>[\s\S]*?<\/nav>/gi, "").replace(/<footer[^>]*>[\s\S]*?<\/footer>/gi, "").replace(/<header[^>]*>[\s\S]*?<\/header>/gi, "");
+  text = text.replace(/<\/?(p|div|br|h[1-6]|li|tr|blockquote)[^>]*>/gi, `
+`).replace(/<\/?[^>]+>/g, " ").replace(/&nbsp;/gi, " ").replace(/&amp;/gi, "&").replace(/&lt;/gi, "<").replace(/&gt;/gi, ">").replace(/&quot;/gi, '"').replace(/&#39;/gi, "'").replace(/\s+/g, " ").replace(/\n\s*\n/g, `
+
+`).trim();
+  return text;
+}
+function parseDuckDuckGoResults(html, maxResults) {
+  const results = [];
+  const resultRegex = /<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([^<]*)<\/a>[\s\S]*?<a[^>]*class="result__snippet"[^>]*>([^<]*)/gi;
+  let match;
+  while ((match = resultRegex.exec(html)) !== null && results.length < maxResults) {
+    const url = decodeURIComponent(match[1].replace(/\/l\/\?uddg=/, "").split("&")[0]);
+    const title = match[2].trim();
+    const snippet = match[3].trim().replace(/&[^;]+;/g, " ");
+    if (url && title && !url.startsWith("//duckduckgo.com")) {
+      results.push({ title, url, snippet });
+    }
+  }
+  if (results.length === 0) {
+    const simpleRegex = /<a[^>]*href="(https?:\/\/[^"]+)"[^>]*class="[^"]*result[^"]*"[^>]*>([^<]+)/gi;
+    while ((match = simpleRegex.exec(html)) !== null && results.length < maxResults) {
+      const url = match[1];
+      const title = match[2].trim();
+      if (url && title) {
+        results.push({ title, url, snippet: "" });
+      }
+    }
+  }
+  return results;
+}
+
+class WebTools {
+  static registerAll(registry) {
+    registry.register(WebFetchTool.tool, WebFetchTool.executor);
+    registry.register(WebSearchTool.tool, WebSearchTool.executor);
+  }
+}
+
 // packages/core/src/skills/loader.ts
 import { join as join3 } from "path";
 import { homedir as homedir2 } from "os";
@@ -29455,7 +29643,609 @@ class HookExecutor {
     return null;
   }
 }
+// packages/core/src/commands/loader.ts
+import { existsSync as existsSync2, readdirSync, statSync } from "fs";
+import { join as join4, basename, extname } from "path";
+import { homedir as homedir3 } from "os";
+
+class CommandLoader {
+  commands = new Map;
+  cwd;
+  constructor(cwd2) {
+    this.cwd = cwd2 || process.cwd();
+  }
+  async loadAll() {
+    this.commands.clear();
+    const globalDir = join4(homedir3(), ".oldpal", "commands");
+    await this.loadFromDirectory(globalDir, "global");
+    const projectDir = join4(this.cwd, ".oldpal", "commands");
+    await this.loadFromDirectory(projectDir, "project");
+  }
+  async loadFromDirectory(dir, source, prefix = "") {
+    if (!existsSync2(dir))
+      return;
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      const fullPath = join4(dir, entry);
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        const newPrefix = prefix ? `${prefix}:${entry}` : entry;
+        await this.loadFromDirectory(fullPath, source, newPrefix);
+      } else if (stat.isFile() && extname(entry) === ".md") {
+        const command = await this.loadCommandFile(fullPath, prefix);
+        if (command) {
+          this.commands.set(command.name, command);
+        }
+      }
+    }
+  }
+  async loadCommandFile(filePath, prefix) {
+    try {
+      const content = await Bun.file(filePath).text();
+      const { frontmatter, body } = this.parseFrontmatter(content);
+      const fileName = basename(filePath, ".md");
+      const name = frontmatter.name || (prefix ? `${prefix}:${fileName}` : fileName);
+      return {
+        name,
+        description: frontmatter.description || `Run the ${name} command`,
+        tags: frontmatter.tags,
+        allowedTools: frontmatter["allowed-tools"]?.split(",").map((t) => t.trim()),
+        content: body,
+        filePath,
+        builtin: false
+      };
+    } catch (error) {
+      console.error(`Failed to load command from ${filePath}:`, error);
+      return null;
+    }
+  }
+  parseFrontmatter(content) {
+    const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (!match) {
+      return { frontmatter: {}, body: content };
+    }
+    const [, yamlContent, body] = match;
+    const frontmatter = {};
+    const lines = yamlContent.split(`
+`);
+    for (const line of lines) {
+      const colonIndex = line.indexOf(":");
+      if (colonIndex === -1)
+        continue;
+      const key = line.slice(0, colonIndex).trim();
+      let value = line.slice(colonIndex + 1).trim();
+      if (value.startsWith("[") && value.endsWith("]")) {
+        const arrayContent = value.slice(1, -1);
+        frontmatter[key] = arrayContent.split(",").map((v) => v.trim());
+      } else {
+        if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+          value = value.slice(1, -1);
+        }
+        frontmatter[key] = value;
+      }
+    }
+    return { frontmatter, body: body.trim() };
+  }
+  register(command) {
+    this.commands.set(command.name, command);
+  }
+  getCommand(name) {
+    return this.commands.get(name);
+  }
+  getCommands() {
+    return Array.from(this.commands.values());
+  }
+  hasCommand(name) {
+    return this.commands.has(name);
+  }
+  findMatching(partial) {
+    const lower = partial.toLowerCase();
+    return this.getCommands().filter((cmd) => cmd.name.toLowerCase().startsWith(lower) || cmd.description.toLowerCase().includes(lower));
+  }
+}
+// packages/core/src/commands/executor.ts
+class CommandExecutor {
+  loader;
+  constructor(loader) {
+    this.loader = loader;
+  }
+  parseCommand(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith("/")) {
+      return null;
+    }
+    const match = trimmed.match(/^\/(\S+)(?:\s+(.*))?$/);
+    if (!match) {
+      return null;
+    }
+    return {
+      name: match[1],
+      args: match[2] || ""
+    };
+  }
+  isCommand(input) {
+    return this.parseCommand(input) !== null;
+  }
+  async execute(input, context) {
+    const parsed = this.parseCommand(input);
+    if (!parsed) {
+      return { handled: false };
+    }
+    const command = this.loader.getCommand(parsed.name);
+    if (!command) {
+      context.emit("text", `Unknown command: /${parsed.name}
+
+Use /help to see available commands.
+`);
+      context.emit("done");
+      return { handled: true };
+    }
+    if (command.selfHandled && command.handler) {
+      return command.handler(parsed.args, context);
+    }
+    const prompt = await this.preparePrompt(command, parsed.args);
+    return {
+      handled: false,
+      prompt
+    };
+  }
+  async preparePrompt(command, args) {
+    let content = command.content;
+    content = content.replace(/\$ARGUMENTS/g, args || "(no arguments provided)");
+    content = await this.processShellCommands(content);
+    return content;
+  }
+  async processShellCommands(content) {
+    const lines = content.split(`
+`);
+    const processedLines = [];
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("!")) {
+        const command = trimmed.slice(1).trim();
+        const output = await this.executeShell(command);
+        processedLines.push(`\`\`\`
+${output}
+\`\`\``);
+      } else {
+        processedLines.push(line);
+      }
+    }
+    return processedLines.join(`
+`);
+  }
+  async executeShell(command) {
+    try {
+      const proc = Bun.spawn(["bash", "-c", command], {
+        stdout: "pipe",
+        stderr: "pipe"
+      });
+      const [stdout, stderr] = await Promise.all([
+        new Response(proc.stdout).text(),
+        new Response(proc.stderr).text()
+      ]);
+      const exitCode = await proc.exited;
+      if (exitCode !== 0 && stderr) {
+        return `Error (exit ${exitCode}):
+${stderr}`;
+      }
+      return stdout.trim() || "(no output)";
+    } catch (error) {
+      return `Error: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  }
+  getSuggestions(partial) {
+    if (!partial.startsWith("/")) {
+      return [];
+    }
+    const name = partial.slice(1).toLowerCase();
+    return this.loader.findMatching(name);
+  }
+}
+// packages/core/src/commands/builtin.ts
+import { join as join5 } from "path";
+import { homedir as homedir4 } from "os";
+import { existsSync as existsSync3, mkdirSync, writeFileSync } from "fs";
+
+class BuiltinCommands {
+  tokenUsage = {
+    inputTokens: 0,
+    outputTokens: 0,
+    totalTokens: 0,
+    maxContextTokens: 200000
+  };
+  registerAll(loader) {
+    loader.register(this.helpCommand(loader));
+    loader.register(this.clearCommand());
+    loader.register(this.statusCommand());
+    loader.register(this.compactCommand());
+    loader.register(this.configCommand());
+    loader.register(this.initCommand());
+    loader.register(this.costCommand());
+    loader.register(this.modelCommand());
+    loader.register(this.memoryCommand());
+    loader.register(this.bugCommand());
+    loader.register(this.prCommand());
+    loader.register(this.reviewCommand());
+  }
+  updateTokenUsage(usage) {
+    Object.assign(this.tokenUsage, usage);
+  }
+  getTokenUsage() {
+    return { ...this.tokenUsage };
+  }
+  helpCommand(loader) {
+    return {
+      name: "help",
+      description: "Show available slash commands",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        const commands = loader.getCommands();
+        const builtinCmds = commands.filter((c) => c.builtin);
+        const customCmds = commands.filter((c) => !c.builtin);
+        let message = `
+**Available Slash Commands**
+
+`;
+        if (builtinCmds.length > 0) {
+          message += `**Built-in Commands:**
+`;
+          for (const cmd of builtinCmds.sort((a, b) => a.name.localeCompare(b.name))) {
+            message += `  /${cmd.name} - ${cmd.description}
+`;
+          }
+          message += `
+`;
+        }
+        if (customCmds.length > 0) {
+          message += `**Custom Commands:**
+`;
+          for (const cmd of customCmds.sort((a, b) => a.name.localeCompare(b.name))) {
+            message += `  /${cmd.name} - ${cmd.description}
+`;
+          }
+          message += `
+`;
+        }
+        message += `**Tips:**
+`;
+        message += `  - Create custom commands in .oldpal/commands/*.md
+`;
+        message += `  - Global commands go in ~/.oldpal/commands/*.md
+`;
+        message += `  - Use /init to create a starter command
+`;
+        context.emit("text", message);
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
+  clearCommand() {
+    return {
+      name: "clear",
+      description: "Clear conversation history and start fresh",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        context.clearMessages();
+        this.tokenUsage.inputTokens = 0;
+        this.tokenUsage.outputTokens = 0;
+        this.tokenUsage.totalTokens = 0;
+        context.emit("text", `Conversation cleared. Starting fresh.
+`);
+        context.emit("done");
+        return { handled: true, clearConversation: true };
+      }
+    };
+  }
+  statusCommand() {
+    return {
+      name: "status",
+      description: "Show current session status and token usage",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        const usage = this.tokenUsage;
+        const usedPercent = Math.round(usage.totalTokens / usage.maxContextTokens * 100);
+        let message = `
+**Session Status**
+
+`;
+        message += `**Working Directory:** ${context.cwd}
+`;
+        message += `**Session ID:** ${context.sessionId}
+`;
+        message += `**Messages:** ${context.messages.length}
+`;
+        message += `**Available Tools:** ${context.tools.length}
+
+`;
+        message += `**Token Usage:**
+`;
+        message += `  Input: ${usage.inputTokens.toLocaleString()}
+`;
+        message += `  Output: ${usage.outputTokens.toLocaleString()}
+`;
+        message += `  Total: ${usage.totalTokens.toLocaleString()} / ${usage.maxContextTokens.toLocaleString()} (${usedPercent}%)
+`;
+        if (usage.cacheReadTokens || usage.cacheWriteTokens) {
+          message += `  Cache Read: ${(usage.cacheReadTokens || 0).toLocaleString()}
+`;
+          message += `  Cache Write: ${(usage.cacheWriteTokens || 0).toLocaleString()}
+`;
+        }
+        const barLength = 30;
+        const filledLength = Math.round(usedPercent / 100 * barLength);
+        const bar = "\u2588".repeat(filledLength) + "\u2591".repeat(barLength - filledLength);
+        message += `
+  [${bar}] ${usedPercent}%
+`;
+        context.emit("text", message);
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
+  compactCommand() {
+    return {
+      name: "compact",
+      description: "Summarize conversation to save context space",
+      builtin: true,
+      selfHandled: false,
+      content: `Please summarize our conversation so far into a concise format that preserves:
+1. Key decisions made
+2. Important context about the codebase
+3. Current task/goal we're working on
+4. Any constraints or requirements mentioned
+
+Format the summary as a brief bullet-point list. This summary will replace the conversation history to save context space.`
+    };
+  }
+  configCommand() {
+    return {
+      name: "config",
+      description: "Show current configuration",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        const configPaths = [
+          join5(context.cwd, ".oldpal", "config.json"),
+          join5(homedir4(), ".oldpal", "config.json")
+        ];
+        let message = `
+**Configuration**
+
+`;
+        message += `**Config File Locations:**
+`;
+        for (const path of configPaths) {
+          const exists = existsSync3(path);
+          message += `  ${exists ? "\u2713" : "\u25CB"} ${path}
+`;
+        }
+        message += `
+**Commands Directories:**
+`;
+        message += `  - Project: ${join5(context.cwd, ".oldpal", "commands")}
+`;
+        message += `  - Global: ${join5(homedir4(), ".oldpal", "commands")}
+`;
+        context.emit("text", message);
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
+  initCommand() {
+    return {
+      name: "init",
+      description: "Initialize oldpal config and create example command",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        const commandsDir = join5(context.cwd, ".oldpal", "commands");
+        mkdirSync(commandsDir, { recursive: true });
+        const exampleCommand = `---
+name: review
+description: Review code changes for issues and improvements
+tags: [code, review]
+---
+
+# Code Review
+
+Please review the current code changes and provide feedback on:
+
+1. **Code Quality**
+   - Readability and maintainability
+   - Following project conventions
+   - Proper error handling
+
+2. **Potential Issues**
+   - Security vulnerabilities
+   - Performance concerns
+   - Edge cases not handled
+
+3. **Suggestions**
+   - Improvements to consider
+   - Best practices to apply
+   - Documentation needs
+
+If there are staged git changes, focus on those. Otherwise, ask what code to review.
+`;
+        const examplePath = join5(commandsDir, "review.md");
+        if (!existsSync3(examplePath)) {
+          writeFileSync(examplePath, exampleCommand);
+        }
+        let message = `
+**Initialized oldpal**
+
+`;
+        message += `Created: ${commandsDir}
+`;
+        message += `Example: ${examplePath}
+
+`;
+        message += `You can now:
+`;
+        message += `  - Add custom commands to .oldpal/commands/
+`;
+        message += `  - Use /review to try the example command
+`;
+        message += `  - Run /help to see all available commands
+`;
+        context.emit("text", message);
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
+  costCommand() {
+    return {
+      name: "cost",
+      description: "Show estimated API cost for this session",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        const usage = this.tokenUsage;
+        const inputCostPer1M = 3;
+        const outputCostPer1M = 15;
+        const inputCost = usage.inputTokens / 1e6 * inputCostPer1M;
+        const outputCost = usage.outputTokens / 1e6 * outputCostPer1M;
+        const totalCost = inputCost + outputCost;
+        const cacheReadCostPer1M = 0.3;
+        const cacheSavings = usage.cacheReadTokens ? usage.cacheReadTokens / 1e6 * (inputCostPer1M - cacheReadCostPer1M) : 0;
+        let message = `
+**Estimated Session Cost**
+
+`;
+        message += `Input tokens: ${usage.inputTokens.toLocaleString()} (~$${inputCost.toFixed(4)})
+`;
+        message += `Output tokens: ${usage.outputTokens.toLocaleString()} (~$${outputCost.toFixed(4)})
+`;
+        message += `**Total: ~$${totalCost.toFixed(4)}**
+`;
+        if (cacheSavings > 0) {
+          message += `
+Cache savings: ~$${cacheSavings.toFixed(4)}
+`;
+        }
+        message += `
+*Based on Claude 3.5 Sonnet pricing*
+`;
+        context.emit("text", message);
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
+  modelCommand() {
+    return {
+      name: "model",
+      description: "Show current model information",
+      builtin: true,
+      selfHandled: true,
+      content: "",
+      handler: async (args, context) => {
+        let message = `
+**Model Information**
+
+`;
+        message += `Current model: claude-3-5-sonnet-20241022
+`;
+        message += `Context window: 200,000 tokens
+`;
+        message += `Max output: 8,192 tokens
+
+`;
+        message += `*Model selection coming in a future update*
+`;
+        context.emit("text", message);
+        context.emit("done");
+        return { handled: true };
+      }
+    };
+  }
+  memoryCommand() {
+    return {
+      name: "memory",
+      description: "Show conversation summary and key memories",
+      builtin: true,
+      selfHandled: false,
+      content: `Please provide a summary of our conversation so far, including:
+
+1. **Key Context** - What you know about this project/codebase
+2. **Current Task** - What we're working on
+3. **Decisions Made** - Any choices or agreements from our discussion
+4. **Open Items** - Things we mentioned but haven't addressed yet
+
+Keep it concise but comprehensive.`
+    };
+  }
+  bugCommand() {
+    return {
+      name: "bug",
+      description: "Analyze and help fix a bug",
+      builtin: true,
+      selfHandled: false,
+      content: `Help me debug an issue. $ARGUMENTS
+
+Please:
+1. Understand the bug/error described
+2. Identify likely causes
+3. Search relevant code files
+4. Propose a fix with code changes
+
+If no bug is described, ask me to describe the issue I'm experiencing.`
+    };
+  }
+  prCommand() {
+    return {
+      name: "pr",
+      description: "Create a pull request for current changes",
+      builtin: true,
+      selfHandled: false,
+      content: `Help me create a pull request for the current changes.
+
+1. First, check git status and staged changes
+2. Review the diff to understand what changed
+3. Write a clear PR title (max 72 chars)
+4. Write a description with:
+   - Summary of changes
+   - Motivation/context
+   - Testing done
+   - Any notes for reviewers
+
+Then create the PR using the gh CLI.`
+    };
+  }
+  reviewCommand() {
+    return {
+      name: "review",
+      description: "Review code changes for issues",
+      builtin: true,
+      selfHandled: false,
+      content: `Review the current code changes. $ARGUMENTS
+
+Check for:
+1. **Bugs** - Logic errors, edge cases, null checks
+2. **Security** - Input validation, injection risks, secrets
+3. **Performance** - N+1 queries, unnecessary loops, memory leaks
+4. **Style** - Naming, formatting, code organization
+5. **Tests** - Coverage, edge cases, assertions
 
+If there are staged changes, review those. Otherwise, ask what to review.`
+    };
+  }
+}
 // packages/core/src/llm/client.ts
 async function createLLMClient(config) {
   if (config.provider === "anthropic") {
@@ -29466,8 +30256,8 @@ async function createLLMClient(config) {
 }
 
 // packages/core/src/config.ts
-import { join as join5 } from "path";
-import { homedir as homedir4 } from "os";
+import { join as join7 } from "path";
+import { homedir as homedir6 } from "os";
 var DEFAULT_CONFIG = {
   llm: {
     provider: "anthropic",
@@ -29497,13 +30287,13 @@ var DEFAULT_CONFIG = {
   ]
 };
 function getConfigDir() {
-  return join5(homedir4(), ".oldpal");
+  return join7(homedir6(), ".oldpal");
 }
 function getConfigPath(filename) {
-  return join5(getConfigDir(), filename);
+  return join7(getConfigDir(), filename);
 }
 function getProjectConfigDir(cwd2 = process.cwd()) {
-  return join5(cwd2, ".oldpal");
+  return join7(cwd2, ".oldpal");
 }
 async function loadConfig(cwd2 = process.cwd()) {
   const config = { ...DEFAULT_CONFIG };
@@ -29516,7 +30306,7 @@ async function loadConfig(cwd2 = process.cwd()) {
     if (userConfig.voice)
       config.voice = { ...config.voice, ...userConfig.voice };
   }
-  const projectConfigPath = join5(getProjectConfigDir(cwd2), "settings.json");
+  const projectConfigPath = join7(getProjectConfigDir(cwd2), "settings.json");
   const projectConfig = await loadJsonFile(projectConfigPath);
   if (projectConfig) {
     Object.assign(config, projectConfig);
@@ -29525,7 +30315,7 @@ async function loadConfig(cwd2 = process.cwd()) {
     if (projectConfig.voice)
       config.voice = { ...config.voice, ...projectConfig.voice };
   }
-  const localConfigPath = join5(getProjectConfigDir(cwd2), "settings.local.json");
+  const localConfigPath = join7(getProjectConfigDir(cwd2), "settings.local.json");
   const localConfig = await loadJsonFile(localConfigPath);
   if (localConfig) {
     Object.assign(config, localConfig);
@@ -29543,7 +30333,7 @@ async function loadHooksConfig(cwd2 = process.cwd()) {
   if (userHooks?.hooks) {
     mergeHooks(hooks, userHooks.hooks);
   }
-  const projectHooksPath = join5(getProjectConfigDir(cwd2), "hooks.json");
+  const projectHooksPath = join7(getProjectConfigDir(cwd2), "hooks.json");
   const projectHooks = await loadJsonFile(projectHooksPath);
   if (projectHooks?.hooks) {
     mergeHooks(hooks, projectHooks.hooks);
@@ -29579,16 +30369,22 @@ class AgentLoop {
   skillExecutor;
   hookLoader;
   hookExecutor;
+  commandLoader;
+  commandExecutor;
+  builtinCommands;
   llmClient = null;
   config = null;
   cwd;
+  sessionId;
   isRunning = false;
   shouldStop = false;
   onChunk;
   onToolStart;
   onToolEnd;
+  onTokenUsage;
   constructor(options = {}) {
     this.cwd = options.cwd || process.cwd();
+    this.sessionId = options.sessionId || generateId();
     this.context = new AgentContext;
     this.toolRegistry = new ToolRegistry;
     this.connectorBridge = new ConnectorBridge;
@@ -29596,22 +30392,29 @@ class AgentLoop {
     this.skillExecutor = new SkillExecutor;
     this.hookLoader = new HookLoader;
     this.hookExecutor = new HookExecutor;
+    this.commandLoader = new CommandLoader(this.cwd);
+    this.commandExecutor = new CommandExecutor(this.commandLoader);
+    this.builtinCommands = new BuiltinCommands;
     this.onChunk = options.onChunk;
     this.onToolStart = options.onToolStart;
     this.onToolEnd = options.onToolEnd;
+    this.onTokenUsage = options.onTokenUsage;
   }
   async initialize() {
     this.config = await loadConfig(this.cwd);
     this.llmClient = await createLLMClient(this.config.llm);
     this.toolRegistry.register(BashTool.tool, BashTool.executor);
     FilesystemTools.registerAll(this.toolRegistry);
+    WebTools.registerAll(this.toolRegistry);
     await this.connectorBridge.discover(this.config.connectors);
     this.connectorBridge.registerAll(this.toolRegistry);
     await this.skillLoader.loadAll(this.cwd);
+    await this.commandLoader.loadAll();
+    this.builtinCommands.registerAll(this.commandLoader);
     const hooksConfig = await loadHooksConfig(this.cwd);
     this.hookLoader.load(hooksConfig);
     await this.hookExecutor.execute(this.hookLoader.getHooks("SessionStart"), {
-      session_id: generateId(),
+      session_id: this.sessionId,
       hook_event_name: "SessionStart",
       cwd: this.cwd
     });
@@ -29627,7 +30430,7 @@ class AgentLoop {
     this.shouldStop = false;
     try {
       const promptHookResult = await this.hookExecutor.execute(this.hookLoader.getHooks("UserPromptSubmit"), {
-        session_id: generateId(),
+        session_id: this.sessionId,
         hook_event_name: "UserPromptSubmit",
         cwd: this.cwd,
         prompt: userMessage
@@ -29636,6 +30439,18 @@ class AgentLoop {
         this.emit({ type: "error", error: promptHookResult.stopReason || "Blocked by hook" });
         return;
       }
+      if (userMessage.startsWith("/")) {
+        const commandResult = await this.handleCommand(userMessage);
+        if (commandResult.handled) {
+          if (commandResult.clearConversation) {
+            this.context = new AgentContext;
+          }
+          return;
+        }
+        if (commandResult.prompt) {
+          userMessage = commandResult.prompt;
+        }
+      }
       if (userMessage.startsWith("/")) {
         const handled = await this.handleSkillInvocation(userMessage);
         if (handled)
@@ -29716,6 +30531,30 @@ class AgentLoop {
     }
     return results;
   }
+  async handleCommand(message) {
+    const context = {
+      cwd: this.cwd,
+      sessionId: this.sessionId,
+      messages: this.context.getMessages(),
+      tools: this.toolRegistry.getTools(),
+      clearMessages: () => {
+        this.context = new AgentContext;
+      },
+      addSystemMessage: (content) => {
+        this.context.addSystemMessage(content);
+      },
+      emit: (type, content) => {
+        if (type === "text" && content) {
+          this.emit({ type: "text", content });
+        } else if (type === "done") {
+          this.emit({ type: "done" });
+        } else if (type === "error" && content) {
+          this.emit({ type: "error", error: content });
+        }
+      }
+    };
+    return this.commandExecutor.execute(message, context);
+  }
   async handleSkillInvocation(message) {
     const match = message.match(/^\/(\S+)(?:\s+(.*))?$/);
     if (!match)
@@ -29747,18 +30586,34 @@ class AgentLoop {
   getSkills() {
     return this.skillLoader.getSkills();
   }
+  getCommands() {
+    return this.commandLoader.getCommands();
+  }
+  getTokenUsage() {
+    return this.builtinCommands.getTokenUsage();
+  }
+  updateTokenUsage(usage) {
+    this.builtinCommands.updateTokenUsage(usage);
+    this.onTokenUsage?.(this.builtinCommands.getTokenUsage());
+  }
   isProcessing() {
     return this.isRunning;
   }
+  getSessionId() {
+    return this.sessionId;
+  }
+  clearConversation() {
+    this.context = new AgentContext;
+  }
 }
 
 // packages/core/src/index.ts
 init_anthropic();
 
 // packages/core/src/logger.ts
-import { existsSync as existsSync3, mkdirSync, appendFileSync } from "fs";
-import { join as join6 } from "path";
-import { homedir as homedir5 } from "os";
+import { existsSync as existsSync5, mkdirSync as mkdirSync2, appendFileSync } from "fs";
+import { join as join8 } from "path";
+import { homedir as homedir7 } from "os";
 
 class Logger {
   logDir;
@@ -29766,14 +30621,14 @@ class Logger {
   sessionId;
   constructor(sessionId) {
     this.sessionId = sessionId;
-    this.logDir = join6(homedir5(), ".oldpal", "logs");
+    this.logDir = join8(homedir7(), ".oldpal", "logs");
     this.ensureDir(this.logDir);
     const date = new Date().toISOString().split("T")[0];
-    this.logFile = join6(this.logDir, `${date}.log`);
+    this.logFile = join8(this.logDir, `${date}.log`);
   }
   ensureDir(dir) {
-    if (!existsSync3(dir)) {
-      mkdirSync(dir, { recursive: true });
+    if (!existsSync5(dir)) {
+      mkdirSync2(dir, { recursive: true });
     }
   }
   write(level, message, data) {
@@ -29812,13 +30667,13 @@ class SessionStorage {
   sessionId;
   constructor(sessionId) {
     this.sessionId = sessionId;
-    this.sessionsDir = join6(homedir5(), ".oldpal", "sessions");
+    this.sessionsDir = join8(homedir7(), ".oldpal", "sessions");
     this.ensureDir(this.sessionsDir);
-    this.sessionFile = join6(this.sessionsDir, `${sessionId}.json`);
+    this.sessionFile = join8(this.sessionsDir, `${sessionId}.json`);
   }
   ensureDir(dir) {
-    if (!existsSync3(dir)) {
-      mkdirSync(dir, { recursive: true });
+    if (!existsSync5(dir)) {
+      mkdirSync2(dir, { recursive: true });
     }
   }
   save(data) {
@@ -29831,16 +30686,16 @@ class SessionStorage {
   }
 }
 function initOldpalDir() {
-  const baseDir = join6(homedir5(), ".oldpal");
+  const baseDir = join8(homedir7(), ".oldpal");
   const dirs = [
     baseDir,
-    join6(baseDir, "sessions"),
-    join6(baseDir, "logs"),
-    join6(baseDir, "skills")
+    join8(baseDir, "sessions"),
+    join8(baseDir, "logs"),
+    join8(baseDir, "skills")
   ];
   for (const dir of dirs) {
-    if (!existsSync3(dir)) {
-      mkdirSync(dir, { recursive: true });
+    if (!existsSync5(dir)) {
+      mkdirSync2(dir, { recursive: true });
     }
   }
 }
@@ -29977,6 +30832,20 @@ class EmbeddedClient {
   getSessionId() {
     return this.session.getSessionId();
   }
+  async getCommands() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    return this.agent.getCommands();
+  }
+  getTokenUsage() {
+    return this.agent.getTokenUsage();
+  }
+  clearConversation() {
+    this.agent.clearConversation();
+    this.messages = [];
+    this.logger.info("Conversation cleared");
+  }
 }
 // packages/terminal/src/components/Input.tsx
 var import_react23 = __toESM(require_react(), 1);
@@ -30158,7 +31027,7 @@ function parseMarkdown(text) {
 
 // packages/terminal/src/components/Messages.tsx
 var jsx_dev_runtime3 = __toESM(require_jsx_dev_runtime(), 1);
-function Messages4({ messages, currentResponse, currentToolCall, lastToolResult }) {
+function Messages4({ messages, currentResponse, currentToolCall, lastToolResult, activityLog = [] }) {
   const visibleMessages = messages.slice(-15);
   return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
     flexDirection: "column",
@@ -30166,7 +31035,37 @@ function Messages4({ messages, currentResponse, currentToolCall, lastToolResult
       visibleMessages.map((message) => /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(MessageBubble, {
         message
       }, message.id, false, undefined, this)),
-      currentToolCall && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
+      activityLog.map((entry) => {
+        if (entry.type === "tool_call" && entry.toolCall) {
+          return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
+            marginY: 1,
+            children: [
+              /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
+                dimColor: true,
+                children: "\u25D0 "
+              }, undefined, false, undefined, this),
+              /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
+                dimColor: true,
+                children: formatToolCall(entry.toolCall)
+              }, undefined, false, undefined, this)
+            ]
+          }, entry.id, true, undefined, this);
+        }
+        if (entry.type === "tool_result" && entry.toolResult) {
+          return /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
+            marginLeft: 2,
+            children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
+              dimColor: true,
+              children: [
+                "\u2192 ",
+                truncate(entry.toolResult.content, 100)
+              ]
+            }, undefined, true, undefined, this)
+          }, entry.id, false, undefined, this);
+        }
+        return null;
+      }),
+      currentToolCall && !activityLog.some((e) => e.toolCall?.id === currentToolCall.id) && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
         marginY: 1,
         children: [
           /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
@@ -30179,7 +31078,7 @@ function Messages4({ messages, currentResponse, currentToolCall, lastToolResult
           }, undefined, false, undefined, this)
         ]
       }, undefined, true, undefined, this),
-      lastToolResult && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
+      lastToolResult && !activityLog.some((e) => e.toolResult?.toolCallId === lastToolResult.toolCallId) && /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Box_default, {
         marginY: 1,
         marginLeft: 2,
         children: /* @__PURE__ */ jsx_dev_runtime3.jsxDEV(Text, {
@@ -30297,10 +31196,17 @@ function truncate(text, maxLength) {
 
 // packages/terminal/src/components/Status.tsx
 var jsx_dev_runtime4 = __toESM(require_jsx_dev_runtime(), 1);
-function Status({ isProcessing, cwd: cwd2, queueLength = 0 }) {
-  const maxCwdLength = 50;
+function Status({ isProcessing, cwd: cwd2, queueLength = 0, tokenUsage }) {
+  const maxCwdLength = 30;
   const displayCwd = cwd2.length > maxCwdLength ? "..." + cwd2.slice(-(maxCwdLength - 3)) : cwd2;
   const queueInfo = queueLength > 0 ? ` | ${queueLength} queued` : "";
+  let tokenInfo = "";
+  if (tokenUsage && tokenUsage.totalTokens > 0) {
+    const used = Math.round(tokenUsage.totalTokens / 1000);
+    const max = Math.round(tokenUsage.maxContextTokens / 1000);
+    const percent = Math.round(tokenUsage.totalTokens / tokenUsage.maxContextTokens * 100);
+    tokenInfo = ` | ${used}k/${max}k (${percent}%)`;
+  }
   return /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Box_default, {
     marginTop: 1,
     borderStyle: "single",
@@ -30318,6 +31224,10 @@ function Status({ isProcessing, cwd: cwd2, queueLength = 0 }) {
             dimColor: !isProcessing,
             children: isProcessing ? "\u25CF processing" : "\u25CF ready"
           }, undefined, false, undefined, this),
+          /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
+            dimColor: true,
+            children: tokenInfo
+          }, undefined, false, undefined, this),
           /* @__PURE__ */ jsx_dev_runtime4.jsxDEV(Text, {
             dimColor: true,
             children: queueInfo
@@ -30326,7 +31236,8 @@ function Status({ isProcessing, cwd: cwd2, queueLength = 0 }) {
             dimColor: true,
             children: [
               " | ",
-              isProcessing ? "Esc to stop" : "Ctrl+C to exit"
+              isProcessing ? "Esc to stop" : "Ctrl+C to exit",
+              " | /help"
             ]
           }, undefined, true, undefined, this)
         ]
@@ -30391,8 +31302,12 @@ function App2({ cwd: cwd2 }) {
   const [isInitializing, setIsInitializing] = import_react25.useState(true);
   const [error, setError] = import_react25.useState(null);
   const [messageQueue, setMessageQueue] = import_react25.useState([]);
+  const [activityLog, setActivityLog] = import_react25.useState([]);
+  const [tokenUsage, setTokenUsage] = import_react25.useState();
   const responseRef = import_react25.useRef("");
   const clientRef = import_react25.useRef(null);
+  const toolCallsRef = import_react25.useRef([]);
+  const toolResultsRef = import_react25.useRef([]);
   const processQueue = import_react25.useCallback(async () => {
     if (!clientRef.current || messageQueue.length === 0)
       return;
@@ -30407,9 +31322,12 @@ function App2({ cwd: cwd2 }) {
     setMessages((prev) => [...prev, userMessage]);
     setCurrentResponse("");
     responseRef.current = "";
+    toolCallsRef.current = [];
+    toolResultsRef.current = [];
     setError(null);
     setCurrentToolCall(undefined);
     setLastToolResult(undefined);
+    setActivityLog([]);
     setIsProcessing(true);
     await clientRef.current.send(nextMessage);
   }, [messageQueue]);
@@ -30423,31 +31341,60 @@ function App2({ cwd: cwd2 }) {
             responseRef.current += chunk.content;
             setCurrentResponse(responseRef.current);
           } else if (chunk.type === "tool_use" && chunk.toolCall) {
+            toolCallsRef.current.push(chunk.toolCall);
+            setActivityLog((prev) => [
+              ...prev,
+              {
+                id: generateId(),
+                type: "tool_call",
+                toolCall: chunk.toolCall,
+                timestamp: now()
+              }
+            ]);
             setCurrentToolCall(chunk.toolCall);
             setLastToolResult(undefined);
           } else if (chunk.type === "tool_result" && chunk.toolResult) {
+            toolResultsRef.current.push(chunk.toolResult);
+            setActivityLog((prev) => [
+              ...prev,
+              {
+                id: generateId(),
+                type: "tool_result",
+                toolResult: chunk.toolResult,
+                timestamp: now()
+              }
+            ]);
             setLastToolResult(chunk.toolResult);
             setCurrentToolCall(undefined);
           } else if (chunk.type === "error" && chunk.error) {
             setError(chunk.error);
             setIsProcessing(false);
+          } else if (chunk.type === "usage" && chunk.usage) {
+            setTokenUsage(chunk.usage);
           } else if (chunk.type === "done") {
-            if (responseRef.current) {
+            if (responseRef.current || toolCallsRef.current.length > 0) {
               setMessages((prev) => [
                 ...prev,
                 {
                   id: generateId(),
                   role: "assistant",
                   content: responseRef.current,
-                  timestamp: now()
+                  timestamp: now(),
+                  toolCalls: toolCallsRef.current.length > 0 ? [...toolCallsRef.current] : undefined,
+                  toolResults: toolResultsRef.current.length > 0 ? [...toolResultsRef.current] : undefined
                 }
               ]);
               setCurrentResponse("");
               responseRef.current = "";
+              toolCallsRef.current = [];
+              toolResultsRef.current = [];
             }
             setCurrentToolCall(undefined);
             setLastToolResult(undefined);
             setIsProcessing(false);
+            if (newClient) {
+              setTokenUsage(newClient.getTokenUsage());
+            }
           }
         });
         newClient.onError((err) => {
@@ -30550,9 +31497,12 @@ function App2({ cwd: cwd2 }) {
     setMessages((prev) => [...prev, userMessage]);
     setCurrentResponse("");
     responseRef.current = "";
+    toolCallsRef.current = [];
+    toolResultsRef.current = [];
     setError(null);
     setCurrentToolCall(undefined);
     setLastToolResult(undefined);
+    setActivityLog([]);
     setIsProcessing(true);
     await client.send(trimmedInput);
   }, [client, isProcessing]);
@@ -30573,7 +31523,8 @@ function App2({ cwd: cwd2 }) {
         messages,
         currentResponse: isProcessing ? currentResponse : undefined,
         currentToolCall,
-        lastToolResult
+        lastToolResult,
+        activityLog: isProcessing ? activityLog : []
       }, undefined, false, undefined, this),
       messageQueue.length > 0 && /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Box_default, {
         marginY: 1,
@@ -30611,7 +31562,8 @@ function App2({ cwd: cwd2 }) {
       /* @__PURE__ */ jsx_dev_runtime6.jsxDEV(Status, {
         isProcessing,
         cwd: cwd2,
-        queueLength: messageQueue.length
+        queueLength: messageQueue.length,
+        tokenUsage
       }, undefined, false, undefined, this)
     ]
   }, undefined, true, undefined, this);
@@ -30626,7 +31578,7 @@ var options = {
   help: args.includes("--help") || args.includes("-h")
 };
 if (options.version) {
-  console.log("oldpal v0.1.7");
+  console.log("oldpal v0.1.9");
   process.exit(0);
 }
 if (options.help) {
@@ -30657,4 +31609,4 @@ waitUntilExit().then(() => {
   process.exit(0);
 });
 
-//# debugId=F204A4187B2BDE8664756E2164756E21
+//# debugId=307434E7D5151E5864756E2164756E21