@manix-cli/manix 0.1.2

package/dist/openrouter.js

@@ -0,0 +1,108 @@
+const base = () => process.env.OPENROUTER_BASE_URL || "https://openrouter.ai/api/v1";
+const HEADERS = {
+  "HTTP-Referer": "https://github.com/manindhra/manix",
+  "X-Title": "Manix"
+};
+function authHeaders(apiKey) {
+  return { ...HEADERS, ...apiKey ? { Authorization: `Bearer ${apiKey}` } : {} };
+}
+async function streamChat({ apiKey, model, messages, tools, signal, onText }) {
+  const res = await fetch(`${base()}/chat/completions`, {
+    method: "POST",
+    headers: { ...authHeaders(apiKey), "Content-Type": "application/json" },
+    body: JSON.stringify({
+      model,
+      messages,
+      ...tools?.length ? { tools, tool_choice: "auto" } : {},
+      stream: true,
+      usage: { include: true }
+    }),
+    signal
+  });
+  if (!res.ok) {
+    let detail = "";
+    try {
+      const j = await res.json();
+      detail = j?.error?.message || JSON.stringify(j);
+    } catch {
+    }
+    throw new Error(`OpenRouter ${res.status}: ${detail || res.statusText}`);
+  }
+  const decoder = new TextDecoder();
+  let buf = "";
+  let content = "";
+  let usage = null;
+  let finish = null;
+  const toolCalls = [];
+  for await (const chunk of res.body) {
+    buf += decoder.decode(chunk, { stream: true });
+    let nl;
+    while ((nl = buf.indexOf("\n")) !== -1) {
+      const line = buf.slice(0, nl).trimEnd();
+      buf = buf.slice(nl + 1);
+      if (!line || line.startsWith(":")) continue;
+      if (!line.startsWith("data:")) continue;
+      const data = line.slice(5).trim();
+      if (data === "[DONE]") continue;
+      let json;
+      try {
+        json = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      if (json.error) throw new Error(json.error.message || "OpenRouter stream error");
+      if (json.usage) usage = json.usage;
+      const choice = json.choices?.[0];
+      if (!choice) continue;
+      if (choice.finish_reason) finish = choice.finish_reason;
+      const d = choice.delta || {};
+      if (d.content) {
+        content += d.content;
+        onText?.(d.content);
+      }
+      for (const tc of d.tool_calls || []) {
+        const i = tc.index ?? 0;
+        if (!toolCalls[i]) toolCalls[i] = { id: "", type: "function", function: { name: "", arguments: "" } };
+        if (tc.id) toolCalls[i].id = tc.id;
+        if (tc.function?.name) toolCalls[i].function.name += tc.function.name;
+        if (tc.function?.arguments) toolCalls[i].function.arguments += tc.function.arguments;
+      }
+    }
+  }
+  return { content, toolCalls: toolCalls.filter(Boolean), usage, finish };
+}
+let modelCache = null;
+async function fetchModels(apiKey, force = false) {
+  if (modelCache && !force) return modelCache;
+  const res = await fetch(`${base()}/models`, { headers: authHeaders(apiKey) });
+  if (!res.ok) throw new Error(`OpenRouter /models: ${res.status}`);
+  modelCache = (await res.json()).data ?? [];
+  return modelCache;
+}
+function cachedModels() {
+  return modelCache;
+}
+async function getCredits(apiKey) {
+  try {
+    const res = await fetch(`${base()}/credits`, { headers: authHeaders(apiKey) });
+    if (!res.ok) return null;
+    return (await res.json()).data ?? null;
+  } catch {
+    return null;
+  }
+}
+async function validateKey(apiKey) {
+  try {
+    const res = await fetch(`${base()}/key`, { headers: authHeaders(apiKey) });
+    return res.ok;
+  } catch {
+    return false;
+  }
+}
+export {
+  cachedModels,
+  fetchModels,
+  getCredits,
+  streamChat,
+  validateKey
+};

package/dist/permissions.js

@@ -0,0 +1,19 @@
+class Permissions {
+  constructor({ yolo = false } = {}) {
+    this.yolo = yolo;
+    this.always = /* @__PURE__ */ new Set();
+  }
+  async check(tool, ask) {
+    if (tool.safe || this.yolo || this.always.has(tool.name)) return true;
+    if (!ask) return false;
+    const answer = await ask();
+    if (answer === "always") {
+      this.always.add(tool.name);
+      return true;
+    }
+    return answer === "once";
+  }
+}
+export {
+  Permissions
+};

package/dist/print.js

@@ -0,0 +1,51 @@
+import { Agent } from "./agent.js";
+import { Permissions } from "./permissions.js";
+import { t, GLYPH } from "./theme.js";
+async function runPrint({ config, cwd, prompt, yolo, mcp, skills, contextFiles }) {
+  const permissions = new Permissions({ yolo });
+  let failed = false;
+  const agent = new Agent({
+    config,
+    cwd,
+    permissions,
+    mcp,
+    skills,
+    contextFiles,
+    handlers: {
+      onTextDelta: (d) => process.stdout.write(d),
+      onAssistantDone: (text) => {
+        if (text) process.stdout.write("\n");
+      },
+      onToolStart: ({ display }) => process.stderr.write(t.dim(`${GLYPH.tool} ${display}
+`)),
+      onToolEnd: ({ display, ok, summary }) => {
+        if (!ok) process.stderr.write(t.err(`${GLYPH.error} ${display}: ${summary}
+`));
+      },
+      onInfo: (m) => process.stderr.write(t.dim(`${GLYPH.info} ${m}
+`)),
+      onError: (m) => {
+        failed = true;
+        process.stderr.write(t.err(`${GLYPH.error} ${m}
+`));
+      },
+      requestPermission: async () => {
+        process.stderr.write(
+          t.warn(`${GLYPH.info} action auto-denied \u2014 use --yolo to allow writes/bash in print mode
+`)
+        );
+        return "no";
+      }
+    }
+  });
+  await agent.send(prompt);
+  const s = agent.stats();
+  process.stderr.write(
+    t.dim(`\u2014 ${s.requests} req \xB7 ${s.prompt + s.completion} tok \xB7 $${s.cost.toFixed(4)}
+`)
+  );
+  if (failed) process.exitCode = 1;
+}
+export {
+  runPrint
+};

package/dist/prompts.js

@@ -0,0 +1,47 @@
+import os from "node:os";
+function systemPrompt({ cwd, model, contextFiles = [], skills = [] }) {
+  const parts = [];
+  parts.push(`You are Manix, an expert AI coding agent running in the user's terminal.
+
+Environment:
+- Working directory: ${cwd}
+- Platform: ${process.platform} (${os.release()})
+- Date: ${(/* @__PURE__ */ new Date()).toDateString()}
+- Model: ${model}
+
+You accomplish tasks by calling tools. Rules:
+- Gather context first: use read_file, list_dir, glob_files and grep_search to understand code before changing it. Never guess file contents.
+- Read a file before editing it. Prefer edit_file (exact, unique old_string) over write_file for existing files.
+- Use bash for tests, builds, git and installs. Keep commands non-interactive; explain risky commands before running them.
+- After making changes, verify them (run tests/build) when possible.
+- Paths may be relative to the working directory.
+- Be concise \u2014 output renders in a terminal. Use short markdown, no preamble, no flattery. Reference code as path:line.
+- If the request is ambiguous, ask a clarifying question instead of guessing.`);
+  if (skills.length) {
+    parts.push(
+      `Skills (expert playbooks) are available. When one is clearly relevant to the task, load it with the skill tool BEFORE doing the work:
+` + skills.map((s) => `- ${s.name}: ${s.description}`).join("\n")
+    );
+  }
+  for (const f of contextFiles) {
+    parts.push(`Project context from ${f.path}:
+
+${f.content}`);
+  }
+  return parts.join("\n\n");
+}
+const INIT_PROMPT = `Analyze this repository and create a MANIX.md file that will be given to future Manix sessions as project context.
+
+Explore first: list_dir the root, read README/package/build files, skim key source files. Then write MANIX.md containing:
+1. What this project is (1-2 lines)
+2. Commands: build, test, lint, run (exact commands)
+3. Architecture: key directories/files and how they fit together
+4. Conventions: code style, patterns to follow, things to avoid
+
+Keep it under 60 lines. Create the file with write_file.`;
+const COMPACT_PROMPT = `Summarize this entire conversation so it can replace the full history. Include: the user's goals, decisions made, files created/modified and how, current state, and immediate next steps. Be thorough but compact. Reply with only the summary.`;
+export {
+  COMPACT_PROMPT,
+  INIT_PROMPT,
+  systemPrompt
+};

package/dist/sessions.js

@@ -0,0 +1,80 @@
+import fs from "node:fs";
+import path from "node:path";
+import { MANIX_DIR, ensureDir } from "./config.js";
+const SESSIONS_DIR = path.join(MANIX_DIR, "sessions");
+function createSession(cwd, model) {
+  ensureDir(SESSIONS_DIR);
+  const id = (/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replace(/[:T]/g, "-") + "-" + Math.random().toString(36).slice(2, 6);
+  const file = path.join(SESSIONS_DIR, id + ".jsonl");
+  appendLine(file, { type: "meta", id, cwd, model, created: Date.now() });
+  return { id, file };
+}
+function appendMessage(session, message) {
+  if (!session) return;
+  appendLine(session.file, { type: "message", message });
+}
+function appendLine(file, obj) {
+  fs.appendFileSync(file, JSON.stringify(obj) + "\n");
+}
+function parseSessionFile(file) {
+  let meta = null;
+  const messages = [];
+  let raw;
+  try {
+    raw = fs.readFileSync(file, "utf8");
+  } catch {
+    return null;
+  }
+  for (const line of raw.split("\n")) {
+    if (!line.trim()) continue;
+    let obj;
+    try {
+      obj = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (obj.type === "meta") meta = obj;
+    else if (obj.type === "message") messages.push(obj.message);
+  }
+  if (!meta) return null;
+  return { meta, messages };
+}
+function listSessions(cwd) {
+  let files;
+  try {
+    files = fs.readdirSync(SESSIONS_DIR).filter((f) => f.endsWith(".jsonl"));
+  } catch {
+    return [];
+  }
+  const all = [];
+  for (const f of files) {
+    const file = path.join(SESSIONS_DIR, f);
+    const parsed = parseSessionFile(file);
+    if (!parsed || !parsed.messages.length) continue;
+    const firstUser = parsed.messages.find((m) => m.role === "user");
+    all.push({
+      id: parsed.meta.id,
+      file,
+      cwd: parsed.meta.cwd,
+      created: parsed.meta.created,
+      mtime: fs.statSync(file).mtimeMs,
+      count: parsed.messages.length,
+      title: String(firstUser?.content || "(empty)").split("\n")[0].slice(0, 64)
+    });
+  }
+  all.sort((a, b) => b.mtime - a.mtime);
+  const here = all.filter((s) => s.cwd === cwd);
+  return here.length ? here : all;
+}
+function loadSession(idOrFile) {
+  const file = idOrFile.endsWith(".jsonl") ? idOrFile : path.join(SESSIONS_DIR, idOrFile + ".jsonl");
+  const parsed = parseSessionFile(file);
+  return parsed ? { ...parsed, file } : null;
+}
+export {
+  SESSIONS_DIR,
+  appendMessage,
+  createSession,
+  listSessions,
+  loadSession
+};

package/dist/skills.js

@@ -0,0 +1,70 @@
+import fs from "node:fs";
+import path from "node:path";
+import { MANIX_DIR } from "./config.js";
+function loadSkills(cwd) {
+  const dirs = [path.join(MANIX_DIR, "skills"), path.join(cwd, ".manix", "skills")];
+  const byName = /* @__PURE__ */ new Map();
+  for (const dir of dirs) {
+    let entries;
+    try {
+      entries = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      if (!e.isDirectory()) continue;
+      const file = path.join(dir, e.name, "SKILL.md");
+      let src;
+      try {
+        src = fs.readFileSync(file, "utf8");
+      } catch {
+        continue;
+      }
+      const { meta, body } = parseFrontmatter(src);
+      const name = (meta.name || e.name).toLowerCase().replace(/\s+/g, "-");
+      byName.set(name, {
+        name,
+        description: meta.description || "(no description)",
+        body,
+        dir: path.join(dir, e.name)
+      });
+    }
+  }
+  return [...byName.values()];
+}
+function parseFrontmatter(src) {
+  const m = src.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  if (!m) return { meta: {}, body: src };
+  const meta = {};
+  for (const line of m[1].split("\n")) {
+    const kv = line.match(/^(\w[\w-]*):\s*(.*)$/);
+    if (kv) meta[kv[1]] = kv[2].trim();
+  }
+  return { meta, body: src.slice(m[0].length) };
+}
+function skillTool(skills) {
+  return {
+    name: "skill",
+    safe: true,
+    description: "Load a skill (expert playbook) by name and follow its instructions. Available: " + (skills.map((s) => s.name).join(", ") || "none"),
+    parameters: {
+      type: "object",
+      properties: { name: { type: "string" } },
+      required: ["name"]
+    },
+    describe: (a) => `Skill(${a.name})`,
+    async run(a) {
+      const s = skills.find((x) => x.name === String(a.name).toLowerCase());
+      if (!s) return `No skill named "${a.name}". Available: ${skills.map((x) => x.name).join(", ")}`;
+      return `# Skill: ${s.name}
+(files for this skill live in ${s.dir})
+
+${s.body}`;
+    }
+  };
+}
+export {
+  loadSkills,
+  parseFrontmatter,
+  skillTool
+};

package/dist/slash.js

@@ -0,0 +1,31 @@
+function slashCommands(skills = []) {
+  const base = [
+    { name: "help", desc: "Show commands and shortcuts" },
+    { name: "model", desc: "Switch model \u2014 picker, or /model <id>" },
+    { name: "resume", desc: "Resume a previous session" },
+    { name: "clear", desc: "Start a fresh conversation" },
+    { name: "compact", desc: "Summarize history to free context" },
+    { name: "cost", desc: "Session usage + OpenRouter credits" },
+    { name: "mcp", desc: "MCP server status" },
+    { name: "skills", desc: "List available skills" },
+    { name: "init", desc: "Generate MANIX.md for this project" },
+    { name: "yolo", desc: "Toggle auto-approve for all tools" },
+    { name: "exit", desc: "Quit Manix" }
+  ];
+  const skillCmds = skills.map((s) => ({ name: s.name, desc: `(skill) ${s.description}`, skill: s }));
+  return [...base, ...skillCmds];
+}
+function helpText(commands) {
+  const rows = commands.map((c) => `  /${c.name.padEnd(12)} ${c.desc}`);
+  return [
+    "Commands:",
+    ...rows,
+    "",
+    "Shortcuts: Esc interrupt \xB7 \u2191/\u2193 history \xB7 Tab complete \xB7 Ctrl+C twice to quit",
+    'Flags: manix "task" \xB7 -p print mode \xB7 --model <id> \xB7 --continue \xB7 --resume \xB7 --yolo'
+  ].join("\n");
+}
+export {
+  helpText,
+  slashCommands
+};

package/dist/theme.js

@@ -0,0 +1,84 @@
+import chalk from "chalk";
+import os from "node:os";
+const color = {
+  accent: "#ff9f6b",
+  amber: "#ffd27f",
+  user: "#d7d3cd",
+  dim: "#8a8580",
+  faint: "#5c5854",
+  border: "#4a443f",
+  ok: "#98c379",
+  err: "#e06c75",
+  warn: "#e5c07b",
+  code: "#61afef"
+};
+const t = {
+  accent: chalk.hex(color.accent),
+  amber: chalk.hex(color.amber),
+  user: chalk.hex(color.user),
+  dim: chalk.hex(color.dim),
+  faint: chalk.hex(color.faint),
+  ok: chalk.hex(color.ok),
+  err: chalk.hex(color.err),
+  warn: chalk.hex(color.warn),
+  code: chalk.hex(color.code),
+  bold: chalk.bold
+};
+const LOGO = "\u25B2";
+const WORDMARK = `${LOGO}  M A N I X`;
+const GLYPH = {
+  user: "\u276F",
+  assistant: "\u23FA",
+  tool: "\u25CF",
+  info: "\u25CB",
+  error: "\u2717"
+};
+const SPINNER = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+function hexToRgb(hex) {
+  const n = parseInt(hex.slice(1), 16);
+  return [n >> 16 & 255, n >> 8 & 255, n & 255];
+}
+function lerpColor(hexA, hexB, t2) {
+  const a = hexToRgb(hexA);
+  const b = hexToRgb(hexB);
+  const [r, g, bl] = a.map((av, i) => Math.round(av + (b[i] - av) * t2));
+  return chalk.rgb(r, g, bl);
+}
+function gradient(text) {
+  const chars = [...text];
+  return chars.map((ch, i) => lerpColor(color.accent, color.amber, chars.length > 1 ? i / (chars.length - 1) : 0)(ch)).join("");
+}
+function hr(pad = 0) {
+  return "\u2500".repeat(Math.max(10, (process.stdout.columns || 80) - pad));
+}
+const MASCOT = ["...#...", "..###..", ".#####.", "#######"];
+function shortenPath(p) {
+  const home = os.homedir();
+  return p === home ? "~" : p.startsWith(home + "/") ? "~" + p.slice(home.length) : p;
+}
+const TIPS = [
+  "Tip: /model swaps the model mid-conversation \u2014 try a free one to explore.",
+  "Tip: /init teaches Manix about this repo so it needs less hand-holding.",
+  "Tip: Esc interrupts a running turn \xB7 Ctrl+C twice quits.",
+  "Tip: drop a SKILL.md under .manix/skills/ to teach Manix a new playbook.",
+  "Tip: /resume brings back any previous session in this project.",
+  "Tip: --yolo auto-approves every tool call \u2014 use with care."
+];
+function randomTip() {
+  return TIPS[Math.floor(Math.random() * TIPS.length)];
+}
+export {
+  GLYPH,
+  LOGO,
+  MASCOT,
+  SPINNER,
+  TIPS,
+  WORDMARK,
+  color,
+  gradient,
+  hr,
+  lerpColor,
+  randomTip,
+  shortenPath,
+  t
+};

package/dist/tools/bash.js

@@ -0,0 +1,44 @@
+import { exec } from "node:child_process";
+import { t } from "../theme.js";
+const short = (s, n = 60) => s.length > n ? s.slice(0, n - 1) + "\u2026" : s;
+const bashTool = {
+  name: "bash",
+  safe: false,
+  description: "Run a shell command in the working directory. Non-interactive only. Returns stdout+stderr (truncated).",
+  parameters: {
+    type: "object",
+    properties: {
+      command: { type: "string" },
+      timeout_ms: { type: "integer", description: "Max runtime (default 120000, cap 600000)" }
+    },
+    required: ["command"]
+  },
+  describe: (a) => `Bash(${short(String(a.command || ""))})`,
+  preview: (a) => String(a.command || "").split("\n").slice(0, 8).map((l) => t.warn("$ " + l)),
+  run(a, ctx) {
+    return new Promise((resolve) => {
+      exec(
+        a.command,
+        {
+          cwd: ctx.cwd,
+          timeout: Math.min(a.timeout_ms || 12e4, 6e5),
+          maxBuffer: 10 * 1024 * 1024,
+          env: process.env
+        },
+        (err, stdout, stderr) => {
+          let out = [stdout, stderr].map((s) => String(s).trim()).filter(Boolean).join("\n");
+          if (out.length > 3e4) out = out.slice(0, 15e3) + "\n\u2026 [output truncated] \u2026\n" + out.slice(-1e4);
+          if (err?.killed) return resolve(`Command timed out.
+${out}`);
+          if (err && typeof err.code === "number") return resolve(`Exit code ${err.code}
+${out}`);
+          if (err && !out) return resolve(`Error: ${err.message}`);
+          resolve(out || "(no output)");
+        }
+      );
+    });
+  }
+};
+export {
+  bashTool
+};

package/dist/tools/fs-tools.js

@@ -0,0 +1,119 @@
+import fs from "node:fs";
+import path from "node:path";
+import { t } from "../theme.js";
+const rel = (cwd, p) => path.resolve(cwd, p);
+const short = (s, n = 60) => s.length > n ? s.slice(0, n - 1) + "\u2026" : s;
+const readFileTool = {
+  name: "read_file",
+  safe: true,
+  description: "Read a text file. Returns numbered lines. Use offset (1-based) and limit for large files.",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string", description: "File path (relative to cwd or absolute)" },
+      offset: { type: "integer", description: "1-based line to start from" },
+      limit: { type: "integer", description: "Max lines to return (default/cap 2000)" }
+    },
+    required: ["path"]
+  },
+  describe: (a) => `Read(${a.path})`,
+  async run(a, ctx) {
+    const p = rel(ctx.cwd, a.path);
+    const lines = fs.readFileSync(p, "utf8").split("\n");
+    const off = Math.max(1, a.offset || 1);
+    const lim = Math.min(a.limit || 2e3, 2e3);
+    const slice = lines.slice(off - 1, off - 1 + lim);
+    const body = slice.map((l, i) => `${String(off + i).padStart(5)}\u2192${l.slice(0, 500)}`).join("\n");
+    const more = off - 1 + lim < lines.length ? `
+\u2026 (${lines.length} lines total)` : "";
+    return body + more;
+  }
+};
+const writeFileTool = {
+  name: "write_file",
+  safe: false,
+  description: "Create or overwrite a file with the given content. Creates parent directories.",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string" },
+      content: { type: "string" }
+    },
+    required: ["path", "content"]
+  },
+  describe: (a) => `Write(${a.path})`,
+  preview(a) {
+    const lines = String(a.content ?? "").split("\n");
+    const shown = lines.slice(0, 12).map((l) => t.ok("+ " + short(l, 76)));
+    if (lines.length > 12) shown.push(t.dim(`  \u2026 +${lines.length - 12} more lines`));
+    return shown;
+  },
+  async run(a, ctx) {
+    const p = rel(ctx.cwd, a.path);
+    const existed = fs.existsSync(p);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, a.content);
+    return `${existed ? "Overwrote" : "Created"} ${a.path} (${Buffer.byteLength(a.content)} bytes)`;
+  }
+};
+const editFileTool = {
+  name: "edit_file",
+  safe: false,
+  description: "Replace an exact string in a file. old_string must match exactly and be unique unless replace_all is true. Read the file first.",
+  parameters: {
+    type: "object",
+    properties: {
+      path: { type: "string" },
+      old_string: { type: "string", description: "Exact text to replace (include enough context to be unique)" },
+      new_string: { type: "string" },
+      replace_all: { type: "boolean" }
+    },
+    required: ["path", "old_string", "new_string"]
+  },
+  describe: (a) => `Edit(${a.path})`,
+  preview(a) {
+    const olds = String(a.old_string ?? "").split("\n").slice(0, 8);
+    const news = String(a.new_string ?? "").split("\n").slice(0, 8);
+    return [
+      ...olds.map((l) => t.err("- " + short(l, 76))),
+      ...news.map((l) => t.ok("+ " + short(l, 76)))
+    ];
+  },
+  async run(a, ctx) {
+    const p = rel(ctx.cwd, a.path);
+    const src = fs.readFileSync(p, "utf8");
+    const count = src.split(a.old_string).length - 1;
+    if (count === 0) throw new Error("old_string not found in file \u2014 read the file and retry with exact text");
+    if (count > 1 && !a.replace_all)
+      throw new Error(`old_string matches ${count} times \u2014 add surrounding context or set replace_all`);
+    const next = a.replace_all ? src.split(a.old_string).join(a.new_string) : src.replace(a.old_string, a.new_string);
+    fs.writeFileSync(p, next);
+    return `Edited ${a.path} (${a.replace_all ? count : 1} replacement${count > 1 && a.replace_all ? "s" : ""})`;
+  }
+};
+const listDirTool = {
+  name: "list_dir",
+  safe: true,
+  description: "List directory entries. Directories get a trailing slash.",
+  parameters: {
+    type: "object",
+    properties: { path: { type: "string", description: "Defaults to cwd" } }
+  },
+  describe: (a) => `List(${a.path || "."})`,
+  async run(a, ctx) {
+    const p = rel(ctx.cwd, a.path || ".");
+    const entries = fs.readdirSync(p, { withFileTypes: true });
+    entries.sort((x, y) => y.isDirectory() - x.isDirectory() || x.name.localeCompare(y.name));
+    const rows = entries.slice(0, 200).map((e) => e.isDirectory() ? e.name + "/" : e.name);
+    if (entries.length > 200) rows.push(`\u2026 +${entries.length - 200} more`);
+    return rows.join("\n") || "(empty)";
+  }
+};
+const fsTools = [readFileTool, writeFileTool, editFileTool, listDirTool];
+export {
+  editFileTool,
+  fsTools,
+  listDirTool,
+  readFileTool,
+  writeFileTool
+};

package/dist/tools/index.js

@@ -0,0 +1,20 @@
+import { fsTools } from "./fs-tools.js";
+import { searchTools } from "./search.js";
+import { bashTool } from "./bash.js";
+function builtinTools() {
+  return [...fsTools, ...searchTools, bashTool];
+}
+function toOpenAI(tool) {
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: tool.parameters || { type: "object", properties: {} }
+    }
+  };
+}
+export {
+  builtinTools,
+  toOpenAI
+};