@hasna/oldpal 0.1.8 → 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]+)["']?/);
@@ -29643,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") {
@@ -29654,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",
@@ -29685,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 };
@@ -29704,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);
@@ -29713,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);
@@ -29731,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);
@@ -29767,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;
@@ -29784,9 +30392,13 @@ 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);
@@ -29797,10 +30409,12 @@ class AgentLoop {
     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
     });
@@ -29816,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
@@ -29825,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)
@@ -29905,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)
@@ -29936,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;
@@ -29955,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) {
@@ -30001,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) {
@@ -30020,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 });
     }
   }
 }
@@ -30166,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);
@@ -30516,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",
@@ -30537,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
@@ -30545,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)
         ]
@@ -30611,6 +31303,7 @@ function App2({ cwd: cwd2 }) {
   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([]);
@@ -30676,6 +31369,8 @@ function App2({ cwd: cwd2 }) {
           } 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 || toolCallsRef.current.length > 0) {
               setMessages((prev) => [
@@ -30697,6 +31392,9 @@ function App2({ cwd: cwd2 }) {
             setCurrentToolCall(undefined);
             setLastToolResult(undefined);
             setIsProcessing(false);
+            if (newClient) {
+              setTokenUsage(newClient.getTokenUsage());
+            }
           }
         });
         newClient.onError((err) => {
@@ -30864,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);
@@ -30879,7 +31578,7 @@ var options = {
   help: args.includes("--help") || args.includes("-h")
 };
 if (options.version) {
-  console.log("oldpal v0.1.8");
+  console.log("oldpal v0.1.9");
   process.exit(0);
 }
 if (options.help) {
@@ -30910,4 +31609,4 @@ waitUntilExit().then(() => {
   process.exit(0);
 });
 
-//# debugId=43BB59ABD8BF8C1564756E2164756E21
+//# debugId=307434E7D5151E5864756E2164756E21