@myagentroam/node 0.9.94 → 0.9.96

package/dist/service/workspace-content-search-service.js

@@ -6,7 +6,7 @@ import { bundledRipgrepPath } from '../ripgrep-binary.js';
 const RESULT_LIMIT = 200;
 const PER_FILE_LIMIT = 20;
 const FILE_BYTE_LIMIT = 2 * 1024 * 1024;
-const SCAN_BYTE_LIMIT = 128 * 1024 * 1024;
+const SCAN_BYTE_LIMIT = 64 * 1024 * 1024;
 const OUTPUT_BYTE_LIMIT = 2 * 1024 * 1024;
 const TIMEOUT_MS = 5_000;
 const WINDOWS_ARGUMENT_BATCH_BYTES = 24 * 1024;
@@ -53,29 +53,38 @@ export class WorkspaceContentSearchService {
     search(workspace, input) {
         if (typeof input.query !== 'string' || input.query.length < 1 || input.query.length > 256)
             throw new Error('FILE_CONTENT_SEARCH_INVALID');
-        const key = `${workspace.id}\0${input.query.toLocaleLowerCase()}`;
+        if (input.regex !== undefined && typeof input.regex !== 'boolean')
+            throw new Error('FILE_CONTENT_SEARCH_INVALID');
+        const search = { query: input.query, regex: input.regex === true };
+        const queryKey = search.regex ? search.query : search.query.toLocaleLowerCase();
+        const key = `${workspace.id}\0${search.regex}\0${queryKey}`;
         const existing = this.pending.get(key);
         if (existing !== undefined)
             return existing;
-        const task = this.perform(workspace, input.query).finally(() => this.pending.delete(key));
+        const task = this.perform(workspace, search).finally(() => this.pending.delete(key));
         this.pending.set(key, task);
         return task;
     }
-    async perform(workspace, query) {
+    async perform(workspace, search) {
         const deadline = Date.now() + TIMEOUT_MS;
         const release = await acquireSearch(deadline);
         try {
+            if (search.regex && this.ripgrep === null)
+                throw new Error('RIPGREP_RESOURCE_UNAVAILABLE');
             const prepared = await this.candidates(workspace, deadline);
-            if (prepared.files.length === 0)
+            if (prepared.files.length === 0) {
+                if (search.regex)
+                    await this.validateNativeRegex(workspace.path, search, deadline);
                 return {
                     matches: [],
                     engine: 'NODE',
                     truncated: prepared.truncated || Date.now() >= deadline,
                     skippedFiles: prepared.skippedFiles
                 };
+            }
             if (this.ripgrep !== null) {
                 try {
-                    const matches = await this.nativeSearch('RIPGREP', workspace.path, prepared.files, query, deadline);
+                    const matches = await this.nativeSearch('RIPGREP', workspace.path, prepared.files, search, deadline);
                     return {
                         matches: matches.slice(0, RESULT_LIMIT),
                         engine: 'RIPGREP',
@@ -83,11 +92,13 @@ export class WorkspaceContentSearchService {
                         skippedFiles: prepared.skippedFiles
                     };
                 }
-                catch {
+                catch (error) {
+                    if (search.regex)
+                        throw error;
                     // Missing, incompatible or failed bundled resources safely fall through.
                 }
             }
-            const fallback = await nodeSearch(prepared.files, query, deadline);
+            const fallback = await nodeSearch(prepared.files, search.query, deadline);
             return {
                 matches: fallback.matches.slice(0, RESULT_LIMIT),
                 engine: 'NODE',
@@ -99,6 +110,14 @@ export class WorkspaceContentSearchService {
             release();
         }
     }
+    async validateNativeRegex(root, search, deadline) {
+        const command = commandFor('RIPGREP', [], search, this.ripgrep ?? undefined);
+        const result = await runCommand(command.file, [...command.args, '-'], root, deadline);
+        if (result.code === 2)
+            throw new Error('FILE_CONTENT_SEARCH_INVALID');
+        if (!command.validCodes.includes(result.code))
+            throw new Error('CONTENT_SEARCH_COMMAND_FAILED');
+    }
     async candidates(workspace, deadline) {
         const root = await realpath(workspace.path);
         let candidates;
@@ -139,21 +158,24 @@ export class WorkspaceContentSearchService {
         }
         return { files, skippedFiles, truncated };
     }
-    async nativeSearch(engine, root, files, query, deadline) {
+    async nativeSearch(engine, root, files, search, deadline) {
         const matches = [];
         const argumentBatchBytes = this.platform === 'win32' ? WINDOWS_ARGUMENT_BATCH_BYTES : POSIX_ARGUMENT_BATCH_BYTES;
         for (const batch of batches(files, argumentBatchBytes)) {
             if (Date.now() >= deadline || matches.length > RESULT_LIMIT)
                 break;
-            const command = commandFor(engine, batch, query, this.ripgrep ?? undefined);
+            const command = commandFor(engine, batch, search, this.ripgrep ?? undefined);
             const result = await runCommand(command.file, command.args, root, deadline, engine === 'RIPGREP');
-            if (!command.validCodes.includes(result.code))
+            if (!command.validCodes.includes(result.code)) {
+                if (search.regex && result.code === 2)
+                    throw new Error('FILE_CONTENT_SEARCH_INVALID');
                 throw new Error('CONTENT_SEARCH_COMMAND_FAILED');
+            }
             const paths = new Map(batch.flatMap((file) => [
                 [normalizeResultPath(file.path, this.platform), file.path],
                 [normalizeResultPath(file.absolutePath, this.platform), file.path]
             ]));
-            matches.push(...parseOutput(engine, result.stdout, query).map((match) => ({
+            matches.push(...parseOutput(engine, result.stdout, search).map((match) => ({
                 ...match,
                 path: paths.get(normalizeResultPath(match.path, this.platform)) ??
                     (() => {
@@ -213,7 +235,7 @@ function batches(files, maximumBytes) {
         result.push(current);
     return result;
 }
-function commandFor(engine, files, query, ripgrep) {
+function commandFor(engine, files, search, ripgrep) {
     const paths = files.map((file) => file.path);
     if (engine === 'RIPGREP')
         return {
@@ -224,12 +246,12 @@ function commandFor(engine, files, query, ripgrep) {
             args: [
                 '--json',
                 '--no-config',
-                '--fixed-strings',
                 '--ignore-case',
                 '--max-count',
                 String(PER_FILE_LIMIT),
+                ...(search.regex ? [] : ['--fixed-strings']),
                 '--',
-                query,
+                search.query,
                 ...paths
             ],
             validCodes: [0, 1]
@@ -301,14 +323,14 @@ async function runCommand(file, args, cwd, deadline, stopAfterResultLimit = fals
         });
     });
 }
-function parseOutput(engine, output, query) {
+function parseOutput(engine, output, search) {
     if (engine === 'RIPGREP')
-        return parseRipgrep(output, query);
+        return parseRipgrep(output, search);
     if (engine === 'GREP')
-        return parseGrep(output, query);
-    return parsePowerShell(output, query);
+        return parseGrep(output, search);
+    return parsePowerShell(output, search);
 }
-function parseRipgrep(output, query) {
+function parseRipgrep(output, search) {
     return output
         .toString('utf8')
         .split('\n')
@@ -320,7 +342,9 @@ function parseRipgrep(output, query) {
             return [];
         const data = value.data;
         const preview = String(data?.lines?.text).replace(/[\r\n]+$/u, '');
-        const column = lowerIndex(preview, query);
+        const column = search.regex
+            ? regexRipgrepIndex(preview, data?.submatches)
+            : lowerIndex(preview, search.query);
         if (typeof data?.path?.text !== 'string' || !Number.isInteger(data.line_number) || column < 0)
             throw new Error('CONTENT_SEARCH_OUTPUT_INVALID');
         return [
@@ -333,7 +357,7 @@ function parseRipgrep(output, query) {
         ];
     });
 }
-function parseGrep(output, query) {
+function parseGrep(output, search) {
     const matches = [];
     let offset = 0;
     while (offset < output.length) {
@@ -345,7 +369,7 @@ function parseGrep(output, query) {
         const record = output.subarray(separator + 1, end).toString('utf8');
         const colon = record.indexOf(':');
         const preview = record.slice(colon + 1).replace(/\r$/u, '');
-        const column = lowerIndex(preview, query);
+        const column = lowerIndex(preview, search.query);
         if (colon < 1 || column < 0)
             throw new Error('CONTENT_SEARCH_OUTPUT_INVALID');
         matches.push({
@@ -358,7 +382,7 @@ function parseGrep(output, query) {
     }
     return matches;
 }
-function parsePowerShell(output, query) {
+function parsePowerShell(output, search) {
     return output
         .toString('utf8')
         .split(/\r?\n/u)
@@ -370,7 +394,7 @@ function parsePowerShell(output, query) {
             !Number.isInteger(match.line) ||
             typeof match.preview !== 'string')
             throw new Error('CONTENT_SEARCH_OUTPUT_INVALID');
-        const column = lowerIndex(match.preview, query);
+        const column = lowerIndex(match.preview, search.query);
         if (column < 0)
             throw new Error('CONTENT_SEARCH_OUTPUT_INVALID');
         return [
@@ -445,6 +469,12 @@ async function nodeSearch(files, query, deadline) {
 function lowerIndex(source, query) {
     return source.toLocaleLowerCase().indexOf(query.toLocaleLowerCase());
 }
+function regexRipgrepIndex(preview, submatches) {
+    const start = submatches?.[0]?.start;
+    if (typeof start !== 'number' || !Number.isInteger(start) || start < 0)
+        return -1;
+    return Buffer.from(preview, 'utf8').subarray(0, start).toString('utf8').length;
+}
 function limitPerFile(matches) {
     const counts = new Map();
     return matches.filter((match) => {

package/dist/service/workspace-file-service.js

@@ -1,7 +1,7 @@
 import { tmpdir } from 'node:os';
 import { isAbsolute, win32 } from 'node:path';
 import { listWorkspaceFiles, mutateWorkspaceFile, normalizeFilePreviewPath, readAllowedFileContentRange, readWorkspaceFileContentRange, readAllowedTextFile, readWorkspaceTextFile, writeWorkspaceTextFile, WorkspaceFileIndex } from '../workspace.js';
-const INDEX_CACHE_LIMIT = 8;
+const INDEX_CACHE_LIMIT = 32;
 export class WorkspaceFileService {
     state;
     allowedRoots;

package/dist/service/workspace-workbench-service.js

@@ -1,16 +1,23 @@
 import { createHash } from 'node:crypto';
 import { listGitHistoryRefs, openGitHistoryFileContent, readGitHistory, readGitHistoryFileDiff, readGitHistoryFileContentRange, readGitHistoryFiles, readCurrentChangeDiff, readRestrictedDiff, resolveGitRepository, resolveGitRepositoryTarget, restoreCurrentChange } from '../workspace.js';
+import { WorkspaceCodeNavigationService } from './workspace-code-navigation-service.js';
 import { WorkspaceContentSearchService } from './workspace-content-search-service.js';
 import { WorkspaceWatchController } from './workspace-watch-controller.js';
 import { WorkspaceWatchSnapshotService } from './workspace-watch-snapshot-service.js';
 export class WorkspaceWorkbenchService {
     options;
     contentSearch;
+    codeNavigation;
     snapshots;
     watchController;
     constructor(options) {
         this.options = options;
         this.contentSearch = new WorkspaceContentSearchService(options.files);
+        this.codeNavigation = new WorkspaceCodeNavigationService({
+            files: options.files,
+            nodeId: options.nodeId,
+            searchContent: (workspace, query) => this.contentSearch.search(workspace, { query })
+        });
         this.snapshots = new WorkspaceWatchSnapshotService(options);
         this.watchController = new WorkspaceWatchController({
             requireWorkspace: options.requireWorkspace,
@@ -30,6 +37,8 @@ export class WorkspaceWorkbenchService {
             'workspace.files.search': (data) => this.searchFiles(record(data)),
             'workspace.files.mutate': (data) => this.mutateFile(record(data)),
             'workspace.content.search': (data) => this.searchContent(record(data)),
+            'workspace.symbol.prepare': (data) => this.prepareSymbolIndex(record(data)),
+            'workspace.symbol.definition': (data) => this.symbolDefinition(record(data)),
             'workspace.files.upload.preflight': (data) => this.preflight(record(data)),
             'workspace.files.upload.create': (data) => this.createUpload(record(data)),
             'workspace.files.upload.chunk': (data) => this.writeUpload(record(data)),
@@ -56,9 +65,19 @@ export class WorkspaceWorkbenchService {
     ensureTopicSnapshot(workspaceId, topic) {
         return this.snapshots.ensureSnapshot(workspaceId, topic);
     }
-    clearWorkspace(workspaceId) {
+    /** Node-owned file mutations must not reuse a generation's old candidate list. */
+    invalidateWorkspaceFiles(workspaceId) {
+        this.codeNavigation.invalidate(workspaceId);
+    }
+    /** Releases page-watch state without discarding the durable code index. */
+    releaseWorkspace(workspaceId) {
         this.snapshots.clear(workspaceId);
     }
+    /** Removes all Workspace state after the Workspace itself is unregistered. */
+    clearWorkspace(workspaceId) {
+        this.releaseWorkspace(workspaceId);
+        this.codeNavigation.forget(workspaceId);
+    }
     clear() {
         this.snapshots.clearAll();
     }
@@ -94,6 +113,14 @@ export class WorkspaceWorkbenchService {
         const workspace = this.options.requireWorkspace(input.workspaceId);
         return { search: await this.contentSearch.search(workspace, input) };
     }
+    async symbolDefinition(input) {
+        const workspace = this.options.requireWorkspace(input.workspaceId);
+        return { definition: await this.codeNavigation.definition(workspace, input) };
+    }
+    async prepareSymbolIndex(input) {
+        const workspace = this.options.requireWorkspace(input.workspaceId);
+        return { preparation: await this.codeNavigation.prepare(workspace, input) };
+    }
     async preflight(input) {
         return {
             uploads: await this.options.uploads.preflight(this.options.requireWorkspace(input.workspaceId), input)

package/dist/workspace.js

@@ -90,12 +90,51 @@ export class WorkspaceFileIndex {
     expiryTimer;
     refreshedAt = 0;
     refreshAttemptedAt = 0;
+    lifecycleGeneration = 0;
     constructor(workspaceRoot, limits = {}) {
         this.workspaceRoot = workspaceRoot;
         this.limits = limits;
     }
-    async contentCandidates() {
-        await this.ensureLoaded();
+    async contentCandidates(options = {}) {
+        await this.ensureLoaded(options.requireFresh === true);
+        return this.currentContentCandidates();
+    }
+    /**
+     * Returns the current candidate snapshot without synchronously rebuilding an
+     * empty or explicitly invalidated index. A stale loaded snapshot schedules
+     * its normal single-flight refresh before it is returned.
+     */
+    peekContentCandidates() {
+        if (this.stale || this.root === undefined)
+            return undefined;
+        if (Date.now() - this.refreshAttemptedAt >=
+            (this.limits.freshnessTtlMs ?? FILE_INDEX_FRESHNESS_TTL_MS))
+            this.refreshInBackground();
+        return this.currentContentCandidates();
+    }
+    /** Starts a single candidate refresh without making the caller await it. */
+    refreshContentCandidates(requireFresh = false) {
+        if (this.loading !== undefined)
+            return this.loading;
+        if (this.stale || this.root === undefined) {
+            this.loading = this.rebuild().finally(() => {
+                this.loading = undefined;
+            });
+            return this.loading;
+        }
+        if (requireFresh) {
+            this.refreshAttemptedAt = Date.now();
+            this.loading = this.rebuild().finally(() => {
+                this.loading = undefined;
+            });
+            return this.loading;
+        }
+        if (Date.now() - this.refreshAttemptedAt >=
+            (this.limits.freshnessTtlMs ?? FILE_INDEX_FRESHNESS_TTL_MS))
+            this.refreshInBackground();
+        return this.loading ?? Promise.resolve();
+    }
+    currentContentCandidates() {
         this.touch();
         return {
             entries: this.entries.filter((entry) => entry.kind === 'FILE'),
@@ -103,6 +142,7 @@ export class WorkspaceFileIndex {
         };
     }
     dispose() {
+        this.lifecycleGeneration += 1;
         if (this.expiryTimer !== undefined)
             clearTimeout(this.expiryTimer);
         this.expiryTimer = undefined;
@@ -150,11 +190,22 @@ export class WorkspaceFileIndex {
             truncated: next !== undefined || this.truncated
         };
     }
-    async ensureLoaded() {
+    async ensureLoaded(requireFresh = false) {
         if (!this.stale && this.root !== undefined) {
             if (Date.now() - this.refreshAttemptedAt >=
-                (this.limits.freshnessTtlMs ?? FILE_INDEX_FRESHNESS_TTL_MS))
-                this.refreshInBackground();
+                (this.limits.freshnessTtlMs ?? FILE_INDEX_FRESHNESS_TTL_MS)) {
+                if (requireFresh) {
+                    if (this.loading === undefined) {
+                        this.refreshAttemptedAt = Date.now();
+                        this.loading = this.rebuild().finally(() => {
+                            this.loading = undefined;
+                        });
+                    }
+                    await this.loading;
+                }
+                else
+                    this.refreshInBackground();
+            }
             return;
         }
         if (this.loading === undefined) {
@@ -171,14 +222,21 @@ export class WorkspaceFileIndex {
         this.expiryTimer.unref();
     }
     async rebuild() {
+        const generation = this.lifecycleGeneration;
         const root = await resolveRegisteredWorkspaceRoot(this.workspaceRoot);
+        if (generation !== this.lifecycleGeneration)
+            return;
         const excludes = [...DEFAULT_QUICK_OPEN_EXCLUDES, ...(await workspaceExcludePatterns(root))];
+        if (generation !== this.lifecycleGeneration)
+            return;
         const indexed = [];
         const entryLimit = this.limits.entryLimit ?? FILE_INDEX_ENTRY_LIMIT;
         let truncated = false;
         const directories = ['.'];
         let directoryCursor = 0;
-        while (directoryCursor < directories.length && !truncated) {
+        while (generation === this.lifecycleGeneration &&
+            directoryCursor < directories.length &&
+            !truncated) {
             const relativeDirectory = directories[directoryCursor];
             directoryCursor += 1;
             const directory = await resolveWorkspaceEntryFromCanonicalRoot(root, relativeDirectory, true).catch(() => undefined);
@@ -191,6 +249,8 @@ export class WorkspaceFileIndex {
             const appendPending = async () => {
                 const resolvedEntries = await Promise.all(pending);
                 pending = [];
+                if (generation !== this.lifecycleGeneration)
+                    return;
                 for (const entry of resolvedEntries) {
                     if (entry === undefined)
                         continue;
@@ -208,6 +268,8 @@ export class WorkspaceFileIndex {
                 }
             };
             for await (const child of stream) {
+                if (generation !== this.lifecycleGeneration)
+                    return;
                 const candidatePath = relativeDirectory === '.'
                     ? child.name
                     : posix.join(relativeDirectory.replaceAll('\\', '/'), child.name);
@@ -224,6 +286,8 @@ export class WorkspaceFileIndex {
             if (!truncated && pending.length > 0)
                 await appendPending();
         }
+        if (generation !== this.lifecycleGeneration)
+            return;
         this.root = root;
         this.entries = indexed;
         this.truncated = truncated;

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.94",
+  "version": "0.9.96",
   "description": "MyAgentRoam Node runtime CLI.",
-  "license": "Apache-2.0",
+  "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
   "files": [
     "dist/**/*.js",
     "vendor/ripgrep/**/*",
+    "vendor/ctags/**/*",
     "LICENSE",
     "NOTICE"
   ],
@@ -26,16 +27,18 @@
     "minimatch": "^10.2.6",
     "node-datachannel": "0.33.4",
     "node-pty": "1.1.0",
+    "npm": "11.12.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.9.94",
-    "@myagentroam/protocol": "0.9.94"
+    "@myagentroam/agent": "0.9.96",
+    "@myagentroam/protocol": "0.9.96"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"
   },
   "scripts": {
     "build": "node ../scripts/clean-build-output.mjs dist && tsc -p tsconfig.json",
+    "stage:computer-use-runtime": "node ../scripts/stage-computer-use-runtime.mjs",
     "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.tests.json --noEmit",
     "dev": "tsx watch src/main.ts",
     "start": "node dist/main.js",

package/vendor/ctags/NOTICE

@@ -0,0 +1,10 @@
+This directory distributes Universal Ctags 6.2.1 as a separate executable work.
+
+Universal Ctags is licensed under GPL-2.0-or-later. Its complete corresponding
+source is included at source/universal-ctags-6.2.1.tar.gz. The Linux x64 program
+was built without source changes from that archive using configure --disable-xml
+with optional pkg-config dependencies unavailable. The Windows x64 program is
+the upstream universal-ctags/ctags-win32 v6.2.1 ctags-v6.2.1-x64.zip executable.
+
+The Windows upstream package also distributes the MinGW-w64 runtime, jansson,
+and libyaml license texts copied into licenses/.