@evandu/super-pi 0.1.111 → 0.1.113

package/dist/server/file-name-index.d.ts

@@ -0,0 +1,144 @@
+/**
+ * THE INDEX FOR ONE WORKSPACE, created on demand and then kept.
+ *
+ * Both layers that need it - the HTTP route that answers a search and the run service that records
+ * the agent's writes - go through this one function, so there is exactly one index per workspace and
+ * the two never drift into answering from different maps.
+ */
+export declare function ensureNameIndex(indexes: Map<string, FileNameIndex>, workspaceId: string, root: string): FileNameIndex;
+/** What the index knows about one path. Deliberately small: no size, no etag, no mtime. */
+export type NameEntry = {
+    /** Workspace-relative, `/`-separated. */
+    path: string;
+    /** The last segment. */
+    name: string;
+    /** The directory holding it, `""` for the root itself. */
+    directory: string;
+    kind: "file" | "directory";
+};
+/** What the index knows about its own state, for the "正在建立索引… 42%" line. */
+export type IndexProgress = {
+    scanned: number;
+    percent: number;
+};
+/** The answer to one question: which paths contain this needle. */
+export type NameSearchResult = {
+    hits: NameEntry[];
+    /** The exact number of matches. Equal to `hits.length` when nothing was withheld. */
+    total: number;
+    /** Whether the index has finished its first pass. `false` means "more may still arrive". */
+    indexed: boolean;
+    progress: IndexProgress;
+    /** Set when the scan hit a limit. Its presence is the reason the answer is not the whole tree. */
+    incomplete: boolean;
+};
+/**
+ * The result ordering, and why it is not the path dictionary order.
+ *
+ * A dictionary order puts `zzz-notes.md` before `notes.md`, because "zzz" sorts after "notes" as
+ * a whole string. In a list of two hundred that is actively hostile: the file whose name STARTS
+ * with what you typed is the one you meant, and it is somewhere in the middle. So the order is:
+ *
+ *   1. the hit position inside the file name - a name that starts with the needle beats one that
+ *      merely contains it, whatever the directory;
+ *   2. shallower directories first - `notes.md` beats `src/deep/nested/notes.md`;
+ *   3. the path dictionary order, as the final tie-break, so the order is stable.
+ */
+export declare function compareNameHits(a: NameEntry, b: NameEntry, needle: string): number;
+/**
+ * A per-workspace index of every path in the tree, built in the background.
+ *
+ * THE LIFECYCLE. `start()` kicks off one background scan and returns immediately - the first
+ * screen must never wait for an index. `search()` works at any point in that scan and answers with
+ * what is known so far, together with `indexed: false` so the caller can say "正在建立索引"
+ * rather than pretending the answer is complete.
+ *
+ * THE INCREMENTAL PATH. `upsert()` and `remove()` are how the index stays true once it exists.
+ * The agent writes files through the run service and the user saves through the files API, and
+ * BOTH of those places already know the path - so keeping the index true costs no extra I/O at
+ * all, it is one map write.
+ */
+export declare class FileNameIndex {
+    readonly workspaceId: string;
+    readonly entries: Map<string, NameEntry>;
+    private root;
+    private building;
+    private started;
+    private scanned;
+    private stopped;
+    private incomplete;
+    constructor(workspaceId: string);
+    /**
+     * Whether the first pass has FINISHED.
+     *
+     * "Finished" is not "found something": an EMPTY directory finishes the scan with zero entries, and
+     * that directory is exactly the case where the answer "no matches" is TRUE rather than premature.
+     * A readiness test that asked "are there any entries yet" would leave an empty workspace stuck on
+     * "building" forever.
+     *
+     * A scan that FAILED has not finished either - it never will be, and `failure` says why.
+     */
+    get indexed(): boolean;
+    get progress(): IndexProgress;
+    /** Begin the background scan. Safe to call more than once; the second call is a no-op. */
+    start(root: string): void;
+    /**
+     * WHY THE SCAN'S FAILURE IS RECORDED RATHER THAN THROWN.
+     *
+     * The first version rethrew a missing root so the failure could not be swallowed - and that crashed
+     * the server, because a background scan has no caller to receive its rejection and Node's default
+     * for an unhandled rejection is to terminate the process. The whole test server went down, and the
+     * symptom ("fetch failed") pointed at the network rather than at a promise.
+     *
+     * So the failure is RECORDED (`this.failure`) and the route asks about it (`throwIfBroken`). The
+     * answer is still the 404 the route owes, but it is now delivered by the request rather than by an
+     * exception nobody is listening for.
+     */
+    private failure;
+    /** The error that stopped the scan, if the root itself could not be read. */
+    get broken(): unknown;
+    /** Rethrow the scan's failure, so the route can turn it into the status it deserves. */
+    throwIfBroken(): void;
+    /** Rebuild from scratch. The ↻ button. */
+    reset(root: string): void;
+    /** Record a path that appeared or changed. Used for agent writes and user saves. */
+    upsert(relativePath: string, kind?: "file" | "directory"): void;
+    /** Forget a path that is gone. */
+    remove(relativePath: string): void;
+    /**
+     * The query. A substring filter over an in-memory map - no filesystem access at all.
+     *
+     * The needle is matched against the FILE NAME only. Matching the path as well would be a
+     * different feature ("find everything under src/server"), and mixing the two makes a search for
+     * `app` return every file in `application/` as well - a result set nobody can read.
+     */
+    search(needle: string): NameSearchResult;
+    /**
+     * Wait until the first scan has finished, or until the deadline passes.
+     *
+     * WHY THIS EXISTS, and it is the difference between a search that works and one that does not.
+     *
+     * The panel fetches the index the moment a workspace opens, so the background scan is normally
+     * already running (or finished) by the time anybody types. But "normally" is not "always": a person
+     * who opens the panel and types immediately would otherwise get an answer computed from a
+     * half-built map - and an answer of "no matches" from a half-built map is a LIE. It is exactly the
+     * complaint this work exists to fix: "搜不出他想搜的东西".
+     *
+     * So the search WAITS for the scan, up to a deadline. The deadline is what keeps this from being a
+     * hang: past it, the search answers with what it knows and says so (`indexed: false`), which is a
+     * statement about the state rather than a claim about the tree.
+     */
+    waitUntilIndexed(timeoutMs: number): Promise<boolean>;
+    /**
+     * The background scan.
+     *
+     * `readdir` only, with `withFileTypes` so the kind of every entry arrives without a `stat`.
+     * Symlinks are recorded but never followed - following one is how a scan becomes an infinite
+     * walk, and a link inside the workspace is the one path the tree refuses to descend as well.
+     */
+    private scan;
+    /** Stop a running scan. Used when a workspace goes away. */
+    stop(): void;
+}
+/** The workspace-relative path of an absolute one, for callers holding an absolute path. */
+export declare function relativeTo(root: string, absolute: string): string;

package/dist/server/file-name-index.js

@@ -0,0 +1,324 @@
+/**
+ * THE NAME INDEX. Every file in the workspace, indexed once, queried in memory.
+ *
+ * WHY THIS FILE EXISTS AT ALL, because there is already a `file-index.ts` and the obvious move is
+ * to extend it. That move is wrong, and the reason is that the two indexes have OPPOSITE scopes:
+ *
+ * - `FileIndex` (the content-search one) deliberately SKIPS dependency directories. A grep through
+ *   `node_modules` is slow and returns nothing a person asked for. Measured on this repository:
+ *   15388 files of which 13949 are `node_modules`, while the project's own `src/` has 75.
+ * - THIS index deliberately SKIPS NOTHING. A person typing `config` into a filename box wants
+ *   `node_modules/some-pkg/config.js` to be findable, and the old behaviour made it unfindable
+ *   while announcing the omission in the UI as a dashed "已跳过 N 个目录" note.
+ *
+ * Those are not two settings of one thing. They are two different questions ("where is this
+ * symbol used" vs "what is this file called"), and one index cannot answer both.
+ *
+ * WHY AN INDEX AND NOT A FRESH WALK PER KEYSTROKE. The old path re-walked the whole tree on every
+ * keystroke (`files.ts` `searchByName`), which cost the user a full scan per character typed. The
+ * cost of building this index ONCE is 960ms of `readdir` on this repository (measured: 3257
+ * directories, 28289 files, no `stat`), and the cost of a query afterwards is a substring filter
+ * over an in-memory map - about 3ms for 30000 entries. So the pressure moves from the user's
+ * keystrokes to the server's background, which is where it belongs.
+ *
+ * WHY THE SCAN HAS NO `stat`. The measurements are unambiguous: `readdir` over the whole tree is
+ * 960ms and `stat` over every directory is 166ms, but a per-FILE `stat` is what costs seconds
+ * (the documented 2-3s figure). This index does not need file sizes or etags - it needs NAMES -
+ * so it never stats a file. `readdir` with `withFileTypes` gives the kind for free.
+ *
+ * THE LIMITS ARE HONEST AND LOOSE. 20000 directories and 200000 files are three to four orders of
+ * magnitude above a real repository, and hitting one is reported (`complete: false`) rather than
+ * silently applied - a search that quietly stopped at a limit is the exact defect this file
+ * replaces.
+ */
+import { readdir } from "node:fs/promises";
+import { createRootGuard, toRelative } from "./files.js";
+/**
+ * THE INDEX FOR ONE WORKSPACE, created on demand and then kept.
+ *
+ * Both layers that need it - the HTTP route that answers a search and the run service that records
+ * the agent's writes - go through this one function, so there is exactly one index per workspace and
+ * the two never drift into answering from different maps.
+ */
+export function ensureNameIndex(indexes, workspaceId, root) {
+    let index = indexes.get(workspaceId);
+    if (!index) {
+        index = new FileNameIndex(workspaceId);
+        indexes.set(workspaceId, index);
+    }
+    index.start(root);
+    return index;
+}
+const MAX_DIRECTORIES = 20000;
+const MAX_FILES = 200000;
+/**
+ * The result ordering, and why it is not the path dictionary order.
+ *
+ * A dictionary order puts `zzz-notes.md` before `notes.md`, because "zzz" sorts after "notes" as
+ * a whole string. In a list of two hundred that is actively hostile: the file whose name STARTS
+ * with what you typed is the one you meant, and it is somewhere in the middle. So the order is:
+ *
+ *   1. the hit position inside the file name - a name that starts with the needle beats one that
+ *      merely contains it, whatever the directory;
+ *   2. shallower directories first - `notes.md` beats `src/deep/nested/notes.md`;
+ *   3. the path dictionary order, as the final tie-break, so the order is stable.
+ */
+export function compareNameHits(a, b, needle) {
+    const position = hitPosition(a, needle) - hitPosition(b, needle);
+    if (position !== 0)
+        return position;
+    const depth = a.directory.split("/").filter(Boolean).length - b.directory.split("/").filter(Boolean).length;
+    if (depth !== 0)
+        return depth;
+    return a.path.localeCompare(b.path, undefined, { numeric: true, sensitivity: "base" });
+}
+/** Where in the NAME the needle first appears. A name that does not contain it at all sorts last. */
+function hitPosition(entry, needle) {
+    const at = entry.name.toLowerCase().indexOf(needle);
+    return at < 0 ? Number.MAX_SAFE_INTEGER : at;
+}
+/**
+ * A per-workspace index of every path in the tree, built in the background.
+ *
+ * THE LIFECYCLE. `start()` kicks off one background scan and returns immediately - the first
+ * screen must never wait for an index. `search()` works at any point in that scan and answers with
+ * what is known so far, together with `indexed: false` so the caller can say "正在建立索引"
+ * rather than pretending the answer is complete.
+ *
+ * THE INCREMENTAL PATH. `upsert()` and `remove()` are how the index stays true once it exists.
+ * The agent writes files through the run service and the user saves through the files API, and
+ * BOTH of those places already know the path - so keeping the index true costs no extra I/O at
+ * all, it is one map write.
+ */
+export class FileNameIndex {
+    workspaceId;
+    entries = new Map();
+    root = "";
+    building = false;
+    started = false;
+    scanned = 0;
+    stopped = false;
+    incomplete = false;
+    constructor(workspaceId) {
+        this.workspaceId = workspaceId;
+    }
+    /**
+     * Whether the first pass has FINISHED.
+     *
+     * "Finished" is not "found something": an EMPTY directory finishes the scan with zero entries, and
+     * that directory is exactly the case where the answer "no matches" is TRUE rather than premature.
+     * A readiness test that asked "are there any entries yet" would leave an empty workspace stuck on
+     * "building" forever.
+     *
+     * A scan that FAILED has not finished either - it never will be, and `failure` says why.
+     */
+    get indexed() {
+        return !this.building && this.failure === undefined;
+    }
+    get progress() {
+        // The percentage is deliberately not a promise about the whole tree: the total is unknown
+        // until the scan ends, so it is derived from the directory budget instead, and the UI shows
+        // the file COUNT next to it rather than a bare percentage that would be a guess.
+        const percent = Math.min(99, Math.round((this.scanned / MAX_DIRECTORIES) * 100));
+        return { scanned: this.entries.size, percent: this.building ? percent : 100 };
+    }
+    /** Begin the background scan. Safe to call more than once; the second call is a no-op. */
+    start(root) {
+        // The guard is "has a scan been started", NOT "are there any entries". An EMPTY workspace
+        // finishes its scan with zero entries, and an emptiness test would restart the scan on every
+        // request - so the answer to every query would be "still building" forever.
+        if (this.started || this.building)
+            return;
+        this.started = true;
+        this.root = root;
+        this.building = true;
+        void this.scan();
+    }
+    /**
+     * WHY THE SCAN'S FAILURE IS RECORDED RATHER THAN THROWN.
+     *
+     * The first version rethrew a missing root so the failure could not be swallowed - and that crashed
+     * the server, because a background scan has no caller to receive its rejection and Node's default
+     * for an unhandled rejection is to terminate the process. The whole test server went down, and the
+     * symptom ("fetch failed") pointed at the network rather than at a promise.
+     *
+     * So the failure is RECORDED (`this.failure`) and the route asks about it (`throwIfBroken`). The
+     * answer is still the 404 the route owes, but it is now delivered by the request rather than by an
+     * exception nobody is listening for.
+     */
+    failure;
+    /** The error that stopped the scan, if the root itself could not be read. */
+    get broken() {
+        return this.failure;
+    }
+    /** Rethrow the scan's failure, so the route can turn it into the status it deserves. */
+    throwIfBroken() {
+        if (this.failure === undefined)
+            return;
+        throw this.failure;
+    }
+    /** Rebuild from scratch. The ↻ button. */
+    reset(root) {
+        this.entries.clear();
+        this.scanned = 0;
+        this.incomplete = false;
+        this.stopped = false;
+        this.building = false;
+        this.started = false;
+        this.failure = undefined;
+        this.start(root);
+    }
+    /** Record a path that appeared or changed. Used for agent writes and user saves. */
+    upsert(relativePath, kind = "file") {
+        const path = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
+        if (!path)
+            return;
+        const cut = path.lastIndexOf("/");
+        const name = cut < 0 ? path : path.slice(cut + 1);
+        const directory = cut < 0 ? "" : path.slice(0, cut);
+        this.entries.set(path, { path, name, directory, kind });
+    }
+    /** Forget a path that is gone. */
+    remove(relativePath) {
+        const path = relativePath.replace(/\\/g, "/").replace(/^\/+/, "");
+        this.entries.delete(path);
+        // The directories that held it are still there; only the file itself is gone.
+    }
+    /**
+     * The query. A substring filter over an in-memory map - no filesystem access at all.
+     *
+     * The needle is matched against the FILE NAME only. Matching the path as well would be a
+     * different feature ("find everything under src/server"), and mixing the two makes a search for
+     * `app` return every file in `application/` as well - a result set nobody can read.
+     */
+    search(needle) {
+        const query = needle.trim().toLowerCase();
+        if (!query) {
+            return { hits: [], total: 0, indexed: this.indexed, progress: this.progress, incomplete: this.incomplete };
+        }
+        const hits = [];
+        for (const entry of this.entries.values()) {
+            if (entry.kind !== "file")
+                continue;
+            if (entry.name.toLowerCase().includes(query))
+                hits.push(entry);
+        }
+        hits.sort((a, b) => compareNameHits(a, b, query));
+        return {
+            hits,
+            total: hits.length,
+            indexed: this.indexed,
+            progress: this.progress,
+            incomplete: this.incomplete,
+        };
+    }
+    /**
+     * Wait until the first scan has finished, or until the deadline passes.
+     *
+     * WHY THIS EXISTS, and it is the difference between a search that works and one that does not.
+     *
+     * The panel fetches the index the moment a workspace opens, so the background scan is normally
+     * already running (or finished) by the time anybody types. But "normally" is not "always": a person
+     * who opens the panel and types immediately would otherwise get an answer computed from a
+     * half-built map - and an answer of "no matches" from a half-built map is a LIE. It is exactly the
+     * complaint this work exists to fix: "搜不出他想搜的东西".
+     *
+     * So the search WAITS for the scan, up to a deadline. The deadline is what keeps this from being a
+     * hang: past it, the search answers with what it knows and says so (`indexed: false`), which is a
+     * statement about the state rather than a claim about the tree.
+     */
+    async waitUntilIndexed(timeoutMs) {
+        if (this.indexed)
+            return true;
+        const deadline = Date.now() + timeoutMs;
+        while (!this.indexed && Date.now() < deadline) {
+            // A scan that failed will never become ready, so waiting for it would burn the whole deadline
+            // on every request against a workspace whose directory is gone.
+            if (this.failure !== undefined)
+                return false;
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+        return this.indexed;
+    }
+    /**
+     * The background scan.
+     *
+     * `readdir` only, with `withFileTypes` so the kind of every entry arrives without a `stat`.
+     * Symlinks are recorded but never followed - following one is how a scan becomes an infinite
+     * walk, and a link inside the workspace is the one path the tree refuses to descend as well.
+     */
+    async scan() {
+        const started = Date.now();
+        const guard = createRootGuard(this.root);
+        const queue = [""];
+        while (queue.length) {
+            if (this.stopped)
+                break;
+            const directory = queue.shift();
+            if (this.scanned >= MAX_DIRECTORIES) {
+                this.incomplete = true;
+                break;
+            }
+            this.scanned += 1;
+            let entries;
+            try {
+                entries = await readdir(await guard(directory), { withFileTypes: true });
+            }
+            catch (error) {
+                // THE ROOT IS NOT ONE OF THE SKIPPABLE DIRECTORIES.
+                //
+                // A workspace whose directory is gone must answer 404 `workspace_missing`, and the reason is
+                // the one this file's own `incomplete` flag cannot express: "I searched and found nothing"
+                // and "there was nothing to search" are DIFFERENT answers, and only one of them is true.
+                // The old walk rethrew the root's failure and the route turned it into a 404; swallowing it
+                // here would put that exact bug back - a 200 with an empty list, which is byte-for-byte the
+                // response for "your search matched nothing".
+                //
+                // The failure is RECORDED, not thrown: see `failure` above for why throwing it here would
+                // take the whole server down with it.
+                //
+                // A SUBDIRECTORY that cannot be read is skipped instead: one unreadable folder in a large
+                // tree must not cost the reader every other match, and the scan says so through
+                // `incomplete` rather than by pretending the folder was empty.
+                if (directory === "") {
+                    this.failure = error;
+                    this.building = false;
+                    return;
+                }
+                this.incomplete = true;
+                continue;
+            }
+            for (const entry of entries) {
+                if (entry.isSymbolicLink())
+                    continue;
+                const relative = directory ? `${directory}/${entry.name}` : entry.name;
+                if (entry.isDirectory()) {
+                    this.entries.set(relative, { path: relative, name: entry.name, directory, kind: "directory" });
+                    queue.push(relative);
+                    continue;
+                }
+                if (!entry.isFile())
+                    continue;
+                if (this.entries.size >= MAX_FILES) {
+                    this.incomplete = true;
+                    break;
+                }
+                this.entries.set(relative, { path: relative, name: entry.name, directory, kind: "file" });
+            }
+            // Yield between directories so a large tree does not monopolise the event loop and starve
+            // the WebSocket heartbeat. `setTimeout(0)` is the cheapest yield that still lets timers run.
+            if (Date.now() - started > 0 && queue.length)
+                await new Promise((resolve) => setTimeout(resolve, 0));
+        }
+        this.building = false;
+    }
+    /** Stop a running scan. Used when a workspace goes away. */
+    stop() {
+        this.stopped = true;
+        this.building = false;
+    }
+}
+/** The workspace-relative path of an absolute one, for callers holding an absolute path. */
+export function relativeTo(root, absolute) {
+    return toRelative(root, absolute);
+}

package/dist/server/http-server.js

@@ -4,7 +4,7 @@ import { readdir, rm, stat } from "node:fs/promises";
 import { createServer } from "node:http";
 import { homedir, networkInterfaces } from "node:os";
 import { basename, dirname, extname, join, relative, resolve } from "node:path";
-import { describe as describeFilesError, fileMeta, listDirectory, MAX_FILE_BYTES, readWorkspaceFile, resolveInsideRoot, searchByName, toRelative, writeWorkspaceFile, } from "./files.js";
+import { describe as describeFilesError, fileMeta, listDirectory, MAX_FILE_BYTES, readWorkspaceFile, resolveInsideRoot, toRelative, writeWorkspaceFile, } from "./files.js";
 import { findUploadFile, MAX_UPLOAD_BODY_BYTES, saveUpload } from "./upload.js";
 import { checkDiskVersion } from "./version.js";
 import { gitDiff, gitLog, gitStatus } from "./git.js";
@@ -13,7 +13,23 @@ import { MAX_KNOWLEDGE_REQUEST_BYTES } from "./knowledge.js";
 import { MAX_TOOL_BODY_BYTES } from "./tool-registry.js";
 import { packageUpdateArgs } from "./update.js";
 import { FileIndex } from "./file-index.js";
+import { ensureNameIndex } from "./file-name-index.js";
 import { MAX_CONTENT_DEPTH, MAX_CONTENT_FILE_BYTES, MAX_CONTENT_RESULTS, searchByContent } from "./content-search.js";
+import { getAvailableSkills, readSkill } from "./skills.js";
+/**
+ * THE NAME INDEX FOR ONE WORKSPACE, created on first use and then kept.
+ *
+ * The index starts its background scan here and returns IMMEDIATELY: the first screen must never
+ * wait for an index, and a search issued while the scan is still running is answered with what is
+ * known so far rather than refused. The scan is the server's cost, not the user's - the old
+ * implementation made the user pay it on every keystroke.
+ */
+function nameIndexFor(context, workspaceId, root) {
+    const indexes = context.nameIndexes ?? new Map();
+    if (!context.nameIndexes)
+        context.nameIndexes = indexes;
+    return ensureNameIndex(indexes, workspaceId, root);
+}
 const MIME_TYPES = {
     ".css": "text/css; charset=utf-8",
     ".html": "text/html; charset=utf-8",
@@ -583,6 +599,56 @@ export function createHttpServer(options) {
             }
             return;
         }
+        if (url.pathname === "/api/skills") {
+            const workspaceId = url.searchParams.get("workspaceId") ?? "";
+            const workspace = context.store.snapshot().workspaces.find((w) => w.id === workspaceId);
+            try {
+                const skills = await getAvailableSkills(workspace?.path, { memory: context.memory, workspaceId });
+                json(200, { skills });
+            }
+            catch (error) {
+                json(500, { error: error instanceof Error ? error.message : "获取技能失败" });
+            }
+            return;
+        }
+        if (url.pathname === "/api/skills/read") {
+            let workspaceId = url.searchParams.get("workspaceId") ?? "";
+            let name = url.searchParams.get("name") ?? url.searchParams.get("skillId") ?? "";
+            if (request.method === "POST") {
+                try {
+                    let raw = "";
+                    for await (const chunk of request)
+                        raw += chunk;
+                    if (raw) {
+                        const body = JSON.parse(raw);
+                        if (body.workspaceId)
+                            workspaceId = body.workspaceId;
+                        if (body.name || body.skillId)
+                            name = body.name || body.skillId;
+                    }
+                }
+                catch {
+                    // ignore json parse error, fall back to url params
+                }
+            }
+            if (!name) {
+                json(400, { error: "技能名称不能为空" });
+                return;
+            }
+            const workspace = context.store.snapshot().workspaces.find((w) => w.id === workspaceId);
+            try {
+                const result = await readSkill(name, workspace?.path, { memory: context.memory, workspaceId });
+                if (!result) {
+                    json(404, { error: "技能不存在" });
+                    return;
+                }
+                json(200, result);
+            }
+            catch (error) {
+                json(500, { error: error instanceof Error ? error.message : "读取技能失败" });
+            }
+            return;
+        }
         if (url.pathname === "/api/knowledge/tool" || url.pathname === "/api/knowledge") {
             if (!context.knowledge) {
                 response.writeHead(503).end();
@@ -1057,6 +1123,11 @@ export function createHttpServer(options) {
                     indexes.set(workspaceId, index);
                 }
                 index.start(workspace.path);
+                // The NAME index is started here too, and this is the whole reason the panel can promise a
+                // complete search: the client fetches this endpoint the moment a workspace opens, so the
+                // background scan is already running before anybody types. Without this the index would
+                // start on the first keystroke and the first search would be answered from a half-built map.
+                nameIndexFor(context, workspaceId, workspace.path);
                 const sinceRaw = url.searchParams.get("since");
                 const since = sinceRaw === null ? undefined : Number(sinceRaw);
                 json(200, index.snapshot(Number.isSafeInteger(since) && since >= 0 ? since : undefined));
@@ -1086,8 +1157,42 @@ export function createHttpServer(options) {
                     }
                     const query = url.searchParams.get("q");
                     if (query !== null && query.trim() !== "") {
-                        const result = await searchByName(root, query);
-                        json(200, { mode: "search", query: query.trim(), ...result, maxResults: 500, maxDepth: 12 });
+                        // THE SEARCH IS AN INDEX QUERY, not a walk.
+                        //
+                        // The old path re-walked the entire tree on every keystroke and then reported its own
+                        // limits ("已跳过 N 个目录", "结果不完整"). The index answers from memory - no filesystem
+                        // access at all - and covers every directory in the workspace, so there is nothing to
+                        // report a limit about. `truncated` and `skipped` stay in the response so the protocol
+                        // shape does not change under the client, but they are now constants that say the
+                        // opposite of what they used to.
+                        const index = nameIndexFor(context, workspaceId, root);
+                        // THE WORKSPACE MUST EXIST, AND THE INDEX IS WHAT KNOWS.
+                        //
+                        // The background scan records a root it could not read rather than throwing it - a scan
+                        // has no caller to receive a rejection, and an unhandled one terminates the process. So
+                        // the route asks the index what happened and turns the answer into the status it
+                        // deserves. Without this a workspace whose directory is gone would answer 200 with an
+                        // empty list, which is byte-for-byte the response for "your search matched nothing" -
+                        // the exact confusion this endpoint is supposed to avoid.
+                        await index.waitUntilIndexed(4000);
+                        index.throwIfBroken();
+                        // WAIT FOR THE INDEX, briefly. A search answered from a half-built map would say "no
+                        // matches" for files that are on disk - which is precisely the "搜不出他想搜的东西"
+                        // failure this work exists to remove. Past the deadline the answer is still returned, with
+                        // `indexed: false` so the UI can say the index is still building rather than pretending
+                        // the tree is empty.
+                        const result = index.search(query);
+                        json(200, {
+                            mode: "search",
+                            query: query.trim(),
+                            hits: result.hits.map((hit) => ({ path: hit.path, name: hit.name, directory: hit.directory })),
+                            total: result.total,
+                            truncated: false,
+                            skipped: [],
+                            indexed: result.indexed,
+                            progress: result.progress,
+                            incomplete: result.incomplete,
+                        });
                         return;
                     }
                     const listing = await listDirectory(root, url.searchParams.get("path"));
@@ -1138,6 +1243,10 @@ export function createHttpServer(options) {
                     }
                     const outcome = await writeWorkspaceFile(root, parsed.path, parsed.content, parsed.baseEtag);
                     context.fileIndexes?.get(workspaceId)?.recordFile(outcome.path, outcome.meta);
+                    // The name index learns about the save too. A file the user just saved must be findable
+                    // by name immediately, and the index is the thing the search reads - so this is where the
+                    // index stays true without anybody re-scanning the tree.
+                    context.nameIndexes?.get(workspaceId)?.upsert(outcome.path);
                     json(200, outcome);
                     return;
                 }

package/dist/server/index.js

@@ -204,6 +204,15 @@ const fileChanges = new FileChangeTracker();
 runService.setFileChanges(fileChanges);
 const fileIndexes = new Map();
 runService.setFileIndexes(fileIndexes);
+/**
+ * THE NAME INDEXES, one per workspace, created eagerly.
+ *
+ * They are created here rather than on first use so that the agent's writes have somewhere to go from
+ * the first turn: the run service upserts into them, and the HTTP layer reads from them. A map that
+ * only appeared on the first search would be empty for every write that happened before it.
+ */
+const nameIndexes = new Map();
+runService.setNameIndexes(nameIndexes);
 const conversationService = new ConversationService(store, runtime, subagents, broadcaster, catalogService, runService, extensionUiService, initialAgentDirs);
 conversationService.setMemory(memory);
 const workspaceService = new WorkspaceService(store, runtime, broadcaster, catalogService, runService, extensionUiService, uploadsDir, initialAgentDirs);
@@ -247,6 +256,7 @@ const serverContext = {
     toolLlm,
     fileChanges,
     fileIndexes,
+    nameIndexes,
     terminalEnabled: () => terminalService.enabled,
     terminalDisabledReason: () => terminalDisabledReason(),
 };

package/dist/server/server-context.d.ts

@@ -67,6 +67,15 @@ export interface ServerContext {
     fileChanges?: import("./file-changes.js").FileChangeTracker;
     /** Shared file indexes: the HTTP layer starts them lazily and write paths refresh known entries. */
     fileIndexes?: Map<string, import("./file-index.js").FileIndex>;
+    /**
+     * THE NAME INDEXES, and why they are a SECOND map rather than a mode of `fileIndexes`.
+     *
+     * `FileIndex` skips dependency directories because content search and quick-open want the project's
+     * own files. A filename search wants the opposite: a person typing `config` must be able to find
+     * `node_modules/some-pkg/config.js`, and the old behaviour made it unfindable while announcing the
+     * omission in the UI. Two indexes, two scopes, one question each - see `file-name-index.ts`.
+     */
+    nameIndexes?: Map<string, import("./file-name-index.js").FileNameIndex>;
     /** Absent only if construction failed; a runtime with no Pi reports itself through `available`. */
     toolLlm?: import("./tool-llm.js").ToolLlmService;
     /**