@princetheprogrammerbtw/husk 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,1146 @@
+import { promisify, parseArgs } from 'util';
+import { promises } from 'fs';
+import { resolve, dirname, join } from 'path';
+import Anthropic from '@anthropic-ai/sdk';
+import OpenAI from 'openai';
+import { exec } from 'child_process';
+
+// src/cli/index.ts
+
+// src/core/events.ts
+var AgentEventEmitter = class {
+  handlers = /* @__PURE__ */ new Map();
+  wildcardHandlers = [];
+  /**
+   * Subscribe to a specific event type. The handler receives only
+   * events of that type with the correct payload shape.
+   */
+  on(type, handler) {
+    const list = this.handlers.get(type) ?? [];
+    list.push(handler);
+    this.handlers.set(type, list);
+    return () => this.off(type, handler);
+  }
+  /**
+   * Subscribe to all events. Useful for loggers and tracers.
+   */
+  onAny(handler) {
+    this.wildcardHandlers.push(handler);
+    return () => {
+      const idx = this.wildcardHandlers.indexOf(handler);
+      if (idx >= 0) this.wildcardHandlers.splice(idx, 1);
+    };
+  }
+  off(type, handler) {
+    const list = this.handlers.get(type);
+    if (!list) return;
+    const idx = list.indexOf(handler);
+    if (idx >= 0) list.splice(idx, 1);
+  }
+  /**
+   * Emit an event. Handlers are awaited sequentially; an async handler
+   * that throws is logged but doesn't stop subsequent handlers.
+   */
+  async emit(event) {
+    const typed = this.handlers.get(event.type) ?? [];
+    for (const handler of typed) {
+      try {
+        await handler(event);
+      } catch (err) {
+        console.error("[husk] event handler threw:", err);
+      }
+    }
+    for (const handler of this.wildcardHandlers) {
+      try {
+        await handler(event);
+      } catch (err) {
+        console.error("[husk] wildcard event handler threw:", err);
+      }
+    }
+  }
+};
+var ConsoleLogger = class {
+  debug(message, fields) {
+    console.debug(this.format("debug", message, fields));
+  }
+  info(message, fields) {
+    console.info(this.format("info", message, fields));
+  }
+  warn(message, fields) {
+    console.warn(this.format("warn", message, fields));
+  }
+  error(message, fields) {
+    console.error(this.format("error", message, fields));
+  }
+  format(level, message, fields) {
+    const ts = (/* @__PURE__ */ new Date()).toISOString();
+    const fieldsStr = fields && Object.keys(fields).length > 0 ? ` ${JSON.stringify(fields)}` : "";
+    return `${ts} [${level}] ${message}${fieldsStr}`;
+  }
+};
+var InMemoryStore = class {
+  sessions = /* @__PURE__ */ new Map();
+  async read(sessionId) {
+    return [...this.sessions.get(sessionId) ?? []];
+  }
+  async append(sessionId, message) {
+    const list = this.sessions.get(sessionId) ?? [];
+    list.push(message);
+    this.sessions.set(sessionId, list);
+  }
+  async clear(sessionId) {
+    this.sessions.delete(sessionId);
+  }
+  async listSessions() {
+    return [...this.sessions.keys()];
+  }
+};
+var FileStore = class {
+  rootDir;
+  unified;
+  writeLocks = /* @__PURE__ */ new Map();
+  constructor(options = {}) {
+    this.rootDir = options.path ?? "./.husk/memory";
+    this.unified = options.unified ?? false;
+  }
+  async read(sessionId) {
+    const file = this.fileFor(sessionId);
+    try {
+      const text = await promises.readFile(file, "utf-8");
+      const lines = text.split("\n").filter((line) => line.trim().length > 0);
+      const messages = [];
+      for (const line of lines) {
+        try {
+          const parsed = JSON.parse(line);
+          if (this.unified && parsed.session && parsed.session !== sessionId) continue;
+          messages.push(parsed.message);
+        } catch {
+        }
+      }
+      return messages;
+    } catch (err) {
+      if (isNoEnt(err)) return [];
+      throw err;
+    }
+  }
+  async append(sessionId, message) {
+    const previous = this.writeLocks.get(sessionId) ?? Promise.resolve();
+    const next = previous.then(() => this.doAppend(sessionId, message));
+    this.writeLocks.set(
+      sessionId,
+      next.catch(() => void 0)
+    );
+    return next;
+  }
+  async doAppend(sessionId, message) {
+    await promises.mkdir(this.rootDir, { recursive: true });
+    const file = this.fileFor(sessionId);
+    const entry = this.unified ? JSON.stringify({ session: sessionId, message }) : JSON.stringify({ message });
+    await promises.appendFile(file, `${entry}
+`, "utf-8");
+  }
+  async clear(sessionId) {
+    const file = this.fileFor(sessionId);
+    try {
+      await promises.unlink(file);
+    } catch (err) {
+      if (!isNoEnt(err)) throw err;
+    }
+  }
+  async listSessions() {
+    if (this.unified) {
+      const file = join(this.rootDir, "unified.jsonl");
+      try {
+        const text = await promises.readFile(file, "utf-8");
+        const ids = /* @__PURE__ */ new Set();
+        for (const line of text.split("\n")) {
+          if (!line.trim()) continue;
+          try {
+            const parsed = JSON.parse(line);
+            if (parsed.session) ids.add(parsed.session);
+          } catch {
+          }
+        }
+        return [...ids];
+      } catch (err) {
+        if (isNoEnt(err)) return [];
+        throw err;
+      }
+    }
+    try {
+      const entries = await promises.readdir(this.rootDir);
+      return entries.filter((e) => e.endsWith(".jsonl")).map((e) => e.replace(/\.jsonl$/, ""));
+    } catch (err) {
+      if (isNoEnt(err)) return [];
+      throw err;
+    }
+  }
+  fileFor(sessionId) {
+    if (this.unified) return join(this.rootDir, "unified.jsonl");
+    return join(this.rootDir, `${sanitize(sessionId)}.jsonl`);
+  }
+};
+function isNoEnt(err) {
+  return Boolean(
+    err && typeof err === "object" && "code" in err && err.code === "ENOENT"
+  );
+}
+function sanitize(sessionId) {
+  return sessionId.replace(/[^a-zA-Z0-9._-]/g, "_");
+}
+
+// src/core/steering.ts
+function buildSystemPrompt(steering) {
+  const parts = [];
+  if (steering.systemPrompt && steering.systemPrompt.trim().length > 0) {
+    parts.push(steering.systemPrompt.trim());
+  }
+  if (steering.rules && steering.rules.length > 0) {
+    const numbered = steering.rules.map((rule, i) => `${i + 1}. ${rule}`).join("\n");
+    parts.push(`## Rules
+${numbered}`);
+  }
+  return parts.length > 0 ? parts.join("\n\n") : void 0;
+}
+function buildExampleMessages(examples) {
+  const messages = [];
+  for (const ex of examples) {
+    messages.push({ role: "user", content: ex.user });
+    messages.push({ role: "assistant", content: ex.assistant });
+  }
+  return messages;
+}
+
+// src/core/agent.ts
+var DEFAULTS = {
+  maxIterations: 25,
+  temperature: 0,
+  sessionId: "default"
+};
+var Agent = class {
+  events;
+  provider;
+  tools;
+  steering;
+  maxIterations;
+  temperature;
+  maxTokens;
+  signal;
+  sessionId;
+  memory;
+  logger;
+  constructor(config) {
+    this.events = new AgentEventEmitter();
+    this.provider = config.model;
+    this.tools = config.tools ?? [];
+    this.steering = config.steering;
+    this.maxIterations = config.maxIterations ?? DEFAULTS.maxIterations;
+    this.temperature = config.temperature ?? DEFAULTS.temperature;
+    this.maxTokens = config.maxTokens;
+    this.signal = config.signal;
+    this.sessionId = config.sessionId ?? DEFAULTS.sessionId;
+    this.memory = config.memory;
+    this.logger = new ConsoleLogger();
+  }
+  /**
+   * Subscribe to a specific event type. Returns an unsubscribe fn.
+   */
+  on = (type, handler) => this.events.on(type, handler);
+  /**
+   * Subscribe to all events. Returns an unsubscribe fn.
+   */
+  onAny = (handler) => this.events.onAny(handler);
+  /**
+   * Run the agent loop to completion on the given input.
+   * Returns the final result with output text, full message history,
+   * token usage, and duration.
+   */
+  async run(input) {
+    const start = Date.now();
+    this.signal?.throwIfAborted();
+    await this.events.emit({ type: "agent:start", input, sessionId: this.sessionId });
+    const messages = [];
+    if (this.steering?.examples) {
+      messages.push(...buildExampleMessages(this.steering.examples));
+    }
+    if (this.memory) {
+      const stored = await this.memory.read(this.sessionId);
+      messages.push(...stored);
+    }
+    const userMessage = { role: "user", content: input };
+    messages.push(userMessage);
+    await this.recordMessage(userMessage);
+    const system = this.steering ? buildSystemPrompt(this.steering) : void 0;
+    const tools = this.tools.length > 0 ? this.tools : void 0;
+    let totalInputTokens = 0;
+    let totalOutputTokens = 0;
+    let iterations = 0;
+    let finalOutput = "";
+    let hitMaxIterations = false;
+    while (iterations < this.maxIterations) {
+      this.signal?.throwIfAborted();
+      iterations += 1;
+      await this.events.emit({ type: "agent:iteration", iteration: iterations });
+      const request = {
+        model: this.provider.model,
+        messages,
+        ...tools ? { tools } : {},
+        ...system ? { system } : {},
+        temperature: this.temperature,
+        ...this.maxTokens ? { maxTokens: this.maxTokens } : {}
+      };
+      await this.events.emit({ type: "provider:request", request });
+      const t0 = Date.now();
+      const response = await this.provider.chat(request);
+      const durationMs2 = Date.now() - t0;
+      await this.events.emit({ type: "provider:response", response, durationMs: durationMs2 });
+      totalInputTokens += response.usage.inputTokens;
+      totalOutputTokens += response.usage.outputTokens;
+      await this.recordMessage(response.message);
+      switch (response.stopReason) {
+        case "end_turn":
+        case "stop_sequence": {
+          finalOutput = extractText(response.message);
+          break;
+        }
+        case "max_tokens": {
+          finalOutput = extractText(response.message);
+          this.logger.warn("Model hit max_tokens; output may be truncated", {
+            outputTokens: response.usage.outputTokens
+          });
+          break;
+        }
+        case "tool_use": {
+          const toolUses = extractToolUses(response.message);
+          if (toolUses.length === 0) {
+            finalOutput = extractText(response.message);
+            break;
+          }
+          const results = await Promise.all(
+            toolUses.map(async (tu) => {
+              await this.events.emit({
+                type: "tool:call",
+                id: tu.id,
+                name: tu.name,
+                input: tu.input
+              });
+              const ts = Date.now();
+              const result2 = await this.executeTool(tu.name, tu.input);
+              const dur = Date.now() - ts;
+              await this.events.emit({
+                type: "tool:result",
+                id: tu.id,
+                name: tu.name,
+                result: result2,
+                durationMs: dur
+              });
+              return { tu, result: result2 };
+            })
+          );
+          const toolMessage = {
+            role: "user",
+            content: results.map(
+              ({ tu, result: result2 }) => ({
+                type: "tool_result",
+                toolUseId: tu.id,
+                content: result2.output,
+                ...result2.isError ? { isError: true } : {}
+              })
+            )
+          };
+          await this.recordMessage(toolMessage);
+          continue;
+        }
+        case "error": {
+          throw new Error(`Provider returned error stop reason: ${extractText(response.message)}`);
+        }
+      }
+      if (finalOutput !== "" || response.stopReason !== "tool_use") {
+        break;
+      }
+    }
+    if (iterations >= this.maxIterations && finalOutput === "") {
+      hitMaxIterations = true;
+      this.logger.warn(`Agent hit max iterations (${this.maxIterations}) without end_turn`, {
+        sessionId: this.sessionId
+      });
+      const last = messages[messages.length - 1];
+      if (last) finalOutput = extractText(last);
+    }
+    const durationMs = Date.now() - start;
+    const result = {
+      output: finalOutput,
+      messages,
+      iterations,
+      usage: {
+        inputTokens: totalInputTokens,
+        outputTokens: totalOutputTokens
+      },
+      durationMs
+    };
+    await this.events.emit({
+      type: "agent:end",
+      output: finalOutput,
+      iterations,
+      durationMs
+    });
+    if (hitMaxIterations) {
+      this.logger.warn("Agent ended without clean termination", { hitMaxIterations: true });
+    }
+    return result;
+  }
+  // ── Internals ────────────────────────────────────────────────
+  async recordMessage(message) {
+    await this.events.emit({ type: "agent:message", message });
+    if (this.memory) {
+      await this.memory.append(this.sessionId, message);
+    }
+  }
+  async executeTool(name, input) {
+    const tool = this.tools.find((t) => t.name === name);
+    if (!tool) {
+      return {
+        output: `Error: tool '${name}' is not registered. Available tools: ${this.tools.map((t) => t.name).join(", ")}`,
+        isError: true
+      };
+    }
+    const validation = validateInput(input, tool.inputSchema);
+    if (!validation.valid) {
+      return {
+        output: `Error: invalid input for tool '${name}': ${validation.error}`,
+        isError: true
+      };
+    }
+    try {
+      return await tool.execute(input, { signal: this.signal, logger: this.logger });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { output: `Error executing tool '${name}': ${message}`, isError: true };
+    }
+  }
+};
+function extractText(message) {
+  if (typeof message.content === "string") return message.content;
+  return message.content.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+}
+function extractToolUses(message) {
+  if (typeof message.content === "string") return [];
+  return message.content.filter((b) => b.type === "tool_use");
+}
+function validateInput(input, schema) {
+  if (typeof input !== "object" || input === null) {
+    return { valid: false, error: "Input must be an object" };
+  }
+  if (schema.required) {
+    for (const key of schema.required) {
+      if (!(key in input)) {
+        return { valid: false, error: `Missing required field: ${key}` };
+      }
+    }
+  }
+  return { valid: true };
+}
+var AnthropicProvider = class {
+  name = "anthropic";
+  model;
+  client;
+  defaultMaxTokens;
+  constructor(options = {}) {
+    this.model = options.model ?? "claude-opus-4-6";
+    this.client = new Anthropic({
+      apiKey: options.apiKey ?? process.env.ANTHROPIC_API_KEY,
+      ...options.baseURL ? { baseURL: options.baseURL } : {}
+    });
+    this.defaultMaxTokens = options.maxTokens ?? 8192;
+  }
+  async chat(request) {
+    const { system, messages } = splitSystemMessage(request.messages);
+    const anthropicTools = request.tools?.map(toHuskToolToAnthropic);
+    const response = await this.client.messages.create({
+      model: request.model || this.model,
+      ...system ? { system } : {},
+      messages: messages.map(toAnthropicMessage),
+      ...anthropicTools && anthropicTools.length > 0 ? { tools: anthropicTools } : {},
+      max_tokens: request.maxTokens ?? this.defaultMaxTokens,
+      ...request.temperature !== void 0 ? { temperature: request.temperature } : {},
+      ...request.stopSequences ? { stop_sequences: [...request.stopSequences] } : {}
+    });
+    return {
+      message: {
+        role: "assistant",
+        content: response.content.map(fromAnthropicBlock)
+      },
+      usage: {
+        inputTokens: response.usage.input_tokens,
+        outputTokens: response.usage.output_tokens
+      },
+      stopReason: mapStopReason(response.stop_reason),
+      model: response.model
+    };
+  }
+};
+function splitSystemMessage(messages) {
+  const systemParts = [];
+  const rest = [];
+  for (const m of messages) {
+    if (m.role === "system") {
+      const text = typeof m.content === "string" ? m.content : extractTextFromBlocks(m.content);
+      if (text) systemParts.push(text);
+    } else {
+      rest.push(m);
+    }
+  }
+  return {
+    system: systemParts.length > 0 ? systemParts.join("\n\n") : void 0,
+    messages: rest
+  };
+}
+function extractTextFromBlocks(blocks) {
+  return blocks.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+}
+function toHuskToolToAnthropic(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    input_schema: tool.inputSchema
+  };
+}
+function toAnthropicMessage(message) {
+  if (message.role === "user") {
+    if (typeof message.content === "string") {
+      return { role: "user", content: message.content };
+    }
+    return {
+      role: "user",
+      content: message.content.map((block) => {
+        if (block.type === "text") {
+          return { type: "text", text: block.text };
+        }
+        if (block.type === "tool_result") {
+          return {
+            type: "tool_result",
+            tool_use_id: block.toolUseId,
+            content: typeof block.content === "string" ? block.content : block.content.map((b) => {
+              if (b.type === "text") return { type: "text", text: b.text };
+              return { type: "text", text: JSON.stringify(b) };
+            }),
+            ...block.isError ? { is_error: true } : {}
+          };
+        }
+        if (block.type === "tool_use") {
+          return {
+            type: "tool_use",
+            id: block.id,
+            name: block.name,
+            input: block.input
+          };
+        }
+        return { type: "text", text: "" };
+      })
+    };
+  }
+  if (message.role === "assistant") {
+    if (typeof message.content === "string") {
+      return { role: "assistant", content: message.content };
+    }
+    return {
+      role: "assistant",
+      content: message.content.map((block) => {
+        if (block.type === "text") {
+          return { type: "text", text: block.text };
+        }
+        if (block.type === "tool_use") {
+          return {
+            type: "tool_use",
+            id: block.id,
+            name: block.name,
+            input: block.input
+          };
+        }
+        return { type: "text", text: "" };
+      })
+    };
+  }
+  return { role: "user", content: "" };
+}
+function fromAnthropicBlock(block) {
+  if (block.type === "text") {
+    return { type: "text", text: block.text };
+  }
+  if (block.type === "tool_use") {
+    return {
+      type: "tool_use",
+      id: block.id,
+      name: block.name,
+      input: block.input
+    };
+  }
+  return { type: "text", text: "" };
+}
+function mapStopReason(reason) {
+  switch (reason) {
+    case "end_turn":
+      return "end_turn";
+    case "tool_use":
+      return "tool_use";
+    case "max_tokens":
+      return "max_tokens";
+    case "stop_sequence":
+      return "stop_sequence";
+    default:
+      return "error";
+  }
+}
+var OpenAIProvider = class {
+  name = "openai";
+  model;
+  client;
+  constructor(options = {}) {
+    this.model = options.model ?? "gpt-5";
+    this.client = new OpenAI({
+      apiKey: options.apiKey ?? process.env.OPENAI_API_KEY,
+      ...options.baseURL ? { baseURL: options.baseURL } : {},
+      ...options.organization ? { organization: options.organization } : {}
+    });
+  }
+  async chat(request) {
+    const { system, messages } = splitSystemMessage2(request.messages);
+    const openaiTools = request.tools?.map(toOpenAITool);
+    const response = await this.client.chat.completions.create({
+      model: request.model || this.model,
+      ...system ? { messages: [{ role: "system", content: system }] } : {},
+      messages: [
+        ...system ? [{ role: "system", content: system }] : [],
+        ...messages.flatMap((m) => toOpenAIMessages(m))
+      ],
+      ...openaiTools && openaiTools.length > 0 ? { tools: openaiTools } : {},
+      ...request.temperature !== void 0 ? { temperature: request.temperature } : {},
+      ...request.maxTokens ? { max_tokens: request.maxTokens } : {},
+      ...request.stopSequences ? { stop: [...request.stopSequences] } : {}
+    });
+    const choice = response.choices[0];
+    if (!choice) {
+      throw new Error("OpenAI returned no choices");
+    }
+    const assistantMessage = choice.message;
+    return {
+      message: {
+        role: "assistant",
+        content: fromOpenAIAssistantMessage(assistantMessage)
+      },
+      usage: {
+        inputTokens: response.usage?.prompt_tokens ?? 0,
+        outputTokens: response.usage?.completion_tokens ?? 0
+      },
+      stopReason: mapStopReason2(choice.finish_reason),
+      model: response.model
+    };
+  }
+};
+function splitSystemMessage2(messages) {
+  const systemParts = [];
+  const rest = [];
+  for (const m of messages) {
+    if (m.role === "system") {
+      const text = typeof m.content === "string" ? m.content : extractTextFromBlocks2(m.content);
+      if (text) systemParts.push(text);
+    } else {
+      rest.push(m);
+    }
+  }
+  return {
+    system: systemParts.length > 0 ? systemParts.join("\n\n") : void 0,
+    messages: rest
+  };
+}
+function extractTextFromBlocks2(blocks) {
+  return blocks.filter((b) => b.type === "text").map((b) => b.text).join("\n");
+}
+function toOpenAITool(tool) {
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.inputSchema
+    }
+  };
+}
+function toOpenAIMessages(message) {
+  if (message.role === "system") {
+    const text = typeof message.content === "string" ? message.content : extractTextFromBlocks2(message.content);
+    return [{ role: "system", content: text }];
+  }
+  if (message.role === "user") {
+    if (typeof message.content === "string") {
+      return [{ role: "user", content: message.content }];
+    }
+    const toolResults = message.content.filter((b) => b.type === "tool_result");
+    const textBlocks = message.content.filter((b) => b.type === "text");
+    const out = [];
+    if (textBlocks.length > 0) {
+      out.push({
+        role: "user",
+        content: textBlocks.map((b) => b.text).join("\n")
+      });
+    }
+    for (const tr of toolResults) {
+      if (tr.type !== "tool_result") continue;
+      out.push({
+        role: "tool",
+        tool_call_id: tr.toolUseId,
+        content: typeof tr.content === "string" ? tr.content : tr.content.map((b) => b.type === "text" ? b.text : JSON.stringify(b)).join("\n")
+      });
+    }
+    return out;
+  }
+  if (message.role === "assistant") {
+    if (typeof message.content === "string") {
+      return [{ role: "assistant", content: message.content }];
+    }
+    const textParts = [];
+    const toolCalls = [];
+    for (const block of message.content) {
+      if (block.type === "text") {
+        textParts.push(block.text);
+      } else if (block.type === "tool_use") {
+        toolCalls.push({
+          id: block.id,
+          type: "function",
+          function: {
+            name: block.name,
+            arguments: JSON.stringify(block.input ?? {})
+          }
+        });
+      }
+    }
+    const out = {
+      role: "assistant",
+      content: textParts.length > 0 ? textParts.join("\n") : null
+    };
+    if (toolCalls.length > 0) {
+      out.tool_calls = toolCalls;
+    }
+    return [out];
+  }
+  if (message.role === "tool") {
+    const text = typeof message.content === "string" ? message.content : extractTextFromBlocks2(message.content);
+    return [
+      {
+        role: "tool",
+        tool_call_id: message.toolCallId ?? message.name ?? "unknown",
+        content: text
+      }
+    ];
+  }
+  return [];
+}
+function fromOpenAIAssistantMessage(msg) {
+  const blocks = [];
+  if (msg.content) {
+    blocks.push({ type: "text", text: msg.content });
+  }
+  if (msg.tool_calls) {
+    for (const call of msg.tool_calls) {
+      if (call.type !== "function") continue;
+      let parsed = {};
+      try {
+        parsed = JSON.parse(call.function.arguments);
+      } catch {
+        parsed = { _parseError: call.function.arguments };
+      }
+      blocks.push({
+        type: "tool_use",
+        id: call.id,
+        name: call.function.name,
+        input: parsed
+      });
+    }
+  }
+  return blocks;
+}
+function mapStopReason2(reason) {
+  switch (reason) {
+    case "stop":
+      return "end_turn";
+    case "tool_calls":
+    case "function_call":
+      return "tool_use";
+    case "length":
+      return "max_tokens";
+    case "content_filter":
+      return "stop_sequence";
+    default:
+      return "error";
+  }
+}
+
+// src/tools/registry.ts
+function defineTool(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: tool.inputSchema,
+    execute: async (input) => {
+      const result = await tool.execute(input);
+      return typeof result === "string" ? { output: result } : result;
+    }
+  };
+}
+function stringField(description, options) {
+  return { type: "string", description };
+}
+function integerField(description) {
+  return { type: "integer", description };
+}
+function booleanField(description) {
+  return { type: "boolean", description };
+}
+function objectSchema(properties, required) {
+  return {
+    type: "object",
+    properties,
+    ...required ? { required } : {}
+  };
+}
+var Read = defineTool({
+  name: "Read",
+  description: "Read a file from the filesystem. Returns the file contents as text, with line numbers. Use offset and limit to page through large files.",
+  inputSchema: objectSchema(
+    {
+      path: stringField("Path to the file, relative to the working directory."),
+      offset: integerField("Line number to start reading from (1-indexed). Default: 1."),
+      limit: integerField("Maximum number of lines to read. Default: 2000.")
+    },
+    ["path"]
+  ),
+  execute: async (input) => {
+    const absolute = resolve(input.path);
+    const offset = input.offset ?? 1;
+    const limit = input.limit ?? 2e3;
+    let text;
+    try {
+      text = await promises.readFile(absolute, "utf-8");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return `Error reading file '${input.path}': ${message}`;
+    }
+    const lines = text.split("\n");
+    const start = Math.max(0, offset - 1);
+    const end = Math.min(lines.length, start + limit);
+    const slice = lines.slice(start, end);
+    const numbered = slice.map((line, i) => `${String(start + i + 1).padStart(6, " ")}	${line}`);
+    const header = lines.length > end ? `
+... (${lines.length - end} more lines)
+` : "";
+    return numbered.join("\n") + header;
+  }
+});
+var Write = defineTool({
+  name: "Write",
+  description: "Write content to a file. Creates parent directories as needed. Overwrites the file if it already exists. Use this for new files or full rewrites; use Edit for small changes.",
+  inputSchema: objectSchema(
+    {
+      path: stringField("Path to the file, relative to the working directory."),
+      content: stringField("Content to write to the file.")
+    },
+    ["path", "content"]
+  ),
+  execute: async (input) => {
+    const absolute = resolve(input.path);
+    try {
+      await promises.mkdir(dirname(absolute), { recursive: true });
+      await promises.writeFile(absolute, input.content, "utf-8");
+      const bytes = Buffer.byteLength(input.content, "utf-8");
+      return `Wrote ${bytes} bytes to ${absolute}`;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return `Error writing file '${input.path}': ${message}`;
+    }
+  }
+});
+var Edit = defineTool({
+  name: "Edit",
+  description: "Replace a specific string in a file. The oldText must match exactly one location in the file (include enough surrounding context to make it unique). Use this for small, targeted changes; use Write for full file rewrites.",
+  inputSchema: objectSchema(
+    {
+      path: stringField("Path to the file, relative to the working directory."),
+      oldText: stringField("The exact text to replace. Must match exactly once in the file."),
+      newText: stringField("The text to replace it with.")
+    },
+    ["path", "oldText", "newText"]
+  ),
+  execute: async (input) => {
+    const absolute = resolve(input.path);
+    let original;
+    try {
+      original = await promises.readFile(absolute, "utf-8");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return `Error reading file '${input.path}': ${message}`;
+    }
+    let count = 0;
+    let idx = -1;
+    let searchFrom = 0;
+    while (true) {
+      const found = original.indexOf(input.oldText, searchFrom);
+      if (found === -1) break;
+      count += 1;
+      idx = found;
+      searchFrom = found + 1;
+    }
+    if (count === 0) {
+      return `Error: oldText not found in file '${input.path}'. The text must match exactly (including whitespace and indentation).`;
+    }
+    if (count > 1) {
+      return `Error: oldText matches ${count} locations in '${input.path}'. Include more surrounding context to make the match unique, or call Edit separately for each occurrence.`;
+    }
+    const updated = original.slice(0, idx) + input.newText + original.slice(idx + input.oldText.length);
+    try {
+      await promises.writeFile(absolute, updated, "utf-8");
+      return `Edited ${absolute} (replaced ${input.oldText.length} chars with ${input.newText.length} chars)`;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return `Error writing file '${input.path}': ${message}`;
+    }
+  }
+});
+var execAsync = promisify(exec);
+var DENY_PATTERNS = [
+  /\brm\s+(-[a-z]*f[a-z]*\s+)?-[a-z]*r[a-z]*\s+\/\s*$/i,
+  // rm -rf / (with optional -f variations)
+  /\brm\s+(-[a-z]*r[a-z]*\s+)?-[a-z]*f[a-z]*\s+\/\s*$/i,
+  // rm -rf / (reversed flags)
+  /\bdd\s+.*\bof=\/dev\/(sd|hd|nvme|vd)/i,
+  // dd to a raw block device
+  /\bmkfs(\.[a-z0-9]+)?\s+\/dev\/(sd|hd|nvme|vd)/i,
+  // mkfs on a raw block device
+  /:\(\)\s*\{.*:\s*\|.*&\s*\}\s*;\s*:/,
+  // classic bash fork bomb
+  />\s*\/dev\/(sd|hd|nvme|vd)/i,
+  // redirect to a raw block device
+  /\bchmod\s+(-R\s+)?000\s+\//i,
+  // chmod 000 /
+  /\bchown\s+(-R\s+)?\S+\s+\/\s*$/i
+  // chown -R anything /
+];
+var DEFAULT_TIMEOUT_MS = 6e4;
+var MAX_TIMEOUT_MS = 6e5;
+var Bash = defineTool({
+  name: "Bash",
+  description: "Execute a shell command. Returns stdout, stderr (if any), and the exit code. Use for running scripts, installing packages, git operations, and other shell tasks. Has a 60-second default timeout; pass timeout (in ms) for longer commands.",
+  inputSchema: objectSchema(
+    {
+      command: stringField("The shell command to execute."),
+      description: stringField("A short description of what this command does (for logging)."),
+      timeout: integerField("Timeout in milliseconds. Default: 60000. Max: 600000.")
+    },
+    ["command"]
+  ),
+  execute: async (input) => {
+    for (const pattern of DENY_PATTERNS) {
+      if (pattern.test(input.command)) {
+        return `Error: command blocked by safety policy. The command matches a known dangerous pattern: ${pattern}
+
+If this is intentional, the user must run it manually.`;
+      }
+    }
+    const timeout = Math.min(input.timeout ?? DEFAULT_TIMEOUT_MS, MAX_TIMEOUT_MS);
+    try {
+      const { stdout, stderr } = await execAsync(input.command, { timeout });
+      const out = stdout ? `STDOUT:
+${stdout}` : "(no stdout)";
+      const err = stderr ? `
+STDERR:
+${stderr}` : "";
+      return `${out}${err}`.trim();
+    } catch (err) {
+      const e = err;
+      if (e.killed) {
+        return `Error: command timed out after ${timeout}ms. If you need longer, pass a higher timeout (max 600000ms).`;
+      }
+      const out = e.stdout ? `STDOUT:
+${e.stdout}
+` : "";
+      const errOut = e.stderr ? `STDERR:
+${e.stderr}
+` : "";
+      return `Error: command exited with code ${e.code ?? "unknown"}.
+${out}${errOut}Message: ${e.message ?? "unknown"}`;
+    }
+  }
+});
+var execAsync2 = promisify(exec);
+var Grep = defineTool({
+  name: "Grep",
+  description: `Search files for a regex pattern. Returns matching lines in 'file:line:content' format. Uses ripgrep if available, falls back to grep. Default scope is the current directory, recursive, respecting .gitignore.`,
+  inputSchema: objectSchema(
+    {
+      pattern: stringField("Regex pattern to search for."),
+      path: stringField("File or directory to search in. Default: current directory."),
+      glob: stringField("File glob to filter by (e.g. '*.ts'). Default: all files."),
+      ignoreCase: booleanField("Case-insensitive search. Default: false."),
+      limit: integerField("Maximum number of matching lines to return. Default: 100.")
+    },
+    ["pattern"]
+  ),
+  execute: async (input) => {
+    const limit = input.limit ?? 100;
+    const target = input.path ?? ".";
+    try {
+      const args = [
+        "--line-number",
+        "--no-heading",
+        "--color=never",
+        ...input.ignoreCase ? ["--ignore-case"] : [],
+        ...input.glob ? [`--glob=${input.glob}`] : [],
+        "--",
+        input.pattern,
+        target
+      ];
+      const { stdout } = await execAsync2(`rg ${args.map(shellQuote).join(" ")}`, {
+        maxBuffer: 10 * 1024 * 1024
+      });
+      return truncateOutput(stdout, limit);
+    } catch (err) {
+      const e = err;
+      if (e.code === 1 && !e.stdout) {
+        return "No matches found.";
+      }
+    }
+    try {
+      const args = [
+        "-rn",
+        "--color=never",
+        ...input.ignoreCase ? ["-i"] : [],
+        ...input.glob ? [`--include=${input.glob}`] : [],
+        "-E",
+        "--",
+        input.pattern,
+        target
+      ];
+      const { stdout } = await execAsync2(`grep ${args.map(shellQuote).join(" ")}`, {
+        maxBuffer: 10 * 1024 * 1024
+      });
+      return truncateOutput(stdout, limit);
+    } catch (err) {
+      const e = err;
+      if (e.code === 1 && !e.stdout) {
+        return "No matches found.";
+      }
+      return `Error running grep: ${e.message ?? "unknown"}`;
+    }
+  }
+});
+function shellQuote(s) {
+  if (/^[a-zA-Z0-9_./:=@%+-]+$/.test(s)) return s;
+  return `'${s.replace(/'/g, `'\\''`)}'`;
+}
+function truncateOutput(output, limit) {
+  const lines = output.split("\n");
+  if (lines.length <= limit) return output || "No matches found.";
+  return `${lines.slice(0, limit).join("\n")}
+... (${lines.length - limit} more matches truncated)`;
+}
+
+// src/cli/index.ts
+var TOOL_REGISTRY = { read: Read, write: Write, edit: Edit, bash: Bash, grep: Grep };
+async function main() {
+  const subcommand = process.argv[2];
+  if (subcommand === "--help" || subcommand === "-h" || subcommand === void 0) {
+    printHelp();
+    return;
+  }
+  if (subcommand === "run") {
+    await runCommand();
+    return;
+  }
+  if (subcommand === "version" || subcommand === "--version" || subcommand === "-v") {
+    console.log(`husk ${VERSION}`);
+    return;
+  }
+  console.error(`Unknown command: ${subcommand}
+Run 'husk --help' for usage.`);
+  process.exit(1);
+}
+async function runCommand() {
+  const { values } = parseArgs({
+    args: process.argv.slice(3),
+    options: {
+      model: { type: "string" },
+      provider: { type: "string" },
+      tools: { type: "string" },
+      memory: { type: "string" },
+      max: { type: "string" },
+      help: { type: "boolean", short: "h" }
+    },
+    allowPositionals: true
+  });
+  if (values.help) {
+    printHelp();
+    return;
+  }
+  const prompt = values.help === void 0 ? process.argv[3] : void 0;
+  if (!prompt) {
+    console.error("Error: husk run requires a prompt argument.");
+    console.error('Usage: husk run "your prompt here"');
+    process.exit(1);
+  }
+  const providerName = values.provider ?? process.env.HUSK_PROVIDER ?? "anthropic";
+  const modelId = values.model ?? process.env.HUSK_MODEL ?? "claude-opus-4-6";
+  const provider = providerName === "openai" ? new OpenAIProvider({ model: modelId }) : new AnthropicProvider({ model: modelId });
+  const toolNames = (values.tools ?? "read,write,edit,bash,grep").split(",").map((s) => s.trim()).filter(Boolean);
+  const tools = toolNames.map((name) => {
+    const t = TOOL_REGISTRY[name];
+    if (!t) {
+      console.error(
+        `Error: unknown tool '${name}'. Available: ${Object.keys(TOOL_REGISTRY).join(", ")}`
+      );
+      process.exit(1);
+    }
+    return t;
+  });
+  const memory = values.memory === "file" ? new FileStore() : new InMemoryStore();
+  const maxIterations = values.max ? Number.parseInt(values.max, 10) : 25;
+  const agent = new Agent({
+    model: provider,
+    ...tools.length > 0 ? { tools } : {},
+    memory,
+    maxIterations
+  });
+  const result = await agent.run(prompt);
+  console.log(result.output);
+  process.exit(0);
+}
+function printHelp() {
+  console.log(`husk \u2014 run an agent from the command line
+
+Usage:
+  husk run "<prompt>" [options]
+
+Options:
+  --model <id>       Model id (default: claude-opus-4-6)
+  --provider <name>  'anthropic' (default) or 'openai'
+  --tools <list>     Comma-separated tool names: read,write,edit,bash,grep
+                     (default: all five)
+  --memory <kind>    'in-memory' (default) or 'file'
+  --max <n>          Max agent iterations (default: 25)
+  -h, --help         Show this help
+  -v, --version      Show version
+
+Environment:
+  ANTHROPIC_API_KEY   Required for Anthropic provider
+  OPENAI_API_KEY      Required for OpenAI provider
+  HUSK_MODEL          Override default model
+  HUSK_PROVIDER       Override default provider
+
+Examples:
+  husk run "What is the capital of France?"
+  husk run "Refactor src/foo.ts" --tools read,edit,write
+  husk run "Summarize README.md" --provider openai --model gpt-5
+`);
+}
+var VERSION = "0.0.1";
+await main();
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map