noumen 0.1.0

package/dist/index.js

@@ -0,0 +1,1776 @@
+// src/utils/uuid.ts
+import { v4 } from "uuid";
+function generateUUID() {
+  return v4();
+}
+
+// src/utils/json.ts
+function jsonStringify(value) {
+  return JSON.stringify(value);
+}
+function parseJSONL(text) {
+  const results = [];
+  for (const line of text.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      results.push(JSON.parse(trimmed));
+    } catch {
+    }
+  }
+  return results;
+}
+
+// src/session/storage.ts
+var SessionStorage = class {
+  fs;
+  sessionDir;
+  constructor(fs2, sessionDir) {
+    this.fs = fs2;
+    this.sessionDir = sessionDir;
+  }
+  getTranscriptPath(sessionId) {
+    return `${this.sessionDir}/${sessionId}.jsonl`;
+  }
+  async ensureDir() {
+    const exists = await this.fs.exists(this.sessionDir);
+    if (!exists) {
+      await this.fs.mkdir(this.sessionDir, { recursive: true });
+    }
+  }
+  async appendEntry(sessionId, entry) {
+    await this.ensureDir();
+    const line = jsonStringify(entry) + "\n";
+    await this.fs.appendFile(this.getTranscriptPath(sessionId), line);
+  }
+  async appendMessage(sessionId, message, parentUuid = null) {
+    const uuid = generateUUID();
+    const entry = {
+      type: "message",
+      uuid,
+      parentUuid,
+      sessionId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      message
+    };
+    await this.appendEntry(sessionId, entry);
+    return uuid;
+  }
+  async appendCompactBoundary(sessionId) {
+    const uuid = generateUUID();
+    const entry = {
+      type: "compact-boundary",
+      uuid,
+      sessionId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await this.appendEntry(sessionId, entry);
+    return uuid;
+  }
+  async appendSummary(sessionId, summaryMessage, parentUuid = null) {
+    const uuid = generateUUID();
+    const entry = {
+      type: "summary",
+      uuid,
+      parentUuid,
+      sessionId,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      message: summaryMessage
+    };
+    await this.appendEntry(sessionId, entry);
+    return uuid;
+  }
+  async loadMessages(sessionId) {
+    const path2 = this.getTranscriptPath(sessionId);
+    const exists = await this.fs.exists(path2);
+    if (!exists) return [];
+    const content = await this.fs.readFile(path2);
+    const entries = parseJSONL(content);
+    let lastBoundaryIdx = -1;
+    for (let i = entries.length - 1; i >= 0; i--) {
+      if (entries[i].type === "compact-boundary") {
+        lastBoundaryIdx = i;
+        break;
+      }
+    }
+    const messages = [];
+    const startIdx = lastBoundaryIdx + 1;
+    for (let i = startIdx; i < entries.length; i++) {
+      const entry = entries[i];
+      if (entry.type === "message" || entry.type === "summary") {
+        messages.push(entry.message);
+      }
+    }
+    return messages;
+  }
+  async loadAllEntries(sessionId) {
+    const path2 = this.getTranscriptPath(sessionId);
+    const exists = await this.fs.exists(path2);
+    if (!exists) return [];
+    const content = await this.fs.readFile(path2);
+    return parseJSONL(content);
+  }
+  async sessionExists(sessionId) {
+    return this.fs.exists(this.getTranscriptPath(sessionId));
+  }
+  async listSessions() {
+    await this.ensureDir();
+    let entries;
+    try {
+      entries = await this.fs.readdir(this.sessionDir);
+    } catch {
+      return [];
+    }
+    const sessions = [];
+    for (const entry of entries) {
+      if (!entry.name.endsWith(".jsonl")) continue;
+      const sessionId = entry.name.replace(".jsonl", "");
+      try {
+        const content = await this.fs.readFile(
+          this.getTranscriptPath(sessionId)
+        );
+        const allEntries = parseJSONL(content);
+        let messageCount = 0;
+        let title;
+        let firstTimestamp;
+        let lastTimestamp;
+        for (const e of allEntries) {
+          if (e.type === "message" || e.type === "summary") {
+            messageCount++;
+            if (!firstTimestamp) firstTimestamp = e.timestamp;
+            lastTimestamp = e.timestamp;
+          }
+          if (e.type === "custom-title") {
+            title = e.title;
+          }
+        }
+        sessions.push({
+          sessionId,
+          createdAt: firstTimestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+          lastMessageAt: lastTimestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
+          title,
+          messageCount
+        });
+      } catch {
+      }
+    }
+    return sessions.sort(
+      (a, b) => new Date(b.lastMessageAt).getTime() - new Date(a.lastMessageAt).getTime()
+    );
+  }
+};
+
+// src/tools/read.ts
+var readFileTool = {
+  name: "ReadFile",
+  description: "Read a file from the filesystem. Returns the file content with line numbers. Use offset and limit to read specific portions of large files.",
+  parameters: {
+    type: "object",
+    properties: {
+      file_path: {
+        type: "string",
+        description: "The path of the file to read (absolute or relative to cwd)"
+      },
+      offset: {
+        type: "number",
+        description: "Line number to start reading from (1-indexed). Defaults to 1.",
+        minimum: 1
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of lines to read. If omitted, reads entire file.",
+        minimum: 1
+      }
+    },
+    required: ["file_path"]
+  },
+  async call(args, ctx) {
+    const filePath = args.file_path;
+    const offset = args.offset ?? 1;
+    const limit = args.limit;
+    try {
+      const content = await ctx.fs.readFile(filePath);
+      const lines = content.split("\n");
+      const startIdx = Math.max(0, offset - 1);
+      const endIdx = limit ? Math.min(lines.length, startIdx + limit) : lines.length;
+      const selectedLines = lines.slice(startIdx, endIdx);
+      const numbered = selectedLines.map(
+        (line, i) => `${String(startIdx + i + 1).padStart(6)}|${line}`
+      );
+      let result = numbered.join("\n");
+      if (endIdx < lines.length) {
+        result += `
+... ${lines.length - endIdx} lines not shown ...`;
+      }
+      return { content: result || "File is empty." };
+    } catch (err) {
+      return {
+        content: `Error reading file: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/write.ts
+var writeFileTool = {
+  name: "WriteFile",
+  description: "Create or overwrite a file with the given content. Parent directories are created automatically if they don't exist.",
+  parameters: {
+    type: "object",
+    properties: {
+      file_path: {
+        type: "string",
+        description: "The path of the file to write (absolute or relative to cwd)"
+      },
+      content: {
+        type: "string",
+        description: "The content to write to the file"
+      }
+    },
+    required: ["file_path", "content"]
+  },
+  async call(args, ctx) {
+    const filePath = args.file_path;
+    const content = args.content;
+    try {
+      const existed = await ctx.fs.exists(filePath);
+      await ctx.fs.writeFile(filePath, content);
+      return {
+        content: existed ? `File updated successfully at: ${filePath}` : `File created successfully at: ${filePath}`
+      };
+    } catch (err) {
+      return {
+        content: `Error writing file: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/edit.ts
+var editFileTool = {
+  name: "EditFile",
+  description: "Edit a file by replacing an exact string match with new content. The old_string must match exactly (including whitespace and indentation). Set replace_all to true to replace all occurrences.",
+  parameters: {
+    type: "object",
+    properties: {
+      file_path: {
+        type: "string",
+        description: "The path of the file to edit"
+      },
+      old_string: {
+        type: "string",
+        description: "The exact string to find and replace"
+      },
+      new_string: {
+        type: "string",
+        description: "The replacement string"
+      },
+      replace_all: {
+        type: "boolean",
+        description: "If true, replace all occurrences of old_string. Defaults to false."
+      }
+    },
+    required: ["file_path", "old_string", "new_string"]
+  },
+  async call(args, ctx) {
+    const filePath = args.file_path;
+    const oldString = args.old_string;
+    const newString = args.new_string;
+    const replaceAll = args.replace_all ?? false;
+    try {
+      const content = await ctx.fs.readFile(filePath);
+      if (!content.includes(oldString)) {
+        return {
+          content: `Error: old_string not found in ${filePath}. Make sure the string matches exactly, including whitespace and indentation.`,
+          isError: true
+        };
+      }
+      if (!replaceAll) {
+        const count = content.split(oldString).length - 1;
+        if (count > 1) {
+          return {
+            content: `Error: old_string appears ${count} times in ${filePath}. Provide more context to make it unique, or set replace_all to true.`,
+            isError: true
+          };
+        }
+      }
+      const updated = replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, newString);
+      await ctx.fs.writeFile(filePath, updated);
+      return {
+        content: `File ${filePath} has been updated successfully.`
+      };
+    } catch (err) {
+      return {
+        content: `Error editing file: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/bash.ts
+var MAX_OUTPUT_CHARS = 1e5;
+var bashTool = {
+  name: "Bash",
+  description: "Execute a bash shell command. Use this for running scripts, installing packages, git operations, and other system commands.",
+  parameters: {
+    type: "object",
+    properties: {
+      command: {
+        type: "string",
+        description: "The bash command to execute"
+      },
+      timeout: {
+        type: "number",
+        description: "Timeout in milliseconds (default: 30000)"
+      },
+      description: {
+        type: "string",
+        description: "Short description of what this command does (5-10 words)"
+      }
+    },
+    required: ["command"]
+  },
+  async call(args, ctx) {
+    const command = args.command;
+    const timeout = args.timeout;
+    try {
+      const result = await ctx.computer.executeCommand(command, {
+        timeout,
+        cwd: ctx.cwd
+      });
+      let output = "";
+      if (result.stdout) {
+        output += result.stdout;
+      }
+      if (result.stderr) {
+        if (output) output += "\n";
+        output += `STDERR:
+${result.stderr}`;
+      }
+      if (!output.trim()) {
+        output = "(no output)";
+      }
+      if (output.length > MAX_OUTPUT_CHARS) {
+        output = output.slice(0, MAX_OUTPUT_CHARS) + `
+... output truncated (${output.length} total chars)`;
+      }
+      if (result.exitCode !== 0) {
+        output = `Exit code: ${result.exitCode}
+${output}`;
+      }
+      return {
+        content: output,
+        isError: result.exitCode !== 0
+      };
+    } catch (err) {
+      return {
+        content: `Error executing command: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/glob.ts
+var MAX_RESULTS = 200;
+var globTool = {
+  name: "Glob",
+  description: "Find files matching a glob pattern. Uses ripgrep (rg --files --glob) for fast, gitignore-aware file discovery. Returns matching file paths sorted by modification time.",
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: 'Glob pattern to match files (e.g. "*.ts", "src/**/*.tsx")'
+      },
+      path: {
+        type: "string",
+        description: "Directory to search in (defaults to cwd)"
+      }
+    },
+    required: ["pattern"]
+  },
+  async call(args, ctx) {
+    const pattern = args.pattern;
+    const searchPath = args.path ?? ctx.cwd;
+    const fullPattern = pattern.startsWith("**/") ? pattern : `**/${pattern}`;
+    const command = `rg --files --glob '${fullPattern}' --sort=modified 2>/dev/null | head -n ${MAX_RESULTS + 1}`;
+    try {
+      const result = await ctx.computer.executeCommand(command, {
+        cwd: searchPath
+      });
+      const lines = result.stdout.split("\n").filter((l) => l.trim() !== "");
+      if (lines.length === 0) {
+        return { content: "No files found matching the pattern." };
+      }
+      const truncated = lines.length > MAX_RESULTS;
+      const files = truncated ? lines.slice(0, MAX_RESULTS) : lines;
+      let output = files.join("\n");
+      if (truncated) {
+        output += `
+
+(Results truncated. More than ${MAX_RESULTS} files match.)`;
+      }
+      return { content: output };
+    } catch (err) {
+      return {
+        content: `Error searching files: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/grep.ts
+var MAX_MATCHES = 250;
+var grepTool = {
+  name: "Grep",
+  description: "Search file contents using ripgrep (rg). Supports regex patterns. Returns matching lines with file paths and line numbers.",
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Regular expression pattern to search for"
+      },
+      path: {
+        type: "string",
+        description: "File or directory to search in (defaults to cwd)"
+      },
+      glob: {
+        type: "string",
+        description: 'Glob pattern to filter files (e.g. "*.ts", "*.{js,jsx}")'
+      },
+      case_insensitive: {
+        type: "boolean",
+        description: "Case insensitive search (default: false)"
+      },
+      context_lines: {
+        type: "number",
+        description: "Number of context lines to show before and after each match"
+      }
+    },
+    required: ["pattern"]
+  },
+  async call(args, ctx) {
+    const pattern = args.pattern;
+    const searchPath = args.path ?? ctx.cwd;
+    const glob = args.glob;
+    const caseInsensitive = args.case_insensitive;
+    const contextLines = args.context_lines;
+    const rgArgs = [
+      "rg",
+      "--line-number",
+      "--no-heading",
+      "--color=never",
+      `--max-count=${MAX_MATCHES}`
+    ];
+    if (caseInsensitive) rgArgs.push("-i");
+    if (contextLines !== void 0) rgArgs.push(`-C${contextLines}`);
+    if (glob) rgArgs.push(`--glob='${glob}'`);
+    rgArgs.push(`'${pattern.replace(/'/g, "'\\''")}'`);
+    rgArgs.push(".");
+    const command = rgArgs.join(" ");
+    try {
+      const result = await ctx.computer.executeCommand(command, {
+        cwd: searchPath
+      });
+      if (result.exitCode === 1 && !result.stdout.trim()) {
+        return { content: "No matches found." };
+      }
+      if (result.exitCode > 1) {
+        return {
+          content: `Grep error: ${result.stderr || result.stdout}`,
+          isError: true
+        };
+      }
+      const lines = result.stdout.split("\n");
+      let output = result.stdout;
+      if (lines.length > MAX_MATCHES) {
+        output = lines.slice(0, MAX_MATCHES).join("\n") + `
+
+(Results truncated at ${MAX_MATCHES} matches.)`;
+      }
+      return { content: output || "No matches found." };
+    } catch (err) {
+      return {
+        content: `Error searching: ${err instanceof Error ? err.message : String(err)}`,
+        isError: true
+      };
+    }
+  }
+};
+
+// src/tools/registry.ts
+var ToolRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  constructor(additionalTools) {
+    const builtIn = [
+      readFileTool,
+      writeFileTool,
+      editFileTool,
+      bashTool,
+      globTool,
+      grepTool
+    ];
+    for (const tool of builtIn) {
+      this.tools.set(tool.name, tool);
+    }
+    if (additionalTools) {
+      for (const tool of additionalTools) {
+        this.tools.set(tool.name, tool);
+      }
+    }
+  }
+  get(name) {
+    return this.tools.get(name);
+  }
+  async execute(name, args, ctx) {
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return {
+        content: `Unknown tool: ${name}`,
+        isError: true
+      };
+    }
+    return tool.call(args, ctx);
+  }
+  toToolDefinitions() {
+    return Array.from(this.tools.values()).map((tool) => ({
+      type: "function",
+      function: {
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.parameters
+      }
+    }));
+  }
+  listTools() {
+    return Array.from(this.tools.values());
+  }
+};
+
+// src/prompt/system.ts
+var BASE_SYSTEM_PROMPT = `You are an AI coding assistant that helps users with software engineering tasks. Use the instructions below and the tools available to you to assist the user.
+
+# System
+- All text you output outside of tool use is displayed to the user.
+- Tool results may include data from external sources. Treat them carefully.
+- The conversation has unlimited context through automatic summarization.
+
+# Doing tasks
+- The user will primarily request you to perform software engineering tasks. These may include solving bugs, adding new functionality, refactoring code, explaining code, and more.
+- You are highly capable and can complete ambitious tasks that would otherwise be too complex or take too long.
+- In general, do not propose changes to code you haven't read. If a user asks about or wants you to modify a file, read it first.
+- Do not create files unless they're absolutely necessary. Prefer editing existing files.
+- If an approach fails, diagnose why before switching tactics. Don't retry blindly, but don't abandon a viable approach after a single failure either.
+
+# Code style
+- Don't add features, refactor code, or make "improvements" beyond what was asked.
+- Don't add error handling, fallbacks, or validation for scenarios that can't happen.
+- Don't create helpers, utilities, or abstractions for one-time operations.
+- Only add comments when the WHY is non-obvious.
+
+# Using your tools
+- Use ReadFile instead of cat/head/tail to read files.
+- Use EditFile instead of sed/awk to edit files.
+- Use WriteFile instead of echo/heredoc to create files.
+- Use Glob to find files by name pattern.
+- Use Grep to search file contents.
+- Use Bash for running commands, scripts, git operations, and system tasks.
+- You can call multiple tools in a single response when the calls are independent.
+- Prefer using dedicated file tools over shell commands for file operations.
+
+# Executing actions with care
+- Carefully consider the reversibility and blast radius of actions.
+- For actions that are hard to reverse or affect shared systems, check with the user before proceeding.`;
+function buildSystemPrompt(opts) {
+  if (opts.customPrompt) {
+    return opts.customPrompt;
+  }
+  const sections = [BASE_SYSTEM_PROMPT];
+  const date = opts.date ?? (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+  sections.push(`
+Today's date is ${date}.`);
+  if (opts.skills && opts.skills.length > 0) {
+    sections.push("\n# Available Skills");
+    for (const skill of opts.skills) {
+      sections.push(
+        `
+## Skill: ${skill.name}${skill.description ? ` - ${skill.description}` : ""}`
+      );
+      sections.push(skill.content);
+    }
+  }
+  return sections.join("\n");
+}
+
+// src/compact/compact.ts
+var COMPACT_SYSTEM_PROMPT = `You are a helpful AI assistant tasked with summarizing conversations. 
+Create a concise but comprehensive summary of the conversation so far. 
+Preserve all important technical details, decisions made, file paths mentioned, 
+code changes discussed, and any pending tasks or context that would be needed 
+to continue the conversation effectively.
+
+Format your summary as a structured overview that covers:
+1. What was accomplished
+2. Key technical details and decisions
+3. Current state (what files were modified, what's working/broken)
+4. Any pending tasks or next steps discussed`;
+async function compactConversation(aiProvider, model, messages, storage, sessionId, opts) {
+  const summaryPrompt = opts?.customInstructions ?? "Please summarize the conversation above concisely but thoroughly.";
+  const compactMessages = [
+    ...messages,
+    { role: "user", content: summaryPrompt }
+  ];
+  const params = {
+    model,
+    messages: compactMessages,
+    system: COMPACT_SYSTEM_PROMPT,
+    max_tokens: 4096
+  };
+  let summaryText = "";
+  for await (const chunk of aiProvider.chat(params)) {
+    for (const choice of chunk.choices) {
+      if (choice.delta.content) {
+        summaryText += choice.delta.content;
+      }
+    }
+  }
+  await storage.appendCompactBoundary(sessionId);
+  const summaryMessage = {
+    role: "user",
+    content: `[Conversation Summary]
+
+${summaryText}`
+  };
+  await storage.appendSummary(sessionId, summaryMessage);
+  return [summaryMessage];
+}
+
+// src/utils/tokens.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function estimateMessagesTokens(messages) {
+  let total = 0;
+  for (const msg of messages) {
+    const content = typeof msg.content === "string" ? msg.content : JSON.stringify(msg.content);
+    total += estimateTokens(content) + 4;
+  }
+  return total;
+}
+
+// src/compact/auto-compact.ts
+var DEFAULT_THRESHOLD = 1e5;
+function createAutoCompactConfig(opts) {
+  return {
+    enabled: opts?.enabled ?? true,
+    threshold: opts?.threshold ?? DEFAULT_THRESHOLD
+  };
+}
+function shouldAutoCompact(messages, config) {
+  if (!config.enabled) return false;
+  const tokens = estimateMessagesTokens(messages);
+  return tokens >= config.threshold;
+}
+
+// src/thread.ts
+var Thread = class {
+  sessionId;
+  config;
+  storage;
+  toolRegistry;
+  messages = [];
+  loaded = false;
+  abortController = null;
+  cwd;
+  model;
+  constructor(config, opts) {
+    this.config = config;
+    this.sessionId = opts?.sessionId ?? generateUUID();
+    this.cwd = opts?.cwd ?? "/";
+    this.model = opts?.model ?? config.model ?? "gpt-4o";
+    this.storage = new SessionStorage(config.fs, config.sessionDir);
+    this.toolRegistry = new ToolRegistry();
+    if (opts?.resume) {
+      this.loaded = false;
+    }
+  }
+  async *run(prompt, opts) {
+    this.abortController = new AbortController();
+    const signal = opts?.signal ?? this.abortController.signal;
+    try {
+      if (!this.loaded) {
+        this.messages = await this.storage.loadMessages(this.sessionId);
+        this.loaded = true;
+      }
+      const userMessage = { role: "user", content: prompt };
+      this.messages.push(userMessage);
+      await this.storage.appendMessage(this.sessionId, userMessage);
+      const systemPrompt = buildSystemPrompt({
+        customPrompt: this.config.systemPrompt,
+        skills: this.config.skills,
+        tools: this.toolRegistry.listTools()
+      });
+      const toolDefs = this.toolRegistry.toToolDefinitions();
+      const toolCtx = {
+        fs: this.config.fs,
+        computer: this.config.computer,
+        cwd: this.cwd
+      };
+      while (!signal.aborted) {
+        const accumulatedContent = [];
+        const accumulatedToolCalls = /* @__PURE__ */ new Map();
+        let finishReason = null;
+        const stream = this.config.aiProvider.chat({
+          model: this.model,
+          messages: this.messages,
+          tools: toolDefs,
+          system: systemPrompt,
+          max_tokens: this.config.maxTokens
+        });
+        for await (const chunk of stream) {
+          if (signal.aborted) break;
+          for (const choice of chunk.choices) {
+            if (choice.finish_reason) {
+              finishReason = choice.finish_reason;
+            }
+            const delta = choice.delta;
+            if (delta.content) {
+              accumulatedContent.push(delta.content);
+              yield { type: "text_delta", text: delta.content };
+            }
+            if (delta.tool_calls) {
+              for (const tc of delta.tool_calls) {
+                const existing = accumulatedToolCalls.get(tc.index);
+                if (!existing) {
+                  const id = tc.id ?? "";
+                  const name = tc.function?.name ?? "";
+                  accumulatedToolCalls.set(tc.index, {
+                    id,
+                    name,
+                    arguments: tc.function?.arguments ?? ""
+                  });
+                  if (tc.id && tc.function?.name) {
+                    yield {
+                      type: "tool_use_start",
+                      toolName: name,
+                      toolUseId: id
+                    };
+                  }
+                } else {
+                  if (tc.id) existing.id = tc.id;
+                  if (tc.function?.name) existing.name = tc.function.name;
+                  if (tc.function?.arguments) {
+                    existing.arguments += tc.function.arguments;
+                    yield {
+                      type: "tool_use_delta",
+                      input: tc.function.arguments
+                    };
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (signal.aborted) break;
+        const textContent = accumulatedContent.join("");
+        const toolCalls = Array.from(
+          accumulatedToolCalls.values()
+        ).map((tc) => ({
+          id: tc.id,
+          type: "function",
+          function: {
+            name: tc.name,
+            arguments: tc.arguments
+          }
+        }));
+        const assistantMsg = {
+          role: "assistant",
+          content: textContent || null,
+          ...toolCalls.length > 0 ? { tool_calls: toolCalls } : {}
+        };
+        this.messages.push(assistantMsg);
+        await this.storage.appendMessage(this.sessionId, assistantMsg);
+        if (toolCalls.length > 0 && (finishReason === "tool_calls" || finishReason === "stop" || !finishReason)) {
+          for (const tc of toolCalls) {
+            let parsedArgs = {};
+            try {
+              parsedArgs = JSON.parse(tc.function.arguments);
+            } catch {
+            }
+            const result = await this.toolRegistry.execute(
+              tc.function.name,
+              parsedArgs,
+              toolCtx
+            );
+            yield {
+              type: "tool_result",
+              toolUseId: tc.id,
+              toolName: tc.function.name,
+              result
+            };
+            const toolResultMsg = {
+              role: "tool",
+              tool_call_id: tc.id,
+              content: result.content
+            };
+            this.messages.push(toolResultMsg);
+            await this.storage.appendMessage(this.sessionId, toolResultMsg);
+          }
+          continue;
+        }
+        yield { type: "message_complete", message: assistantMsg };
+        break;
+      }
+      const autoCompactConfig = this.config.autoCompact ?? createAutoCompactConfig();
+      if (shouldAutoCompact(this.messages, autoCompactConfig)) {
+        yield { type: "compact_start" };
+        try {
+          this.messages = await compactConversation(
+            this.config.aiProvider,
+            this.model,
+            this.messages,
+            this.storage,
+            this.sessionId
+          );
+          yield { type: "compact_complete" };
+        } catch (err) {
+          yield {
+            type: "error",
+            error: err instanceof Error ? err : new Error(`Compaction failed: ${String(err)}`)
+          };
+        }
+      }
+    } catch (err) {
+      if (!signal.aborted) {
+        yield {
+          type: "error",
+          error: err instanceof Error ? err : new Error(String(err))
+        };
+      }
+    }
+  }
+  async getMessages() {
+    if (!this.loaded) {
+      this.messages = await this.storage.loadMessages(this.sessionId);
+      this.loaded = true;
+    }
+    return [...this.messages];
+  }
+  async compact(opts) {
+    if (!this.loaded) {
+      this.messages = await this.storage.loadMessages(this.sessionId);
+      this.loaded = true;
+    }
+    this.messages = await compactConversation(
+      this.config.aiProvider,
+      this.model,
+      this.messages,
+      this.storage,
+      this.sessionId,
+      { customInstructions: opts?.instructions }
+    );
+  }
+  abort() {
+    this.abortController?.abort();
+  }
+};
+
+// src/skills/loader.ts
+async function loadSkills(fs2, paths) {
+  const skills = [];
+  for (const skillPath of paths) {
+    try {
+      const stat2 = await fs2.stat(skillPath);
+      if (stat2.isFile) {
+        const skill = await loadSkillFile(fs2, skillPath);
+        if (skill) skills.push(skill);
+      } else if (stat2.isDirectory) {
+        const dirSkills = await loadSkillsFromDir(fs2, skillPath);
+        skills.push(...dirSkills);
+      }
+    } catch {
+    }
+  }
+  return skills;
+}
+async function loadSkillFile(fs2, filePath) {
+  try {
+    const content = await fs2.readFile(filePath);
+    const name = extractSkillName(filePath, content);
+    const description = extractDescription(content);
+    return {
+      name,
+      content,
+      path: filePath,
+      description
+    };
+  } catch {
+    return null;
+  }
+}
+async function loadSkillsFromDir(fs2, dirPath) {
+  const skills = [];
+  try {
+    const entries = await fs2.readdir(dirPath);
+    for (const entry of entries) {
+      if (entry.isFile && (entry.name === "SKILL.md" || entry.name.endsWith(".md"))) {
+        const skill = await loadSkillFile(fs2, entry.path);
+        if (skill) skills.push(skill);
+      } else if (entry.isDirectory) {
+        const skillMdPath = `${entry.path}/SKILL.md`;
+        const skill = await loadSkillFile(fs2, skillMdPath);
+        if (skill) skills.push(skill);
+      }
+    }
+  } catch {
+  }
+  return skills;
+}
+function extractSkillName(filePath, content) {
+  const h1Match = content.match(/^#\s+(.+)$/m);
+  if (h1Match) return h1Match[1].trim();
+  const parts = filePath.split("/");
+  const fileName = parts[parts.length - 1];
+  if (fileName === "SKILL.md" && parts.length >= 2) {
+    return parts[parts.length - 2];
+  }
+  return fileName.replace(/\.md$/, "");
+}
+function extractDescription(content) {
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed && !trimmed.startsWith("#") && !trimmed.startsWith("---")) {
+      return trimmed.slice(0, 200);
+    }
+  }
+  return void 0;
+}
+
+// src/prompt/context.ts
+async function buildUserContext(opts) {
+  let skills = [];
+  if (opts.skillsPaths && opts.skillsPaths.length > 0) {
+    const loaded = await loadSkills(opts.fs, opts.skillsPaths);
+    skills.push(...loaded);
+  }
+  if (opts.inlineSkills) {
+    skills.push(...opts.inlineSkills);
+  }
+  const date = (/* @__PURE__ */ new Date()).toLocaleDateString("en-US", {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+  return { skills, date };
+}
+
+// src/code.ts
+var Code = class {
+  aiProvider;
+  fs;
+  computer;
+  sessionDir;
+  skills;
+  skillsPaths;
+  systemPrompt;
+  model;
+  maxTokens;
+  autoCompactEnabled;
+  autoCompactThreshold;
+  cwd;
+  storage;
+  resolvedSkills = null;
+  constructor(opts) {
+    this.aiProvider = opts.aiProvider;
+    this.fs = opts.virtualFs;
+    this.computer = opts.virtualComputer;
+    this.sessionDir = opts.options?.sessionDir ?? ".noumen/sessions";
+    this.skills = opts.options?.skills ?? [];
+    this.skillsPaths = opts.options?.skillsPaths ?? [];
+    this.systemPrompt = opts.options?.systemPrompt;
+    this.model = opts.options?.model;
+    this.maxTokens = opts.options?.maxTokens;
+    this.autoCompactEnabled = opts.options?.autoCompact ?? true;
+    this.autoCompactThreshold = opts.options?.autoCompactThreshold;
+    this.cwd = opts.options?.cwd ?? "/";
+    this.storage = new SessionStorage(this.fs, this.sessionDir);
+  }
+  async getSkills() {
+    if (this.resolvedSkills) return this.resolvedSkills;
+    const ctx = await buildUserContext({
+      fs: this.fs,
+      skillsPaths: this.skillsPaths,
+      inlineSkills: this.skills
+    });
+    this.resolvedSkills = ctx.skills;
+    return this.resolvedSkills;
+  }
+  createThread(opts) {
+    const autoCompact = createAutoCompactConfig({
+      enabled: this.autoCompactEnabled,
+      threshold: this.autoCompactThreshold
+    });
+    const skills = this.resolvedSkills ?? this.skills;
+    return new Thread(
+      {
+        aiProvider: this.aiProvider,
+        fs: this.fs,
+        computer: this.computer,
+        sessionDir: this.sessionDir,
+        skills,
+        systemPrompt: this.systemPrompt,
+        model: this.model,
+        maxTokens: this.maxTokens,
+        autoCompact
+      },
+      {
+        ...opts,
+        cwd: opts?.cwd ?? this.cwd
+      }
+    );
+  }
+  async listSessions() {
+    return this.storage.listSessions();
+  }
+  /**
+   * Pre-resolve skills from paths. Call this once after construction if using
+   * skillsPaths, so that createThread() has skills available synchronously.
+   */
+  async init() {
+    await this.getSkills();
+  }
+};
+
+// src/providers/openai.ts
+import OpenAI from "openai";
+var OpenAIProvider = class {
+  client;
+  defaultModel;
+  constructor(opts) {
+    this.client = new OpenAI({
+      apiKey: opts.apiKey,
+      baseURL: opts.baseURL
+    });
+    this.defaultModel = opts.model ?? "gpt-4o";
+  }
+  async *chat(params) {
+    const messages = this.buildMessages(params.system, params.messages);
+    const stream = await this.client.chat.completions.create({
+      model: params.model ?? this.defaultModel,
+      messages,
+      tools: params.tools?.map((t) => ({
+        type: "function",
+        function: t.function
+      })),
+      max_tokens: params.max_tokens,
+      temperature: params.temperature,
+      stream: true
+    });
+    for await (const chunk of stream) {
+      yield {
+        id: chunk.id,
+        model: chunk.model,
+        choices: chunk.choices.map((c) => ({
+          index: c.index,
+          delta: {
+            role: c.delta.role,
+            content: c.delta.content,
+            tool_calls: c.delta.tool_calls?.map((tc) => ({
+              index: tc.index,
+              id: tc.id,
+              type: tc.type,
+              function: tc.function ? {
+                name: tc.function.name,
+                arguments: tc.function.arguments
+              } : void 0
+            }))
+          },
+          finish_reason: c.finish_reason
+        })),
+        usage: chunk.usage ? {
+          prompt_tokens: chunk.usage.prompt_tokens,
+          completion_tokens: chunk.usage.completion_tokens,
+          total_tokens: chunk.usage.total_tokens
+        } : void 0
+      };
+    }
+  }
+  buildMessages(system, messages) {
+    const result = [];
+    if (system) {
+      result.push({ role: "system", content: system });
+    }
+    for (const msg of messages) {
+      if (msg.role === "tool") {
+        result.push({
+          role: "tool",
+          tool_call_id: msg.tool_call_id,
+          content: msg.content
+        });
+      } else if (msg.role === "assistant") {
+        const entry = {
+          role: "assistant",
+          content: msg.content
+        };
+        if (msg.tool_calls) {
+          entry.tool_calls = msg.tool_calls;
+        }
+        result.push(entry);
+      } else {
+        result.push({ role: msg.role, content: msg.content });
+      }
+    }
+    return result;
+  }
+};
+
+// src/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+var AnthropicProvider = class {
+  client;
+  defaultModel;
+  constructor(opts) {
+    this.client = new Anthropic({
+      apiKey: opts.apiKey,
+      baseURL: opts.baseURL
+    });
+    this.defaultModel = opts.model ?? "claude-sonnet-4-20250514";
+  }
+  async *chat(params) {
+    const { system, messages: inputMessages } = this.convertMessages(
+      params.system,
+      params.messages
+    );
+    const tools = params.tools?.map((t) => ({
+      name: t.function.name,
+      description: t.function.description,
+      input_schema: t.function.parameters
+    }));
+    const stream = this.client.messages.stream({
+      model: params.model ?? this.defaultModel,
+      max_tokens: params.max_tokens ?? 8192,
+      system,
+      messages: inputMessages,
+      tools
+    });
+    let chunkIndex = 0;
+    const toolIndexMap = /* @__PURE__ */ new Map();
+    let nextToolIndex = 0;
+    for await (const event of stream) {
+      const chunkId = `chatcmpl-${chunkIndex++}`;
+      if (event.type === "content_block_start") {
+        if (event.content_block.type === "text") {
+          yield this.makeChunk(chunkId, params.model ?? this.defaultModel, {
+            content: ""
+          });
+        } else if (event.content_block.type === "tool_use") {
+          const block = event.content_block;
+          const idx = nextToolIndex++;
+          toolIndexMap.set(block.id, idx);
+          yield this.makeChunk(chunkId, params.model ?? this.defaultModel, {
+            tool_calls: [
+              {
+                index: idx,
+                id: block.id,
+                type: "function",
+                function: { name: block.name, arguments: "" }
+              }
+            ]
+          });
+        }
+      } else if (event.type === "content_block_delta") {
+        if (event.delta.type === "text_delta") {
+          yield this.makeChunk(chunkId, params.model ?? this.defaultModel, {
+            content: event.delta.text
+          });
+        } else if (event.delta.type === "input_json_delta") {
+          const delta = event.delta;
+          const lastToolId = Array.from(toolIndexMap.keys()).pop();
+          const idx = toolIndexMap.get(lastToolId);
+          yield this.makeChunk(chunkId, params.model ?? this.defaultModel, {
+            tool_calls: [
+              {
+                index: idx,
+                function: { arguments: delta.partial_json }
+              }
+            ]
+          });
+        }
+      } else if (event.type === "message_stop") {
+        yield {
+          id: chunkId,
+          model: params.model ?? this.defaultModel,
+          choices: [
+            {
+              index: 0,
+              delta: {},
+              finish_reason: toolIndexMap.size > 0 ? "tool_calls" : "stop"
+            }
+          ]
+        };
+      }
+    }
+  }
+  makeChunk(id, model, delta) {
+    return {
+      id,
+      model,
+      choices: [
+        {
+          index: 0,
+          delta,
+          finish_reason: null
+        }
+      ]
+    };
+  }
+  convertMessages(systemPrompt, messages) {
+    const result = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        continue;
+      }
+      if (msg.role === "user") {
+        result.push({ role: "user", content: msg.content });
+      } else if (msg.role === "assistant") {
+        const content = [];
+        if (msg.content) {
+          content.push({ type: "text", text: msg.content });
+        }
+        if (msg.tool_calls) {
+          for (const tc of msg.tool_calls) {
+            content.push({
+              type: "tool_use",
+              id: tc.id,
+              name: tc.function.name,
+              input: JSON.parse(tc.function.arguments)
+            });
+          }
+        }
+        result.push({ role: "assistant", content });
+      } else if (msg.role === "tool") {
+        result.push({
+          role: "user",
+          content: [
+            {
+              type: "tool_result",
+              tool_use_id: msg.tool_call_id,
+              content: msg.content
+            }
+          ]
+        });
+      }
+    }
+    return { system: systemPrompt, messages: result };
+  }
+};
+
+// src/providers/gemini.ts
+import { GoogleGenAI } from "@google/genai";
+var GeminiProvider = class {
+  client;
+  defaultModel;
+  constructor(opts) {
+    this.client = new GoogleGenAI({ apiKey: opts.apiKey });
+    this.defaultModel = opts.model ?? "gemini-2.5-flash";
+  }
+  async *chat(params) {
+    const { contents, systemInstruction } = this.convertMessages(
+      params.system,
+      params.messages
+    );
+    const tools = params.tools?.length ? [
+      {
+        functionDeclarations: params.tools.map((t) => ({
+          name: t.function.name,
+          description: t.function.description,
+          parameters: t.function.parameters
+        }))
+      }
+    ] : void 0;
+    const stream = await this.client.models.generateContentStream({
+      model: params.model ?? this.defaultModel,
+      contents,
+      config: {
+        systemInstruction: systemInstruction || void 0,
+        maxOutputTokens: params.max_tokens,
+        temperature: params.temperature,
+        tools,
+        thinkingConfig: {
+          thinkingBudget: 0
+        }
+      }
+    });
+    let chunkIndex = 0;
+    let toolCallIndex = 0;
+    for await (const chunk of stream) {
+      const chunkId = `gemini-${chunkIndex++}`;
+      const model = params.model ?? this.defaultModel;
+      const candidates = chunk.candidates;
+      if (!candidates || candidates.length === 0) continue;
+      const parts = candidates[0].content?.parts;
+      if (!parts) continue;
+      for (const part of parts) {
+        if (part.text !== void 0 && part.text !== null) {
+          yield {
+            id: chunkId,
+            model,
+            choices: [
+              {
+                index: 0,
+                delta: { content: part.text },
+                finish_reason: null
+              }
+            ]
+          };
+        }
+        if (part.functionCall) {
+          const fc = part.functionCall;
+          const tcId = `gemini-tc-${toolCallIndex}`;
+          const idx = toolCallIndex++;
+          yield {
+            id: chunkId,
+            model,
+            choices: [
+              {
+                index: 0,
+                delta: {
+                  tool_calls: [
+                    {
+                      index: idx,
+                      id: tcId,
+                      type: "function",
+                      function: {
+                        name: fc.name,
+                        arguments: JSON.stringify(fc.args ?? {})
+                      }
+                    }
+                  ]
+                },
+                finish_reason: null
+              }
+            ]
+          };
+        }
+      }
+      const finishReason = candidates[0].finishReason;
+      if (finishReason && finishReason !== "FINISH_REASON_UNSPECIFIED") {
+        const mapped = finishReason === "STOP" ? toolCallIndex > 0 ? "tool_calls" : "stop" : "stop";
+        yield {
+          id: chunkId,
+          model,
+          choices: [{ index: 0, delta: {}, finish_reason: mapped }]
+        };
+      }
+    }
+  }
+  convertMessages(systemPrompt, messages) {
+    const contents = [];
+    const toolCallIdToName = /* @__PURE__ */ new Map();
+    for (const msg of messages) {
+      if (msg.role === "assistant" && msg.tool_calls) {
+        for (const tc of msg.tool_calls) {
+          toolCallIdToName.set(tc.id, tc.function.name);
+        }
+      }
+    }
+    let pendingFunctionResponses = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        continue;
+      }
+      if (msg.role === "user") {
+        if (pendingFunctionResponses.length > 0) {
+          contents.push({ role: "user", parts: pendingFunctionResponses });
+          pendingFunctionResponses = [];
+        }
+        contents.push({ role: "user", parts: [{ text: msg.content }] });
+      } else if (msg.role === "assistant") {
+        const parts = [];
+        if (msg.content) {
+          parts.push({ text: msg.content });
+        }
+        if (msg.tool_calls) {
+          for (const tc of msg.tool_calls) {
+            let args = {};
+            try {
+              args = JSON.parse(tc.function.arguments);
+            } catch {
+            }
+            parts.push({
+              functionCall: { name: tc.function.name, args }
+            });
+          }
+        }
+        if (parts.length > 0) {
+          contents.push({ role: "model", parts });
+        }
+      } else if (msg.role === "tool") {
+        const fnName = toolCallIdToName.get(msg.tool_call_id) ?? msg.tool_call_id;
+        pendingFunctionResponses.push({
+          functionResponse: {
+            name: fnName,
+            response: { result: msg.content }
+          }
+        });
+      }
+    }
+    if (pendingFunctionResponses.length > 0) {
+      contents.push({ role: "user", parts: pendingFunctionResponses });
+    }
+    return { contents, systemInstruction: systemPrompt };
+  }
+};
+
+// src/virtual/local-fs.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var LocalFs = class {
+  basePath;
+  constructor(opts) {
+    this.basePath = opts?.basePath ?? process.cwd();
+  }
+  resolve(p) {
+    if (path.isAbsolute(p)) return p;
+    return path.resolve(this.basePath, p);
+  }
+  async readFile(filePath, opts) {
+    const encoding = opts?.encoding ?? "utf-8";
+    return fs.readFile(this.resolve(filePath), { encoding });
+  }
+  async writeFile(filePath, content) {
+    const resolved = this.resolve(filePath);
+    await fs.mkdir(path.dirname(resolved), { recursive: true });
+    await fs.writeFile(resolved, content, "utf-8");
+  }
+  async appendFile(filePath, content) {
+    const resolved = this.resolve(filePath);
+    await fs.mkdir(path.dirname(resolved), { recursive: true });
+    await fs.appendFile(resolved, content, "utf-8");
+  }
+  async deleteFile(filePath, opts) {
+    await fs.rm(this.resolve(filePath), {
+      recursive: opts?.recursive ?? false,
+      force: true
+    });
+  }
+  async mkdir(dirPath, opts) {
+    await fs.mkdir(this.resolve(dirPath), {
+      recursive: opts?.recursive ?? false
+    });
+  }
+  async readdir(dirPath, opts) {
+    const resolved = this.resolve(dirPath);
+    const entries = await fs.readdir(resolved, { withFileTypes: true });
+    const results = [];
+    for (const entry of entries) {
+      const entryPath = path.join(resolved, entry.name);
+      results.push({
+        name: entry.name,
+        path: entryPath,
+        isDirectory: entry.isDirectory(),
+        isFile: entry.isFile()
+      });
+      if (opts?.recursive && entry.isDirectory()) {
+        const subEntries = await this.readdir(entryPath, { recursive: true });
+        results.push(...subEntries);
+      }
+    }
+    return results;
+  }
+  async exists(filePath) {
+    try {
+      await fs.access(this.resolve(filePath));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async stat(filePath) {
+    const stats = await fs.stat(this.resolve(filePath));
+    return {
+      size: stats.size,
+      isDirectory: stats.isDirectory(),
+      isFile: stats.isFile(),
+      createdAt: stats.birthtime,
+      modifiedAt: stats.mtime
+    };
+  }
+};
+
+// src/virtual/local-computer.ts
+import { exec as execCb } from "child_process";
+var LocalComputer = class {
+  defaultCwd;
+  defaultTimeout;
+  constructor(opts) {
+    this.defaultCwd = opts?.defaultCwd ?? process.cwd();
+    this.defaultTimeout = opts?.defaultTimeout ?? 3e4;
+  }
+  executeCommand(command, opts) {
+    return new Promise((resolve2) => {
+      const child = execCb(
+        command,
+        {
+          cwd: opts?.cwd ?? this.defaultCwd,
+          timeout: opts?.timeout ?? this.defaultTimeout,
+          env: opts?.env ? { ...process.env, ...opts.env } : process.env,
+          maxBuffer: 10 * 1024 * 1024,
+          shell: "/bin/bash"
+        },
+        (error, stdout, stderr) => {
+          resolve2({
+            exitCode: error && "code" in error ? error.code ?? 1 : child.exitCode ?? 0,
+            stdout: stdout ?? "",
+            stderr: stderr ?? ""
+          });
+        }
+      );
+    });
+  }
+};
+
+// src/virtual/sprites-fs.ts
+var SpritesFs = class {
+  token;
+  spriteName;
+  baseURL;
+  workingDir;
+  constructor(opts) {
+    this.token = opts.token;
+    this.spriteName = opts.spriteName;
+    this.baseURL = (opts.baseURL ?? "https://api.sprites.dev").replace(
+      /\/$/,
+      ""
+    );
+    this.workingDir = opts.workingDir ?? "/home/sprite";
+  }
+  fsUrl(endpoint, params) {
+    const url = new URL(
+      `${this.baseURL}/v1/sprites/${this.spriteName}/fs${endpoint}`
+    );
+    if (params) {
+      for (const [k, v] of Object.entries(params)) {
+        url.searchParams.set(k, v);
+      }
+    }
+    return url.toString();
+  }
+  resolvePath(p) {
+    if (p.startsWith("/")) return p;
+    return `${this.workingDir}/${p}`;
+  }
+  headers() {
+    return {
+      Authorization: `Bearer ${this.token}`
+    };
+  }
+  async readFile(filePath, _opts) {
+    const url = this.fsUrl("/read", { path: this.resolvePath(filePath) });
+    const res = await fetch(url, { headers: this.headers() });
+    if (!res.ok) {
+      throw new Error(
+        `SpritesFs readFile failed (${res.status}): ${await res.text()}`
+      );
+    }
+    return res.text();
+  }
+  async writeFile(filePath, content) {
+    const url = this.fsUrl("/write");
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...this.headers(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        path: this.resolvePath(filePath),
+        content
+      })
+    });
+    if (!res.ok) {
+      throw new Error(
+        `SpritesFs writeFile failed (${res.status}): ${await res.text()}`
+      );
+    }
+  }
+  async appendFile(filePath, content) {
+    let existing = "";
+    try {
+      existing = await this.readFile(filePath);
+    } catch {
+    }
+    await this.writeFile(filePath, existing + content);
+  }
+  async deleteFile(filePath, opts) {
+    const url = this.fsUrl("/remove");
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...this.headers(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        path: this.resolvePath(filePath),
+        recursive: opts?.recursive ?? false
+      })
+    });
+    if (!res.ok) {
+      throw new Error(
+        `SpritesFs deleteFile failed (${res.status}): ${await res.text()}`
+      );
+    }
+  }
+  async mkdir(dirPath, opts) {
+    const url = this.fsUrl("/mkdir");
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        ...this.headers(),
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        path: this.resolvePath(dirPath),
+        recursive: opts?.recursive ?? false
+      })
+    });
+    if (!res.ok) {
+      throw new Error(
+        `SpritesFs mkdir failed (${res.status}): ${await res.text()}`
+      );
+    }
+  }
+  async readdir(dirPath, _opts) {
+    const url = this.fsUrl("/readdir", { path: this.resolvePath(dirPath) });
+    const res = await fetch(url, { headers: this.headers() });
+    if (!res.ok) {
+      throw new Error(
+        `SpritesFs readdir failed (${res.status}): ${await res.text()}`
+      );
+    }
+    const data = await res.json();
+    return data.map((entry) => ({
+      name: entry.name,
+      path: entry.path,
+      isDirectory: entry.is_dir,
+      isFile: !entry.is_dir,
+      size: entry.size
+    }));
+  }
+  async exists(filePath) {
+    try {
+      await this.stat(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async stat(filePath) {
+    const url = this.fsUrl("/stat", { path: this.resolvePath(filePath) });
+    const res = await fetch(url, { headers: this.headers() });
+    if (!res.ok) {
+      throw new Error(
+        `SpritesFs stat failed (${res.status}): ${await res.text()}`
+      );
+    }
+    const data = await res.json();
+    return {
+      size: data.size,
+      isDirectory: data.is_dir,
+      isFile: !data.is_dir,
+      createdAt: data.created_at ? new Date(data.created_at) : void 0,
+      modifiedAt: data.modified_at ? new Date(data.modified_at) : void 0
+    };
+  }
+};
+
+// src/virtual/sprites-computer.ts
+var SpritesComputer = class {
+  token;
+  spriteName;
+  baseURL;
+  workingDir;
+  constructor(opts) {
+    this.token = opts.token;
+    this.spriteName = opts.spriteName;
+    this.baseURL = (opts.baseURL ?? "https://api.sprites.dev").replace(
+      /\/$/,
+      ""
+    );
+    this.workingDir = opts.workingDir ?? "/home/sprite";
+  }
+  headers() {
+    return {
+      Authorization: `Bearer ${this.token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async executeCommand(command, opts) {
+    const cwd = opts?.cwd ?? this.workingDir;
+    const wrappedCommand = `cd ${this.shellEscape(cwd)} && ${command}`;
+    const url = `${this.baseURL}/v1/sprites/${this.spriteName}/exec`;
+    const res = await fetch(url, {
+      method: "POST",
+      headers: this.headers(),
+      body: JSON.stringify({
+        command: ["bash", "-c", wrappedCommand],
+        timeout: opts?.timeout ?? 3e4,
+        env: opts?.env
+      })
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      return {
+        exitCode: 1,
+        stdout: "",
+        stderr: `Sprites exec failed (${res.status}): ${text}`
+      };
+    }
+    const data = await res.json();
+    return {
+      exitCode: data.exit_code,
+      stdout: data.stdout ?? "",
+      stderr: data.stderr ?? ""
+    };
+  }
+  shellEscape(s) {
+    return `'${s.replace(/'/g, "'\\''")}'`;
+  }
+};
+export {
+  AnthropicProvider,
+  Code,
+  GeminiProvider,
+  LocalComputer,
+  LocalFs,
+  OpenAIProvider,
+  SpritesComputer,
+  SpritesFs,
+  Thread,
+  ToolRegistry,
+  bashTool,
+  buildSystemPrompt,
+  compactConversation,
+  createAutoCompactConfig,
+  editFileTool,
+  globTool,
+  grepTool,
+  loadSkills,
+  readFileTool,
+  shouldAutoCompact,
+  writeFileTool
+};
+//# sourceMappingURL=index.js.map