@wrongstack/tools 0.299.0 → 0.301.0

package/dist/codebase-index/writer-graph-helpers.d.ts

@@ -2,15 +2,28 @@ import type { GraphEdge, GraphNode, SymbolLang } from './schema.js';
 /**
  * Derive a monorepo package name from an absolute file path.
  * Handles both `packages/<name>/...` and `apps/<name>/...` layouts.
+ *
+ * This is the fallback only. The authoritative grouping is computed at index
+ * time from each ecosystem's own manifests and stored on `files.package` —
+ * see {@link createPackageLabeller}. A path-shape guess is all that is left
+ * for a repo with no manifest at all.
  */
 export declare function derivePackage(filePath: string): string | undefined;
-export declare function packageFromImport(moduleName: string): string | undefined;
+/**
+ * Build the `file → package` lookup the graph readers group by.
+ *
+ * `stored` comes from `files.package`, which the indexer filled from `go.mod`,
+ * `Cargo.toml`, `package.json`, `pom.xml` and friends. Files missing a stored
+ * label (indexed by an older run, or outside any manifest) fall back to the
+ * path-shape heuristic and finally to `(root)`.
+ */
+export declare function createPackageLabeller(stored: ReadonlyMap<string, string>): (file: string) => string;
 export declare function buildPackageGraphNodes(fileCounts: Array<{
     file: string;
     n: number;
 }>, files: Array<{
     file: string;
-}>): {
+}>, packageOf: (file: string) => string): {
     pkgNodes: Map<string, GraphNode>;
     fileToPkg: Map<string, string>;
 };
@@ -22,7 +35,7 @@ export type WriterFileGraphSymbolRow = {
     lang: string;
     line: number;
 };
-export declare function buildFileGraphNodeState(pkgSyms: WriterFileGraphSymbolRow[], localFiles: Set<string>): {
+export declare function buildFileGraphNodeState(pkgSyms: WriterFileGraphSymbolRow[], localFiles: Set<string>, packageOf: (file: string) => string): {
     fileNodes: Map<string, GraphNode>;
     symToFile: Map<number, string>;
     fileStats: Map<string, {
@@ -41,8 +54,7 @@ export type WriterSymbolGraphRow = {
     signature: string;
     scope: string;
 };
-export declare function buildSymbolGraphNodes(symById: Map<number, WriterSymbolGraphRow>, relatedIds: Set<number>, fileFilter: string): GraphNode[];
-export declare function resolveRelativeImport(fromFile: string, moduleName: string, indexedFiles: Set<string>): string | undefined;
+export declare function buildSymbolGraphNodes(symById: Map<number, WriterSymbolGraphRow>, relatedIds: Set<number>, fileFilter: string, packageOf: (file: string) => string): GraphNode[];
 export type WeightedEdgeAccumulator = {
     weight: number;
     types: Map<string, number>;

package/dist/codebase-index/writer-ref-mapper.d.ts

@@ -6,6 +6,9 @@ export type WriterRefRow = {
     to_id: number | null;
     call_type: string;
     line: number;
+    lang?: string | null;
+    module?: string | null;
+    to_file?: string | null;
 };
 export declare function mapWriterRefRow(row: WriterRefRow): Ref;
 //# sourceMappingURL=writer-ref-mapper.d.ts.map

package/dist/codebase-index/writer-schema.d.ts

@@ -1,7 +1,19 @@
 export declare const METADATA_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS metadata (\n    key TEXT PRIMARY KEY,\n    value TEXT NOT NULL\n  );\n";
-export declare const CORE_TABLES_SQL = "\n  CREATE TABLE IF NOT EXISTS files (\n    file TEXT PRIMARY KEY,\n    lang TEXT NOT NULL,\n    mtime_ms INTEGER NOT NULL,\n    symbol_count INTEGER NOT NULL DEFAULT 0,\n    last_indexed INTEGER NOT NULL\n  );\n  CREATE TABLE IF NOT EXISTS symbols (\n    id INTEGER PRIMARY KEY,\n    lang TEXT NOT NULL,\n    kind TEXT NOT NULL,\n    name TEXT NOT NULL,\n    file TEXT NOT NULL,\n    line INTEGER NOT NULL,\n    col INTEGER NOT NULL,\n    signature TEXT NOT NULL DEFAULT '',\n    doc_comment TEXT NOT NULL DEFAULT '',\n    scope TEXT NOT NULL DEFAULT '',\n    text TEXT NOT NULL DEFAULT '',\n    file_fk TEXT NOT NULL\n  );\n";
+export declare const CORE_TABLES_SQL = "\n  CREATE TABLE IF NOT EXISTS files (\n    file TEXT PRIMARY KEY,\n    lang TEXT NOT NULL,\n    mtime_ms INTEGER NOT NULL,\n    symbol_count INTEGER NOT NULL DEFAULT 0,\n    last_indexed INTEGER NOT NULL,\n    -- Code Atlas grouping label, computed at index time from the ecosystem's\n    -- own manifests (package.json, go.mod, Cargo.toml, \u2026). Stored rather than\n    -- re-derived per query because the evidence lives on disk, not in the DB.\n    package TEXT NOT NULL DEFAULT ''\n  );\n  CREATE TABLE IF NOT EXISTS symbols (\n    id INTEGER PRIMARY KEY,\n    lang TEXT NOT NULL,\n    kind TEXT NOT NULL,\n    name TEXT NOT NULL,\n    file TEXT NOT NULL,\n    line INTEGER NOT NULL,\n    col INTEGER NOT NULL,\n    signature TEXT NOT NULL DEFAULT '',\n    doc_comment TEXT NOT NULL DEFAULT '',\n    scope TEXT NOT NULL DEFAULT '',\n    text TEXT NOT NULL DEFAULT '',\n    file_fk TEXT NOT NULL\n  );\n";
+export declare const FILE_INDEX_SQL: readonly ['CREATE INDEX IF NOT EXISTS idx_f_package ON files(package)'];
 export declare const SYMBOL_INDEX_SQL: readonly ['CREATE INDEX IF NOT EXISTS idx_s_name ON symbols(name)', 'CREATE INDEX IF NOT EXISTS idx_s_kind ON symbols(kind)', 'CREATE INDEX IF NOT EXISTS idx_s_lang ON symbols(lang)', 'CREATE INDEX IF NOT EXISTS idx_s_file ON symbols(file)', 'CREATE INDEX IF NOT EXISTS idx_s_lang_kind ON symbols(lang, kind)', 'CREATE INDEX IF NOT EXISTS idx_s_file_fk ON symbols(file_fk)', 'CREATE INDEX IF NOT EXISTS idx_s_name_id ON symbols(name, id)'];
-export declare const REFS_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS refs (\n    id INTEGER PRIMARY KEY,\n    from_id INTEGER NOT NULL,\n    to_name TEXT NOT NULL,\n    to_id INTEGER,\n    call_type TEXT NOT NULL,\n    line INTEGER NOT NULL\n  );\n";
-export declare const REFS_INDEX_SQL: readonly ['CREATE INDEX IF NOT EXISTS idx_r_from ON refs(from_id)', 'CREATE INDEX IF NOT EXISTS idx_r_to_id ON refs(to_id)', 'CREATE INDEX IF NOT EXISTS idx_r_to_name ON refs(to_name)', 'CREATE INDEX IF NOT EXISTS idx_r_call_type ON refs(call_type)'];
+export declare const REFS_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS refs (\n    id INTEGER PRIMARY KEY,\n    from_id INTEGER NOT NULL,\n    to_name TEXT NOT NULL,\n    to_id INTEGER,\n    call_type TEXT NOT NULL,\n    line INTEGER NOT NULL,\n    lang TEXT NOT NULL DEFAULT '',\n    module TEXT,\n    to_file TEXT\n  );\n";
+export declare const REFS_INDEX_SQL: readonly ['CREATE INDEX IF NOT EXISTS idx_r_from ON refs(from_id)', 'CREATE INDEX IF NOT EXISTS idx_r_to_id ON refs(to_id)', 'CREATE INDEX IF NOT EXISTS idx_r_to_name ON refs(to_name)', 'CREATE INDEX IF NOT EXISTS idx_r_call_type ON refs(call_type)', 'CREATE INDEX IF NOT EXISTS idx_r_to_name_lang ON refs(to_name, lang)', 'CREATE INDEX IF NOT EXISTS idx_r_module ON refs(module)', 'CREATE INDEX IF NOT EXISTS idx_r_to_file ON refs(to_file)'];
+/**
+ * Static `lang → family` mirror of {@link LANG_FAMILY_ENTRIES}, so ref
+ * resolution can scope a match to one language family with a join rather than
+ * binding a per-family IN-list into every statement.
+ *
+ * Row `('', '*')` is the wildcard for refs written without a language (older
+ * rows, and tests that construct refs by hand): they keep resolving globally.
+ */
+export declare const LANG_FAMILY_TABLE_SQL = "\n  CREATE TABLE IF NOT EXISTS lang_family (\n    lang TEXT PRIMARY KEY,\n    family TEXT NOT NULL\n  );\n";
+/** Family value that matches every symbol family, used by language-less refs. */
+export declare const LANG_FAMILY_WILDCARD = "*";
 export declare const SYMBOLS_FTS_SQL = "CREATE VIRTUAL TABLE IF NOT EXISTS symbols_fts USING fts5(text, tokenize = 'unicode61')";
 //# sourceMappingURL=writer-schema.d.ts.map

package/dist/codebase-index/writer.d.ts

@@ -56,10 +56,44 @@ export declare class IndexStore {
         indexDir?: string | undefined;
     });
     runWithRetry<T>(fn: () => T): T;
+    /**
+     * Mirror the in-process language→family map into SQLite.
+     *
+     * Rewritten on every open rather than only on schema bumps: the mapping is
+     * static lookup data, so a code-side change (a new language, a language
+     * moving families) must take effect without forcing a full reindex.
+     */
+    private seedLangFamilies;
+    /**
+     * Add any column the current schema expects but the on-disk table lacks.
+     *
+     * `CREATE TABLE IF NOT EXISTS` silently keeps an existing table's old shape,
+     * and the version check above only rebuilds on a version *mismatch*. That
+     * leaves a real gap: several wstack processes share this database, and while
+     * a version upgrade is rolling out one of them may still be running the
+     * previous build. That older process sees the newer version number, drops the
+     * tables, and recreates them from *its* DDL — without the newer columns —
+     * while the metadata row still reads the new version. Every later query for
+     * one of those columns then fails with `no such column`, and no amount of
+     * reindexing fixes it, because the version numbers already agree.
+     *
+     * Repairing column-by-column makes the schema self-healing from any of those
+     * states. Table and column names are compile-time literals from this module,
+     * never user input.
+     */
+    private repairMissingColumns;
     private initSchema;
     private static readonly NEXT_SYMBOL_ID_KEY;
     /** Stay under typical SQLite SQLITE_MAX_VARIABLE_NUMBER (often 999). */
     private static readonly MAX_SQL_VARS;
+    /**
+     * Correlated predicate: the ref in `refs` and the candidate symbol aliased
+     * `sym` belong to the same language family — or the ref carries no language,
+     * in which case the wildcard bind matches everything.
+     *
+     * Each textual occurrence consumes one `?` bind of {@link LANG_FAMILY_WILDCARD}.
+     */
+    private static readonly FAMILY_MATCH_SQL;
     /**
      * Ensure `metadata.next_symbol_id` exists. Safe to call outside a write
      * transaction on open; the first concurrent writer under BEGIN IMMEDIATE
@@ -101,6 +135,42 @@ export declare class IndexStore {
     upsertFile(meta: FileMeta): void;
     getFileMeta(file: string): FileMeta | null;
     getAllFileMetas(): FileMeta[];
+    /** Store the Code Atlas grouping label for each indexed file. */
+    setFilePackages(entries: ReadonlyMap<string, string>): void;
+    /**
+     * Every indexed `namespace`/`module` declaration, for ecosystems whose import
+     * specifiers name a namespace rather than a path (C#, PHP, Elixir, Haskell).
+     * Ordered so the resolver's choice among duplicate declarations is stable.
+     */
+    getNamespaceDeclarations(): Array<{
+        name: string;
+        file: string;
+    }>;
+    /** `file → package` for every indexed file that has a label. */
+    getFilePackages(): Map<string, string>;
+    /**
+     * Distinct `(fromFile, lang, module)` triples needing module resolution.
+     *
+     * Distinct rather than per-ref because resolution depends only on these three
+     * values: a file importing the same module twenty times resolves it once.
+     */
+    getUnresolvedImports(onlyFiles?: readonly string[]): Array<{
+        fromFile: string;
+        lang: string;
+        module: string;
+    }>;
+    /**
+     * Write resolved import targets back onto `refs.to_file`.
+     *
+     * Applied through a temp table and a single UPDATE: one statement per
+     * resolution would mean thousands of round-trips on a first index.
+     */
+    applyImportResolutions(resolutions: ReadonlyArray<{
+        fromFile: string;
+        lang: string;
+        module: string;
+        toFile: string;
+    }>): number;
     search(query: string, filter?: WriterSearchFilter, opts?: {
         limit?: number | undefined;
     }): SearchResult[];
@@ -228,9 +298,12 @@ export declare class IndexStore {
      * Resolve `to_name` → `to_id` for all refs that have a name but no id.
      * Call this after all symbols have been inserted to fill in cross-references.
      *
-     * Single statement: the `to_name IN (SELECT name FROM symbols)` guard restricts
-     * the UPDATE to refs that will actually resolve, so `.changes` counts only refs
-     * that found a target — matching the previous per-row loop's return value.
+     * A match additionally requires the referencing ref and the target symbol to
+     * be in the same {@link LangFamily}. Without that guard a name match is a
+     * cross-language accident waiting to happen — `main`, `New`, `Parse` and
+     * `Config` are declared in most languages at once, and each collision draws a
+     * Code Atlas edge between files that never reference each other. Refs stored
+     * without a language keep the old global behaviour via the `'*'` wildcard row.
      */
     resolveRefs(): number;
     resolveRefsForNames(names: Iterable<string>): number;

package/dist/exec.js

@@ -1131,7 +1131,7 @@ var ProcessRegistryImpl = class {
     const p = this.processes.get(pid);
     if (!p) return false;
     if (p.killed) return true;
-    if (p.protected) return false;
+    if (p.protected && opts.includeProtected !== true) return false;
     if (opts.preserveBackground && p.background) return false;
     const { force = false, graceMs = DEFAULT_GRACE_MS } = opts;
     const isWin3 = os.platform() === "win32";
@@ -1182,9 +1182,13 @@ var ProcessRegistryImpl = class {
   killAll(opts = {}) {
     const pids = Array.from(this.processes.keys());
     const killed = [];
+    const includeProtected = opts.includeProtected === true;
     for (const pid of pids) {
       const p = this.processes.get(pid);
-      if (p && !p.protected && this.kill(pid, opts)) killed.push(pid);
+      if (!p) continue;
+      if (p.protected && !includeProtected) continue;
+      if (opts.preserveBackground && p.background) continue;
+      if (this.kill(pid, opts)) killed.push(pid);
     }
     return killed;
   }
@@ -2642,6 +2646,26 @@ var BLOCKED_ARG_PATTERNS = {
   pnpm: [],
   npx: []
 };
+var BLOCKED_OPTION_NAMES = {
+  git: /* @__PURE__ */ new Set([
+    "--exec",
+    "--upload-pack",
+    "--receive-pack",
+    "--exec-path",
+    "--git-dir",
+    "--work-tree",
+    "--namespace",
+    "-c",
+    "--config",
+    "--config-env",
+    "-C"
+  ]),
+  find: /* @__PURE__ */ new Set(["-exec", "-ok", "-execdir"])
+};
+function optionName(arg) {
+  const eq = arg.indexOf("=");
+  return eq > 0 ? arg.slice(0, eq) : arg;
+}
 var BLOCKED_SUBCOMMANDS = {
   docker: /* @__PURE__ */ new Set(["push"]),
   podman: /* @__PURE__ */ new Set(["push"]),
@@ -2679,6 +2703,15 @@ function validateArgs(cmd, args) {
     const blocked2 = blockedSequences.find((seq) => seq.every((part, idx) => actual[idx] === part));
     if (blocked2) return `Blocked subcommand "${blocked2.join(" ")}" for command "${cmd}"`;
   }
+  const blockedOptions = BLOCKED_OPTION_NAMES[cmd];
+  if (blockedOptions) {
+    for (const arg of args) {
+      if (arg === "--") break;
+      if (blockedOptions.has(optionName(arg))) {
+        return `Blocked option "${optionName(arg)}" for command "${cmd}"`;
+      }
+    }
+  }
   const blocked = BLOCKED_ARG_PATTERNS[cmd];
   if (!blocked) return null;
   for (const arg of args) {

package/dist/format.js

@@ -666,7 +666,7 @@ var ProcessRegistryImpl = class {
     const p = this.processes.get(pid);
     if (!p) return false;
     if (p.killed) return true;
-    if (p.protected) return false;
+    if (p.protected && opts.includeProtected !== true) return false;
     if (opts.preserveBackground && p.background) return false;
     const { force = false, graceMs = DEFAULT_GRACE_MS } = opts;
     const isWin2 = os.platform() === "win32";
@@ -717,9 +717,13 @@ var ProcessRegistryImpl = class {
   killAll(opts = {}) {
     const pids = Array.from(this.processes.keys());
     const killed = [];
+    const includeProtected = opts.includeProtected === true;
     for (const pid of pids) {
       const p = this.processes.get(pid);
-      if (p && !p.protected && this.kill(pid, opts)) killed.push(pid);
+      if (!p) continue;
+      if (p.protected && !includeProtected) continue;
+      if (opts.preserveBackground && p.background) continue;
+      if (this.kill(pid, opts)) killed.push(pid);
     }
     return killed;
   }

package/dist/git.js

@@ -291,11 +291,8 @@ function buildArgs(input) {
         ...input.branch.startsWith("-") || input.branch.includes(" --") ? [] : [input.branch]
       ] : ["branch"];
     case "checkout":
-      return [
-        "checkout",
-        ...input.branch ? ["--", input.branch] : [],
-        ...files.length ? ["--", ...files] : []
-      ];
+      if (files.length) return ["checkout", "--", ...files];
+      return input.branch ? ["checkout", input.branch, "--"] : ["checkout"];
     case "stash":
       return input.message ? ["stash", "push", "-m", input.message] : ["stash", "push"];
     case "push":

package/dist/glob.js

@@ -138,7 +138,7 @@ async function safeResolveReal(input, ctx) {
 }
 
 // src/glob.ts
-var DEFAULT_IGNORE = DEFAULT_WALK_IGNORE_DIRS;
+var DEFAULT_IGNORE = new Set(DEFAULT_WALK_IGNORE_DIRS);
 var WALK_CONCURRENCY = 16;
 var globTool = {
   name: "glob",
@@ -217,7 +217,7 @@ var globTool = {
       const matchedFiles = [];
       for (const e of entries) {
         const name = e.name;
-        if (DEFAULT_IGNORE.includes(name)) continue;
+        if (DEFAULT_IGNORE.has(name)) continue;
         const rel = relPrefix ? `${relPrefix}/${name}` : name;
         const full = path3.join(dir, name);
         if (e.isDirectory()) {

package/dist/grep.js

@@ -40,6 +40,81 @@ var DANGEROUS_PATTERNS = [
   // Greedy quantifier inside lookahead/lookbehind — (?!.*a+)
   /[([][^)\]]*[+*][^)\]]*[)\]][^)]*\?\??/
 ];
+function hasAmbiguousQuantifiedAlternation(pattern) {
+  for (let i = 0; i < pattern.length; i++) {
+    if (pattern[i] !== "(") continue;
+    if (i > 0 && pattern[i - 1] === "\\") continue;
+    let depth = 0;
+    let inClass = false;
+    let j = i;
+    for (; j < pattern.length; j++) {
+      const ch = pattern[j];
+      if (ch === "\\") {
+        j++;
+        continue;
+      }
+      if (inClass) {
+        if (ch === "]") inClass = false;
+        continue;
+      }
+      if (ch === "[") {
+        inClass = true;
+        continue;
+      }
+      if (ch === "(") depth++;
+      else if (ch === ")") {
+        depth--;
+        if (depth === 0) break;
+      }
+    }
+    if (j >= pattern.length) return false;
+    const next = pattern[j + 1];
+    if (next !== "+" && next !== "*" && next !== "{") continue;
+    let inner = pattern.slice(i + 1, j);
+    inner = inner.replace(/^\?(?::|<?[=!])/u, "");
+    const branches = [];
+    let current = "";
+    let d = 0;
+    let cls = false;
+    for (let k = 0; k < inner.length; k++) {
+      const ch = inner[k];
+      if (ch === "\\") {
+        current += ch + (inner[k + 1] ?? "");
+        k++;
+        continue;
+      }
+      if (cls) {
+        if (ch === "]") cls = false;
+        current += ch;
+        continue;
+      }
+      if (ch === "[") {
+        cls = true;
+        current += ch;
+        continue;
+      }
+      if (ch === "(") d++;
+      if (ch === ")") d--;
+      if (ch === "|" && d === 0) {
+        branches.push(current);
+        current = "";
+        continue;
+      }
+      current += ch;
+    }
+    branches.push(current);
+    if (branches.length < 2) continue;
+    for (let a = 0; a < branches.length; a++) {
+      for (let b = a + 1; b < branches.length; b++) {
+        const x = branches[a];
+        const y = branches[b];
+        if (x === "" || y === "") return true;
+        if (x === y || x.startsWith(y) || y.startsWith(x)) return true;
+      }
+    }
+  }
+  return false;
+}
 function compileUserRegex(pattern, flags) {
   if (typeof pattern !== "string") {
     return { ok: false, reason: "pattern must be a string" };
@@ -58,6 +133,12 @@ function compileUserRegex(pattern, flags) {
       };
     }
   }
+  if (hasAmbiguousQuantifiedAlternation(pattern)) {
+    return {
+      ok: false,
+      reason: "pattern quantifies an alternation with overlapping branches \u2014 rewrite so no two branches can match the same text"
+    };
+  }
   try {
     return { ok: true, regex: new RegExp(pattern, flags) };
   } catch (err) {
@@ -73,6 +154,7 @@ function capSubject(line) {
 }
 
 // src/_util.ts
+import * as fsp from "node:fs/promises";
 import * as path from "node:path";
 import * as Core from "@wrongstack/core/utils";
 function resolvePath(input, ctx) {
@@ -96,6 +178,39 @@ function ensureInsideRoot(absPath, ctx) {
 function safeResolve(input, ctx) {
   return ensureInsideRoot(resolvePath(input, ctx), ctx);
 }
+async function resolveRealInsideRoot(absPath, ctx) {
+  if (ctx.allowOutsideProjectRoot) return absPath;
+  const realRoots = await Promise.all(
+    allowedRoots(ctx).map((r) => fsp.realpath(r).catch(() => path.resolve(r)))
+  );
+  let probe = absPath;
+  const pendingTail = [];
+  for (; ; ) {
+    let real;
+    try {
+      real = await fsp.realpath(probe);
+    } catch (err) {
+      if (err.code === "ENOENT") {
+        const parent = path.dirname(probe);
+        if (parent === probe) return absPath;
+        pendingTail.unshift(path.basename(probe));
+        probe = parent;
+        continue;
+      }
+      throw err;
+    }
+    if (isInsideAny(real, realRoots)) {
+      return pendingTail.length > 0 ? path.join(real, ...pendingTail) : real;
+    }
+    throw new Error(
+      `Path "${absPath}" resolves through a symlink outside project root "${realRoots[0]}"`
+    );
+  }
+}
+async function safeResolveReal(input, ctx) {
+  const abs = safeResolve(input, ctx);
+  return await resolveRealInsideRoot(abs, ctx);
+}
 function isBinaryBuffer(buf) {
   const len = Math.min(buf.length, 8192);
   for (let i = 0; i < len; i++) {
@@ -160,7 +275,7 @@ async function loadGitignoreMatcher(projectRoot) {
 }
 
 // src/grep.ts
-var DEFAULT_IGNORE = DEFAULT_WALK_IGNORE_DIRS;
+var DEFAULT_IGNORE = new Set(DEFAULT_WALK_IGNORE_DIRS);
 var NATIVE_SCAN_CONCURRENCY = 32;
 var NATIVE_READ_CHUNK_BYTES = 64 * 1024;
 var NATIVE_MAX_FILE_BYTES = 1e6;
@@ -233,7 +348,7 @@ var grepTool = {
         field: "pattern"
       });
     }
-    const base = input.path ? safeResolve(input.path, ctx) : ctx.cwd;
+    const base = input.path ? await safeResolveReal(input.path, ctx) : ctx.cwd;
     const mode = input.output_mode ?? "content";
     const limit = Math.max(1, Math.min(input.limit ?? 200, 2e3));
     const validation = compileUserRegex(input.pattern, input.case_insensitive ? "i" : "");
@@ -558,7 +673,7 @@ async function runNative(input, base, mode, limit, signal) {
     const subdirs = [];
     for (const e of entries) {
       if (stopped) return;
-      if (DEFAULT_IGNORE.includes(e.name)) continue;
+      if (DEFAULT_IGNORE.has(e.name)) continue;
       if (e.isSymbolicLink()) continue;
       const rel = relPrefix ? `${relPrefix}/${e.name}` : e.name;
       const full = path3.join(dir, e.name);

package/dist/index.d.ts

@@ -30,6 +30,7 @@ export { lintTool } from './lint.js';
 export { logsTool } from './logs.js';
 export { forgetTool, relatedMemoryTool, rememberTool, searchMemoryTool } from './memory.js';
 export { createModeTool } from './mode.js';
+export { nextStepsTool } from './next-steps-tool.js';
 export { outdatedTool } from './outdated.js';
 export { builtinToolsPack } from './pack.js';
 export { patchTool } from './patch.js';