@vincemakes/kiso-tools-node 0.47.1 → 0.47.2

package/dist/corpus.d.ts

@@ -56,6 +56,14 @@ export interface CorpusOptions {
     /** Start the walk here instead of at the root. The DECLARATION is still
      *  read at `workspaceRoot` and paths are still relative to it. */
     walkFrom?: string;
+    /** 0.47.2: stop after VISITING this many files, accepted or not — the
+     *  walk's own budget, beside `maxEntries`, which bounds what it returns.
+     *  A glob that matches little walked the whole tree under it: 11 s from
+     *  a home directory. Default: no cap. */
+    maxVisited?: number;
+    /** 0.47.2: the call's wall-clock deadline (epoch ms); the walk stops
+     *  between entries once it has passed. Default: none. */
+    deadline?: number;
 }
 export interface CorpusWalk {
     /** Workspace-relative, POSIX-separated. */
@@ -68,6 +76,12 @@ export interface CorpusWalk {
     cutByDepth: boolean;
     /** The entry cap was reached. */
     cutByCap: boolean;
+    /** 0.47.2: the walk stopped at `maxVisited` files. */
+    cutByVisits: boolean;
+    /** 0.47.2: the walk stopped at its deadline. */
+    cutByDeadline: boolean;
+    /** The files visited, accepted or not. */
+    visited: number;
 }
 /** One directory's `.gitignore`, and the directory it is relative to. */
 export interface Layer {

package/dist/corpus.js

@@ -135,15 +135,25 @@ export function walkCorpus(opts) {
     const root = opts.workspaceRoot;
     const maxDepth = opts.maxDepth ?? CORPUS_MAX_DEPTH;
     const maxEntries = opts.maxEntries ?? Number.POSITIVE_INFINITY;
+    const maxVisited = opts.maxVisited ?? Number.POSITIVE_INFINITY;
+    const deadline = opts.deadline ?? Number.POSITIVE_INFINITY;
     const rootLayer = readLayer(root);
     /** No declaration, nothing to trust: the pre-corpus rule, unchanged. */
     const declared = rootLayer !== null;
     const files = [];
     let cutByDepth = false;
     let cutByCap = false;
+    let cutByVisits = false;
+    let cutByDeadline = false;
+    let visited = 0;
+    const stopped = () => cutByCap || cutByVisits || cutByDeadline;
     const walk = (dir, depth, layers) => {
-        if (cutByCap)
+        if (stopped())
             return;
+        if (Date.now() > deadline) {
+            cutByDeadline = true;
+            return;
+        }
         let entries;
         try {
             entries = readdirSync(dir, { withFileTypes: true });
@@ -153,7 +163,7 @@ export function walkCorpus(opts) {
         }
         const here = depth === 0 ? layers : layersEntering(dir, layers);
         for (const entry of entries) {
-            if (cutByCap)
+            if (stopped())
                 return;
             const name = entry.name;
             const full = join(dir, name);
@@ -170,6 +180,16 @@ export function walkCorpus(opts) {
                 walk(full, depth + 1, here);
                 continue;
             }
+            if (visited >= maxVisited) {
+                cutByVisits = true;
+                return;
+            }
+            visited += 1;
+            // the clock is read every 256 files, not per file
+            if ((visited & 255) === 0 && Date.now() > deadline) {
+                cutByDeadline = true;
+                return;
+            }
             const rel = relative(root, full).split(sep).join("/");
             if (opts.accept !== undefined && !opts.accept(rel))
                 continue;
@@ -191,7 +211,7 @@ export function walkCorpus(opts) {
         }
     }
     walk(start, 0, startLayers);
-    return { files, cutByDepth, cutByCap };
+    return { files, cutByDepth, cutByCap, cutByVisits, cutByDeadline, visited };
 }
 /** A minimal glob → RegExp, anchored, over workspace-relative POSIX paths.
  *

package/dist/index.js

@@ -31,7 +31,7 @@ import { defineTool } from "@vincemakes/kiso-core";
 import { strippedShellEnv } from "./secret-env.js";
 import { contentRevision, normalizeRevision, postEffectEscape, precondition, publishNewFile, revalidateBeforeRename } from "./wr1.js";
 import { isProtectedPath, protectedIdentity, protectedRefusalText, readUnlessProtected } from "./protected.js";
-import { CORPUS_MAX_DEPTH, globToRegExp, walkCorpus } from "./corpus.js";
+import { CORPUS_MAX_DEPTH, globToRegExp } from "./corpus.js";
 import { describeSearchMiss, regionForSearch } from "./search-miss.js";
 /**
  * TUI2-R1 (C) — THE SHELL PROGRESS SIDECAR.
@@ -546,7 +546,7 @@ export function listDirTool(opts) {
         effects: { precommitSafe: true, concurrency: "shared" },
         promptSnippet: "list_dir — directory entries (the workspace ls)",
         promptGuidelines: ["narrow to a subdirectory when the listing caps at 200 entries"],
-        execute: async ({ path, glob }) => {
+        execute: async ({ path, glob }, ctx) => {
             try {
                 const dir = resolveWithinRoot(opts.workspaceRoot, path ?? ".");
                 // ACI-8: with a pattern this is a recursive search over the
@@ -554,25 +554,57 @@ export function listDirTool(opts) {
                 // cannot drift the way they had.
                 if (glob !== undefined) {
                     const re = globToRegExp(glob);
-                    const walk = walkCorpus({
-                        workspaceRoot: opts.workspaceRoot,
-                        walkFrom: dir,
+                    // 0.47.2 (the owner's trace, 2026-10-08): the walk ran HERE,
+                    // synchronously — a project's name sought from a home directory held the
+                    // main thread for 11.02 s, and no frame, timer or esc reached
+                    // kiso until it returned. It runs on the search worker now
+                    // (CX-1 F4's thread), under `search_text`'s budget: a cap on the
+                    // files it visits, a deadline, and the abort.
+                    const realOrSelf = (p) => {
+                        try {
+                            return realpathSync(p);
+                        }
+                        catch {
+                            return p;
+                        }
+                    };
+                    const deadline = Date.now() + (opts.limits?.searchMaxMs ?? SEARCH_MAX_MS);
+                    const outcome = await runSearchWorker({
+                        kind: "glob",
+                        token: 0,
+                        // both realpath'd: a root and a start resolved differently
+                        // named every file `../../…` under a symlinked workspace
+                        workspaceRoot: realOrSelf(opts.workspaceRoot),
+                        walkFrom: realOrSelf(dir),
+                        source: re.source,
+                        flags: re.flags,
+                        excluded: opts.excludeRoots ?? [],
                         maxEntries: MAX_DIR_ENTRIES,
-                        accept: (rel) => re.test(rel),
-                        isExcluded: (full) => {
-                            const r = relative(opts.workspaceRoot, full).split(sep).join("/");
-                            return (opts.excludeRoots ?? []).some((ex) => r === ex || r.startsWith(`${ex}/`));
-                        },
-                    });
-                    const body = walk.files.length ? cap(walk.files.join("\n")) : `(no match for ${glob})`;
+                        maxVisited: opts.limits?.searchMaxFiles ?? SEARCH_MAX_FILES,
+                        deadline,
+                    }, deadline, ctx.signal);
+                    if (outcome.kind === "aborted")
+                        return { content: "list_dir aborted", isError: true, errorKind: "fatal" };
+                    if (outcome.kind === "error")
+                        return { content: `list_dir failed: ${outcome.message}`, isError: true, errorKind: "fatal" };
+                    const walk = outcome.reply;
+                    if (walk?.error !== undefined)
+                        return { content: `list_dir failed: ${walk.error}`, isError: true, errorKind: "fatal" };
+                    const files = walk?.files ?? [];
+                    const body = files.length ? cap(files.join("\n")) : `(no match for ${glob})`;
                     // TWO truncations, different remedies, and neither claimed
                     // when it did not happen: a walk that silently returns less
-                    // is the defect a note exists to prevent.
+                    // is the defect a note exists to prevent. 0.47.2 adds the
+                    // walk's own two stops, each said as itself.
                     const notes = [];
-                    if (walk.cutByCap)
+                    if (walk?.cutByCap === true)
                         notes.push(`${MAX_DIR_ENTRIES} shown (narrow the pattern for more)`);
-                    if (walk.cutByDepth)
+                    if (walk?.cutByDepth === true)
                         notes.push(`the walk stopped at depth ${CORPUS_MAX_DEPTH} — anything deeper is not listed`);
+                    if (walk?.cutByVisits === true)
+                        notes.push(`the walk stopped after ${walk.visited} files — narrow the path`);
+                    if (outcome.kind === "timeout" || walk?.cutByDeadline === true)
+                        notes.push("the walk stopped — its budget elapsed before it finished (narrow the path or the pattern)");
                     return { content: notes.length ? `${body}\n… ${notes.join("; ")}` : body, isError: false };
                 }
                 // DC-54 — TRUNCATED BEFORE IT BUILDS. It was a `.map` over
@@ -637,6 +669,8 @@ function searchWorkerUrl() {
         return beside;
     return new URL("../dist/search-worker.js", import.meta.url);
 }
+/** One call on the search worker: `search_text`'s walk-and-match, or (0.47.2)
+ *  `list_dir`'s glob walk — the same thread, slots, deadline and abort. */
 async function runSearchWorker(req, deadline, signal) {
     if (signal.aborted)
         return { kind: "aborted" };

package/dist/search-worker.d.ts

@@ -17,6 +17,7 @@
  */
 import { type ProtectedIdentity } from "./protected.js";
 export interface SearchRequest {
+    readonly kind?: "search";
     readonly token: number;
     readonly root: string;
     /** The WORKSPACE root, which is not always the search root: a search under
@@ -57,4 +58,37 @@ export interface SearchReply {
     readonly stoppedAt: number;
     readonly error?: string;
 }
+/** 0.47.2 — `list_dir`'s glob walk, on this thread. It walked on the main
+ *  thread, synchronously: a project's name sought from a home directory held kiso
+ *  for 11 s — no frame, no timer, no esc. The walk is the SAME
+ *  `walkCorpus` it always was; it runs here, under the call's budget. */
+export interface GlobRequest {
+    readonly kind: "glob";
+    readonly token: number;
+    /** Both realpath'd by the caller, for the reason `SearchRequest`'s
+     *  workspace root is: a path made relative between a resolved and an
+     *  unresolved base is `../..` the moment a symlink sits between them. */
+    readonly workspaceRoot: string;
+    readonly walkFrom: string;
+    /** the compiled glob (`globToRegExp`), as source and flags */
+    readonly source: string;
+    readonly flags: string;
+    /** DC-49 exclude roots, workspace-relative */
+    readonly excluded: readonly string[];
+    readonly maxEntries: number;
+    readonly maxVisited: number;
+    readonly deadline: number;
+}
+export interface GlobReply {
+    readonly kind: "glob";
+    readonly token: number;
+    readonly files: string[];
+    readonly cutByDepth: boolean;
+    readonly cutByCap: boolean;
+    readonly cutByVisits: boolean;
+    readonly cutByDeadline: boolean;
+    readonly visited: number;
+    readonly error?: string;
+}
+export declare function runGlob(req: GlobRequest): GlobReply;
 export declare function runSearch(req: SearchRequest): Promise<SearchReply>;

package/dist/search-worker.js

@@ -16,8 +16,8 @@
  * message from a superseded worker is ignored.
  */
 import { open, readdir } from "node:fs/promises";
-import { basename, join, relative } from "node:path";
-import { corpusSkips, layersEntering, readLayer } from "./corpus.js";
+import { basename, join, relative, sep } from "node:path";
+import { corpusSkips, layersEntering, readLayer, walkCorpus } from "./corpus.js";
 import { isMainThread, parentPort } from "node:worker_threads";
 import { diskPath, isProtectedDiskPath } from "./protected.js";
 /** A scanned file is protected by inode (the store itself, under any name
@@ -56,6 +56,22 @@ function excerptAround(line, regex) {
     const end = Math.min(trimmed.length, at + hit + EXCERPT_RADIUS);
     return `${start > 0 ? "…" : ""}${trimmed.slice(start, end)}${end < trimmed.length ? "…" : ""}`;
 }
+export function runGlob(req) {
+    const re = new RegExp(req.source, req.flags);
+    const walk = walkCorpus({
+        workspaceRoot: req.workspaceRoot,
+        walkFrom: req.walkFrom,
+        maxEntries: req.maxEntries,
+        maxVisited: req.maxVisited,
+        deadline: req.deadline,
+        accept: (rel) => re.test(rel),
+        isExcluded: (full) => {
+            const r = relative(req.workspaceRoot, full).split(sep).join("/");
+            return req.excluded.some((ex) => r === ex || r.startsWith(`${ex}/`));
+        },
+    });
+    return { kind: "glob", token: req.token, ...walk };
+}
 export async function runSearch(req) {
     const regex = new RegExp(req.pattern, req.flags);
     const matches = [];
@@ -180,6 +196,15 @@ export async function runSearch(req) {
 }
 if (!isMainThread && parentPort !== null) {
     parentPort.once("message", (req) => {
+        if (req.kind === "glob") {
+            try {
+                parentPort.postMessage(runGlob(req));
+            }
+            catch (err) {
+                parentPort.postMessage({ kind: "glob", token: req.token, files: [], cutByDepth: false, cutByCap: false, cutByVisits: false, cutByDeadline: false, visited: 0, error: err.message });
+            }
+            return;
+        }
         void runSearch(req).then((reply) => parentPort.postMessage(reply), (err) => parentPort.postMessage({ token: req.token, matches: [], totalMatches: 0, filesSeen: 0, skippedFiles: 0, multiLink: 0, unreadableDirs: 0, excludedDirs: 0, stopped: false, stoppedAt: 0, error: err.message }));
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-tools-node",
-	"version": "0.47.1",
+	"version": "0.47.2",
 	"description": "kiso coding tools for Node hosts \u2014 read file, list directory, search text, write/edit file, shell command.",
 	"type": "module",
 	"license": "MIT",
@@ -25,7 +25,7 @@
 		"test": "vitest run"
 	},
 	"dependencies": {
-		"@vincemakes/kiso-core": "0.47.1",
+		"@vincemakes/kiso-core": "0.47.2",
 		"ignore": "^7.0.9"
 	},
 	"devDependencies": {