@myagentroam/node 0.9.95 → 0.9.96

package/dist/service/workspace-code-navigation-service.js

@@ -88,6 +88,7 @@ const buildWaiters = [];
 export class WorkspaceCodeNavigationService {
     options;
     builds = new Map();
+    preparations = new Map();
     candidateRefreshes = new Map();
     locations = new Map();
     failures = new Map();
@@ -96,6 +97,49 @@ export class WorkspaceCodeNavigationService {
     constructor(options) {
         this.options = options;
     }
+    async prepare(workspace, input) {
+        if (typeof input.path !== 'string' || input.path.length === 0 || input.path.length > 4096)
+            throw new Error('SYMBOL_DEFINITION_INVALID');
+        if (!isNavigablePath(input.path))
+            return { state: 'READY' };
+        if (!(await this.available()))
+            return { state: 'UNAVAILABLE' };
+        const location = await this.indexLocation(workspace);
+        this.locations.set(workspace.id, location);
+        this.forgotten.delete(location.directory);
+        const manifest = await readManifest(location.manifest);
+        const tags = manifest === undefined
+            ? undefined
+            : await tagsPath(location, manifest).catch(() => undefined);
+        const reusable = manifest !== undefined &&
+            tags !== undefined &&
+            (await tagsAvailable(tags)) &&
+            manifest.sourceFiles !== undefined;
+        const current = reusable &&
+            manifest.schemaVersion === INDEX_SCHEMA_VERSION &&
+            manifest.optionsVersion === INDEX_OPTIONS_VERSION &&
+            manifest.ctagsVersion === BUNDLED_CTAGS_VERSION;
+        const cachedCandidates = this.options.files.index(workspace).peekContentCandidates();
+        const forceRefreshGeneration = this.forceFreshCandidates.get(workspace.id);
+        if (reusable) {
+            if (!current || cachedCandidates === undefined || forceRefreshGeneration !== undefined)
+                this.refreshCandidatesInBackground(workspace, location, manifest, {
+                    requireFresh: forceRefreshGeneration !== undefined,
+                    mustBuild: !current || forceRefreshGeneration !== undefined,
+                    forceRefreshGeneration
+                });
+            return { state: current ? 'READY' : 'STALE' };
+        }
+        const failure = this.failures.get(location.directory);
+        if (failure !== undefined &&
+            !this.builds.has(location.directory) &&
+            !this.preparations.has(location.directory)) {
+            this.failures.delete(location.directory);
+            return { state: 'FAILED', failureCode: failure };
+        }
+        this.startInitialBuild(workspace, location);
+        return { state: 'BUILDING' };
+    }
     async definition(workspace, input) {
         const path = input.path;
         const symbol = input.symbol;
@@ -276,15 +320,32 @@ export class WorkspaceCodeNavigationService {
         };
     }
     startBuild(input, location, previous) {
-        void this.ensureBuild(input, location, previous).catch((error) => {
-            const failure = buildFailure(error);
-            this.failures.set(location.directory, failure);
-            nodeLog('workspace.code_navigation.index.failed', {
-                nodeId: this.options.nodeId(),
-                failureCode: failure,
-                sourceFiles: input.entries.length,
-                candidateScanMs: input.candidateScanMs
-            });
+        void this.ensureBuild(input, location, previous).catch((error) => this.recordBuildFailure(location, error, input));
+    }
+    startInitialBuild(workspace, location) {
+        if (this.builds.has(location.directory) || this.preparations.has(location.directory))
+            return;
+        const preparation = this.indexInput(workspace, true)
+            .then((input) => {
+            if (this.forgotten.has(location.directory))
+                return;
+            return this.ensureBuild(input, location);
+        })
+            .catch((error) => this.recordBuildFailure(location, error))
+            .finally(() => {
+            if (this.preparations.get(location.directory) === preparation)
+                this.preparations.delete(location.directory);
+        });
+        this.preparations.set(location.directory, preparation);
+    }
+    recordBuildFailure(location, error, input) {
+        const failure = buildFailure(error);
+        this.failures.set(location.directory, failure);
+        nodeLog('workspace.code_navigation.index.failed', {
+            nodeId: this.options.nodeId(),
+            failureCode: failure,
+            sourceFiles: input?.entries.length ?? 0,
+            candidateScanMs: input?.candidateScanMs ?? 0
         });
     }
     refreshCandidatesInBackground(workspace, location, manifest, options = {

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

@@ -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

@@ -37,6 +37,7 @@ 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)),
@@ -116,6 +117,10 @@ export class WorkspaceWorkbenchService {
         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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.9.95",
+  "version": "0.9.96",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -30,8 +30,8 @@
     "npm": "11.12.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.9.95",
-    "@myagentroam/protocol": "0.9.95"
+    "@myagentroam/agent": "0.9.96",
+    "@myagentroam/protocol": "0.9.96"
   },
   "devDependencies": {
     "@types/ws": "^8.18.1"