@wrongstack/tools 0.313.0 → 0.316.1

package/dist/chunk-J5SKD6LN.js

@@ -0,0 +1,235 @@
+import {
+  safeResolveReal
+} from "./chunk-D33S4RQG.js";
+
+// src/tree.ts
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { DEFAULT_WALK_IGNORE_DIRS, compileGlob, expectDefined } from "@wrongstack/core/utils";
+var DEFAULT_IGNORE = /* @__PURE__ */ new Set([
+  ...DEFAULT_WALK_IGNORE_DIRS,
+  ".wrongstack",
+  ".ssh",
+  ".gnupg",
+  ".aws"
+]);
+var DEFAULT_MAX_ENTRIES = 5e3;
+var MAX_TREE_OUTPUT_BYTES = 256 * 1024;
+var treeTool = {
+  name: "tree",
+  category: "Filesystem",
+  description: "Display a project or subpath directory tree. Use it for structural layout; use index-backed `codebase-search` first for code understanding when it is live.",
+  usageHint: "DIRECTORY-LAYOUT EXPLORATION:\n\n- When `codebase-search` is live, use it first for symbols and concepts; use `tree` when the directory hierarchy itself matters.\n- Tune `depth` (default 3) and use `glob`/`exclude` to focus the view.\n- Prefer this over raw `bash find` or `glob` + manual reading when you need a quick structural overview.\nOutput is truncated for very large trees.",
+  permission: "auto",
+  mutating: false,
+  capabilities: ["fs.read"],
+  icon: "tree",
+  maxOutputBytes: 262144,
+  timeoutMs: 15e3,
+  inputSchema: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Root directory to display the tree from (defaults to project root)."
+      },
+      depth: {
+        type: "integer",
+        description: "Maximum directory depth to traverse (default 3, use 0 for unlimited).",
+        minimum: 0,
+        maximum: 20
+      },
+      glob: {
+        type: "string",
+        description: "Only include files matching this glob pattern."
+      },
+      exclude: {
+        type: "array",
+        items: { type: "string" },
+        description: "List of directory names to completely ignore."
+      },
+      show_files: {
+        type: "boolean",
+        description: "Whether to show individual files (default true)."
+      },
+      show_dirs: {
+        type: "boolean",
+        description: "Whether to show directories (default true)."
+      },
+      show_hidden: {
+        type: "boolean",
+        description: "Show hidden files starting with . (default: false)"
+      },
+      max_entries: {
+        type: "integer",
+        description: `Maximum entries retained in the rendered tree (default ${DEFAULT_MAX_ENTRIES}).`,
+        minimum: 1,
+        maximum: 5e4
+      }
+    }
+  },
+  async execute(input, ctx, opts) {
+    let final;
+    const executeStream = treeTool.executeStream;
+    if (!executeStream) throw new Error("treeTool: stream execution unavailable");
+    for await (const ev of executeStream(input, ctx, opts)) {
+      if (ev.type === "final") final = ev.output;
+    }
+    if (!final) throw new Error("tree: stream ended without final event");
+    return final;
+  },
+  async *executeStream(input, ctx, opts) {
+    const basePath = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;
+    const maxDepth = input.depth ?? 3;
+    const showFiles = input.show_files ?? true;
+    const showDirs = input.show_dirs ?? true;
+    const showHidden = input.show_hidden ?? false;
+    const exclude = /* @__PURE__ */ new Set([...DEFAULT_IGNORE, ...input.exclude ?? []]);
+    const globRe = input.glob ? compileGlob(input.glob) : void 0;
+    const maxEntries = input.max_entries ?? DEFAULT_MAX_ENTRIES;
+    const signal = opts?.signal ?? ctx.signal ?? new AbortController().signal;
+    const lines = [basePath];
+    const totals = { totalFiles: { value: 0 }, totalDirs: { value: 0 } };
+    const retention = {
+      entries: 0,
+      outputBytes: Buffer.byteLength(basePath, "utf8"),
+      maxEntries,
+      maxOutputBytes: MAX_TREE_OUTPUT_BYTES,
+      truncated: false
+    };
+    const queue = [];
+    const FLUSH_EVERY = 200;
+    let lastEmittedTotal = 0;
+    const tickProgress = () => {
+      const seen = totals.totalFiles.value + totals.totalDirs.value;
+      if (seen - lastEmittedTotal >= FLUSH_EVERY) {
+        queue.push({
+          type: "metric",
+          text: `${seen} entries`,
+          data: { files: totals.totalFiles.value, dirs: totals.totalDirs.value }
+        });
+        lastEmittedTotal = seen;
+      }
+    };
+    const walkPromise = walkDir(basePath, 0, {
+      maxDepth,
+      exclude,
+      showFiles,
+      showDirs,
+      showHidden,
+      globRe,
+      basePath,
+      lines,
+      prefix: "",
+      isLast: true,
+      totalFiles: totals.totalFiles,
+      totalDirs: totals.totalDirs,
+      onProgress: tickProgress,
+      retention,
+      signal
+    });
+    let walkDone = false;
+    void walkPromise.then(
+      () => {
+        walkDone = true;
+      },
+      () => {
+        walkDone = true;
+      }
+    );
+    while (!walkDone || queue.length > 0) {
+      if (queue.length > 0) {
+        yield expectDefined(queue.shift());
+      } else {
+        let pollTimer;
+        const poll = new Promise((r) => {
+          pollTimer = setTimeout(r, 50);
+        });
+        try {
+          await Promise.race([walkPromise, poll]).catch(() => void 0);
+        } finally {
+          if (pollTimer) clearTimeout(pollTimer);
+        }
+      }
+    }
+    await walkPromise;
+    yield {
+      type: "final",
+      output: {
+        tree: lines.join("\n"),
+        total_files: totals.totalFiles.value,
+        total_dirs: totals.totalDirs.value,
+        truncated: retention.truncated,
+        path: basePath
+      }
+    };
+  }
+};
+function matchesTreeGlob(globRe, fileName, absPath, basePath) {
+  if (globRe.test(fileName)) return true;
+  const rel = path.relative(basePath, absPath);
+  const posixRel = !rel || rel.startsWith("..") || path.isAbsolute(rel) ? absPath.split(path.sep).join("/") : rel.split(path.sep).join("/");
+  return globRe.test(posixRel);
+}
+async function walkDir(dir, depth, opts) {
+  opts.signal.throwIfAborted();
+  if (opts.retention.truncated) return;
+  const entries = await fs.readdir(dir, { withFileTypes: true }).catch(() => []);
+  const filtered = entries.filter((e) => {
+    if (!opts.showHidden && e.name.startsWith(".")) return false;
+    if (opts.exclude.has(e.name)) return false;
+    if (e.isFile() && opts.globRe) {
+      const abs = path.join(dir, e.name);
+      if (!matchesTreeGlob(opts.globRe, e.name, abs, opts.basePath)) return false;
+    }
+    return true;
+  });
+  let dirCount = 0;
+  let fileCount = 0;
+  for (const e of filtered) {
+    if (e.isDirectory()) dirCount++;
+    else if (e.isFile()) fileCount++;
+  }
+  opts.totalDirs.value += dirCount;
+  opts.totalFiles.value += fileCount;
+  opts.onProgress?.();
+  const items = filtered.sort((a, b) => {
+    if (a.isDirectory() && !b.isDirectory()) return -1;
+    if (!a.isDirectory() && b.isDirectory()) return 1;
+    return a.name.localeCompare(b.name);
+  });
+  for (let i = 0; i < items.length; i++) {
+    opts.signal.throwIfAborted();
+    if (opts.retention.truncated) return;
+    const entry = items[i];
+    if (!entry) continue;
+    const isLast = i === items.length - 1;
+    const connector = opts.isLast ? "    " : "\u2502   ";
+    const branch = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
+    const displayName = entry.name + (entry.isDirectory() ? "/" : "");
+    if (!opts.showDirs && entry.isDirectory()) continue;
+    if (!opts.showFiles && entry.isFile()) continue;
+    const line = opts.prefix + branch + displayName;
+    const lineBytes = Buffer.byteLength(line, "utf8") + 1;
+    if (opts.retention.entries >= opts.retention.maxEntries || opts.retention.outputBytes + lineBytes > opts.retention.maxOutputBytes) {
+      opts.retention.truncated = true;
+      return;
+    }
+    opts.lines.push(line);
+    opts.retention.entries++;
+    opts.retention.outputBytes += lineBytes;
+    if (entry.isDirectory() && (opts.maxDepth === 0 || depth < opts.maxDepth)) {
+      const childPrefix = opts.prefix + connector;
+      await walkDir(path.join(dir, entry.name), depth + 1, {
+        ...opts,
+        prefix: childPrefix,
+        isLast
+      });
+    }
+  }
+}
+
+export {
+  treeTool
+};
+//# sourceMappingURL=chunk-J5SKD6LN.js.map