@myagentroam/node 0.9.97 → 0.9.99

package/dist/ctags-binary.js

@@ -1,3 +1,4 @@
+import { chmod } from 'node:fs/promises';
 import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 export const BUNDLED_CTAGS_VERSION = '6.2.1';
@@ -16,3 +17,12 @@ export function bundledCtagsPath(platform = process.platform, architecture = pro
         throw new Error('CTAGS_PLATFORM_UNSUPPORTED');
     return resolve(bundledCtagsDirectory(packageRoot), ...target);
 }
+/**
+ * Restores the execute bit when an installation mechanism lost the bundled
+ * Linux binary's archive mode. Explicit Ctags overrides are never modified.
+ */
+export async function repairBundledCtagsExecutable(platform = process.platform, architecture = process.arch, packageRoot) {
+    if (platform !== 'linux')
+        return;
+    await chmod(bundledCtagsPath(platform, architecture, packageRoot), 0o755);
+}

package/dist/service/code-navigation/c-family-path-specifier-resolver.js

@@ -0,0 +1,40 @@
+import { posix } from 'node:path';
+import { matchesPathSuffix } from './path-specifier-resolver.js';
+function accepts(value) {
+    return /^(?:\.\.?\/)?(?:[A-Za-z0-9_$+.-]+\/)*[A-Za-z0-9_$+.-]+$/u.test(value);
+}
+function matches(path, currentPath, specifier) {
+    return candidates(currentPath, specifier).some((candidate) => path === candidate || matchesPathSuffix(path, candidate));
+}
+function score(path, currentPath, specifier) {
+    const resolvedCandidates = candidates(currentPath, specifier);
+    const exact = resolvedCandidates.indexOf(path);
+    if (exact >= 0)
+        return exact;
+    const suffix = resolvedCandidates.findIndex((candidate) => matchesPathSuffix(path, candidate));
+    return suffix >= 0 ? resolvedCandidates.length + suffix + path.length : Number.MAX_SAFE_INTEGER;
+}
+function candidates(currentPath, specifier) {
+    const relative = posix.normalize(posix.join(posix.dirname(currentPath), specifier));
+    if (relative.startsWith('../') || relative === '..' || relative === specifier)
+        return [specifier];
+    return [relative.replace(/^\.\//u, ''), specifier];
+}
+export const cFamilyPathSpecifierResolver = {
+    id: 'c-family.path-specifier',
+    accepts,
+    directCandidates: candidates,
+    matches,
+    score
+};
+function createCFamilyNavigationResolutionDefinition(languageId) {
+    return {
+        languageId,
+        resolver: { ...cFamilyPathSpecifierResolver, id: `${languageId}.path-specifier` }
+    };
+}
+export const cNavigationResolutionDefinition = createCFamilyNavigationResolutionDefinition('c');
+export const cppNavigationResolutionDefinition = createCFamilyNavigationResolutionDefinition('cpp');
+export const objectiveCNavigationResolutionDefinition = createCFamilyNavigationResolutionDefinition('objective-c');
+export const objectiveCppNavigationResolutionDefinition = createCFamilyNavigationResolutionDefinition('objective-cpp');
+export const cFamilyNavigationResolutionDefinition = createCFamilyNavigationResolutionDefinition('c-family');

package/dist/service/code-navigation/csharp-path-specifier-resolver.js

@@ -0,0 +1,32 @@
+import { matchesPathSuffix } from './path-specifier-resolver.js';
+function accepts(value) {
+    return /^[\p{L}_\p{Nl}][\p{L}\p{Nl}\p{Nd}\p{Pc}\p{Mn}\p{Mc}]*(?:\.[\p{L}_\p{Nl}][\p{L}\p{Nl}\p{Nd}\p{Pc}\p{Mn}\p{Mc}]*)*$/u.test(value);
+}
+function matches(path, _currentPath, specifier) {
+    if (!path.endsWith('.cs'))
+        return false;
+    return namespaceSuffixes(specifier).some((suffix) => matchesPathSuffix(path, `${suffix}.cs`) ||
+        path.startsWith(`${suffix}/`) ||
+        path.includes(`/${suffix}/`));
+}
+function score(path, _currentPath, specifier) {
+    const suffixes = namespaceSuffixes(specifier);
+    const index = suffixes.findIndex((suffix) => matchesPathSuffix(path, `${suffix}.cs`) ||
+        path.startsWith(`${suffix}/`) ||
+        path.includes(`/${suffix}/`));
+    return index < 0 ? Number.MAX_SAFE_INTEGER : index * 10_000 + path.length;
+}
+function namespaceSuffixes(specifier) {
+    const segments = specifier.split('.');
+    return segments.map((_, index) => segments.slice(index).join('/'));
+}
+export const csharpPathSpecifierResolver = {
+    id: 'csharp.path-specifier',
+    accepts,
+    matches,
+    score
+};
+export const csharpNavigationResolutionDefinition = {
+    languageId: 'csharp',
+    resolver: csharpPathSpecifierResolver
+};

package/dist/service/code-navigation/ctags-index-storage.js

@@ -0,0 +1,290 @@
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { createReadStream, createWriteStream } from 'node:fs';
+import { lstat, mkdir, readFile, readdir, rm, stat, writeFile } from 'node:fs/promises';
+import { relative, resolve, sep } from 'node:path';
+import { createInterface } from 'node:readline';
+import { compareTagNames } from './ctags-query.js';
+import { sourceFileFingerprint } from './navigation-target-validator.js';
+const BUILD_TIMEOUT_MS = 120_000;
+const BUILD_QUEUE_LIMIT = 4;
+const BUILD_QUEUE_TIMEOUT_MS = 120_000;
+const MAX_TAGS_BYTES = 512 * 1024 * 1024;
+let activeBuilds = 0;
+const buildWaiters = [];
+export function sourceDelta(previous, current) {
+    const changed = Object.entries(current)
+        .filter(([path, fingerprint]) => previous[path] !== fingerprint)
+        .map(([path]) => path);
+    const removed = Object.keys(previous).filter((path) => current[path] === undefined);
+    return { changed, removed };
+}
+export function manifestEntry(path, fingerprint) {
+    const match = /^([0-9]+):(-1|[0-9]+(?:\.[0-9]+)?)$/u.exec(fingerprint);
+    if (match === null)
+        return undefined;
+    const size = Number(match[1]);
+    const modifiedAt = match[2] === '-1' ? null : Number(match[2]);
+    if (!Number.isSafeInteger(size) ||
+        size < 0 ||
+        (modifiedAt !== null && !Number.isFinite(modifiedAt)))
+        return undefined;
+    return {
+        path,
+        name: path.slice(path.lastIndexOf('/') + 1),
+        kind: 'FILE',
+        size,
+        modifiedAt
+    };
+}
+export function sourceFingerprint(entries) {
+    const hash = createHash('sha256');
+    for (const entry of entries)
+        hash.update(`${entry.path}\0${sourceFileFingerprint(entry.size ?? -1, entry.modifiedAt)}\0`, 'utf8');
+    return hash.digest('hex');
+}
+export async function buildIncrementalTags(executable, root, previousTags, delta, staging, destination) {
+    const changedTags = resolve(staging, 'changed.tags');
+    if (delta.changed.length > 0) {
+        const list = resolve(staging, 'changed.files.list');
+        await writeFile(list, delta.changed.join('\n'), { encoding: 'utf8', mode: 0o600 });
+        const release = await acquireBuild();
+        try {
+            const ctagsMs = await runCtags(executable, root, list, changedTags);
+            await mergeTags(previousTags, changedTags, new Set([...delta.changed, ...delta.removed]), destination);
+            return ctagsMs;
+        }
+        finally {
+            release();
+        }
+    }
+    else
+        await writeFile(changedTags, '', { encoding: 'utf8', mode: 0o600 });
+    await mergeTags(previousTags, changedTags, new Set([...delta.changed, ...delta.removed]), destination);
+    return 0;
+}
+async function mergeTags(previous, changed, replacedPaths, destination) {
+    const output = createWriteStream(destination, { encoding: 'utf8', mode: 0o600 });
+    const oldLines = tagLines(previous)[Symbol.asyncIterator]();
+    const changedLines = tagLines(changed)[Symbol.asyncIterator]();
+    const write = async (line) => {
+        if (!output.write(`${line}\n`))
+            await new Promise((resolvePromise) => output.once('drain', resolvePromise));
+    };
+    let old = await oldLines.next();
+    while (!old.done && old.value.startsWith('!_TAG_')) {
+        await write(old.value);
+        old = await oldLines.next();
+    }
+    let nextChanged = await nextDataTag(changedLines);
+    while (!old.done || nextChanged !== undefined) {
+        while (!old.done && tagPath(old.value) !== undefined && replacedPaths.has(tagPath(old.value)))
+            old = await oldLines.next();
+        if (old.done) {
+            await write(nextChanged);
+            nextChanged = await nextDataTag(changedLines);
+            continue;
+        }
+        if (nextChanged === undefined || compareTagLines(old.value, nextChanged) <= 0) {
+            await write(old.value);
+            old = await oldLines.next();
+        }
+        else {
+            await write(nextChanged);
+            nextChanged = await nextDataTag(changedLines);
+        }
+    }
+    await new Promise((resolvePromise, reject) => {
+        output.once('error', reject);
+        output.end(resolvePromise);
+    });
+}
+async function* tagLines(path) {
+    const input = createInterface({
+        input: createReadStream(path, { encoding: 'utf8' }),
+        crlfDelay: Infinity
+    });
+    for await (const line of input)
+        yield line;
+}
+async function nextDataTag(iterator) {
+    for (;;) {
+        const next = await iterator.next();
+        if (next.done)
+            return undefined;
+        if (!next.value.startsWith('!_TAG_'))
+            return next.value;
+    }
+}
+function tagPath(line) {
+    const second = line.indexOf('\t');
+    if (second < 0)
+        return undefined;
+    const third = line.indexOf('\t', second + 1);
+    return third < 0 ? undefined : line.slice(second + 1, third);
+}
+function compareTagLines(left, right) {
+    const leftName = left.slice(0, left.indexOf('\t'));
+    const rightName = right.slice(0, right.indexOf('\t'));
+    return (compareTagNames(leftName, rightName) || Buffer.compare(Buffer.from(left), Buffer.from(right)));
+}
+export async function acquireBuild() {
+    if (activeBuilds >= 1) {
+        if (buildWaiters.length >= BUILD_QUEUE_LIMIT)
+            throw new Error('SYMBOL_INDEX_BUILD_FAILED');
+        await new Promise((resolvePromise, reject) => {
+            const resume = () => {
+                clearTimeout(timer);
+                resolvePromise();
+            };
+            const timer = setTimeout(() => {
+                const index = buildWaiters.indexOf(resume);
+                if (index >= 0)
+                    buildWaiters.splice(index, 1);
+                reject(new Error('SYMBOL_INDEX_BUILD_FAILED'));
+            }, BUILD_QUEUE_TIMEOUT_MS);
+            timer.unref();
+            buildWaiters.push(resume);
+        });
+    }
+    activeBuilds += 1;
+    return () => {
+        activeBuilds -= 1;
+        buildWaiters.shift()?.();
+    };
+}
+export async function runCtags(executable, cwd, fileList, destination) {
+    const startedAt = Date.now();
+    await new Promise((resolvePromise, reject) => {
+        const child = spawn(executable, [
+            '--options=NONE',
+            '--output-format=u-ctags',
+            '--excmd=number',
+            '--sort=yes',
+            '--tag-relative=no',
+            '--pseudo-tags=-TAG_PROC_CWD',
+            '--fields=+nKS',
+            '--extras=+q',
+            '-L',
+            fileList,
+            '-f',
+            destination
+        ], {
+            cwd,
+            detached: process.platform !== 'win32',
+            windowsHide: true,
+            stdio: ['ignore', 'ignore', 'pipe']
+        });
+        let settled = false;
+        const settle = (callback) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            callback();
+        };
+        const terminate = () => {
+            if (child.pid !== undefined && process.platform !== 'win32') {
+                try {
+                    process.kill(-child.pid, 'SIGKILL');
+                    return;
+                }
+                catch {
+                    // Fall through to the direct process kill.
+                }
+            }
+            child.kill('SIGKILL');
+        };
+        const timer = setTimeout(() => {
+            terminate();
+            settle(() => reject(new Error('SYMBOL_INDEX_BUILD_FAILED')));
+        }, BUILD_TIMEOUT_MS);
+        timer.unref();
+        child.stderr.on('data', () => undefined);
+        child.once('error', () => settle(() => reject(new Error('SYMBOL_INDEX_BUILD_FAILED'))));
+        child.once('exit', (code) => settle(() => (code === 0 ? resolvePromise() : reject(new Error('SYMBOL_INDEX_BUILD_FAILED')))));
+    });
+    return Date.now() - startedAt;
+}
+export async function ensurePrivateDirectory(path) {
+    await mkdir(path, { recursive: true, mode: 0o700 });
+    const metadata = await lstat(path);
+    if (!metadata.isDirectory() || metadata.isSymbolicLink())
+        throw new Error('SYMBOL_INDEX_UNAVAILABLE');
+}
+export async function removeInactiveGenerations(directory, activeGeneration) {
+    const generations = await readdir(directory, { withFileTypes: true }).catch(() => []);
+    await Promise.all(generations
+        .filter((entry) => entry.isDirectory() &&
+        entry.name !== activeGeneration &&
+        /^[0-9a-f-]{36}(?:\.staging)?$/u.test(entry.name))
+        .map((entry) => rm(resolve(directory, entry.name), { recursive: true, force: true })));
+}
+export async function readManifest(path) {
+    try {
+        const value = JSON.parse(await readFile(path, 'utf8'));
+        const sourceFiles = validManifestSourceFiles(value.sourceFiles) ? value.sourceFiles : undefined;
+        const schemaVersion = value.schemaVersion;
+        const optionsVersion = value.optionsVersion;
+        return typeof value === 'object' &&
+            value !== null &&
+            typeof schemaVersion === 'number' &&
+            Number.isInteger(schemaVersion) &&
+            schemaVersion >= 0 &&
+            typeof optionsVersion === 'number' &&
+            Number.isInteger(optionsVersion) &&
+            optionsVersion >= 0 &&
+            typeof value.ctagsVersion === 'string' &&
+            typeof value.sourceFingerprint === 'string' &&
+            /^[a-f0-9]{64}$/u.test(value.sourceFingerprint) &&
+            typeof value.truncated === 'boolean' &&
+            typeof value.generation === 'string' &&
+            /^[0-9a-f-]{36}$/u.test(value.generation)
+            ? {
+                schemaVersion,
+                optionsVersion,
+                ctagsVersion: value.ctagsVersion,
+                sourceFingerprint: value.sourceFingerprint,
+                ...(sourceFiles === undefined ? {} : { sourceFiles }),
+                truncated: value.truncated,
+                generation: value.generation
+            }
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function validManifestSourceFiles(value) {
+    if (value === undefined)
+        return false;
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const entries = Object.entries(value);
+    return (entries.length <= 100_000 &&
+        entries.every(([path, fingerprint]) => path.length > 0 &&
+            path.length <= 4096 &&
+            !path.includes('\0') &&
+            !path.includes('\\') &&
+            !path.startsWith('/') &&
+            !path.split('/').some((part) => part.length === 0 || part === '.' || part === '..') &&
+            typeof fingerprint === 'string' &&
+            /^[0-9]+:(?:-1|[0-9]+(?:\.[0-9]+)?)$/u.test(fingerprint)));
+}
+export async function tagsPath(location, manifest) {
+    const path = resolve(location.generations, manifest.generation, 'tags');
+    if (relative(location.generations, path)
+        .split(sep)
+        .some((part) => part === '..'))
+        throw new Error('SYMBOL_INDEX_UNAVAILABLE');
+    return path;
+}
+export async function tagsAvailable(path) {
+    try {
+        const metadata = await stat(path);
+        return metadata.isFile() && metadata.size <= MAX_TAGS_BYTES;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/service/code-navigation/ctags-query.js

@@ -0,0 +1,140 @@
+const MAX_TAG_LINE_BYTES = 16 * 1024;
+const READ_BLOCK_BYTES = 4096;
+export async function firstTagOffset(handle, size, symbol) {
+    let low = 0;
+    let high = size;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        const start = await findTagLineStart(handle, middle);
+        if (start === undefined) {
+            high = middle;
+            continue;
+        }
+        const line = await readTagLine(handle, start, size);
+        if (line === undefined) {
+            high = middle;
+            continue;
+        }
+        const tag = parseTag(line.text);
+        if (tag === undefined || compareTagNames(tag.name, symbol) < 0)
+            low = line.nextOffset;
+        else
+            high = line.start;
+    }
+    return low;
+}
+async function findTagLineStart(handle, offset) {
+    let cursor = offset;
+    let scanned = 0;
+    while (cursor > 0 && scanned < MAX_TAG_LINE_BYTES) {
+        const start = Math.max(0, cursor - Math.min(READ_BLOCK_BYTES, MAX_TAG_LINE_BYTES - scanned));
+        const chunk = Buffer.alloc(cursor - start);
+        const { bytesRead } = await handle.read(chunk, 0, chunk.length, start);
+        if (bytesRead === 0)
+            return undefined;
+        const newline = chunk.subarray(0, bytesRead).lastIndexOf(0x0a);
+        if (newline >= 0)
+            return start + newline + 1;
+        cursor = start;
+        scanned += bytesRead;
+    }
+    return cursor === 0 ? 0 : undefined;
+}
+export async function readTagLine(handle, offset, size) {
+    if (offset >= size)
+        return undefined;
+    let start = offset;
+    if (start > 0) {
+        const before = Buffer.alloc(1);
+        await handle.read(before, 0, 1, start - 1);
+        if (before[0] !== 0x0a) {
+            const aligned = await findNewline(handle, start, size, MAX_TAG_LINE_BYTES);
+            if (aligned === undefined)
+                return undefined;
+            start = aligned + 1;
+        }
+    }
+    if (start >= size)
+        return undefined;
+    const bytes = [];
+    let total = 0;
+    let cursor = start;
+    while (cursor < size && total <= MAX_TAG_LINE_BYTES) {
+        const chunk = Buffer.alloc(Math.min(READ_BLOCK_BYTES, size - cursor));
+        const { bytesRead } = await handle.read(chunk, 0, chunk.length, cursor);
+        if (bytesRead === 0)
+            break;
+        const content = chunk.subarray(0, bytesRead);
+        const newline = content.indexOf(0x0a);
+        const part = newline >= 0 ? content.subarray(0, newline) : content;
+        total += part.length;
+        if (total > MAX_TAG_LINE_BYTES)
+            return undefined;
+        bytes.push(part);
+        if (newline >= 0)
+            return {
+                start,
+                nextOffset: cursor + newline + 1,
+                text: Buffer.concat(bytes, total).toString('utf8')
+            };
+        cursor += bytesRead;
+    }
+    return undefined;
+}
+async function findNewline(handle, offset, size, limit) {
+    let cursor = offset;
+    let remaining = limit;
+    while (cursor < size && remaining > 0) {
+        const chunk = Buffer.alloc(Math.min(READ_BLOCK_BYTES, size - cursor, remaining));
+        const { bytesRead } = await handle.read(chunk, 0, chunk.length, cursor);
+        if (bytesRead === 0)
+            return undefined;
+        const newline = chunk.subarray(0, bytesRead).indexOf(0x0a);
+        if (newline >= 0)
+            return cursor + newline;
+        cursor += bytesRead;
+        remaining -= bytesRead;
+    }
+    return undefined;
+}
+export function parseTag(text) {
+    if (text.length === 0 ||
+        text.startsWith('!_TAG_') ||
+        Buffer.byteLength(text) > MAX_TAG_LINE_BYTES)
+        return undefined;
+    const fields = text.split('\t');
+    if (fields.length < 3)
+        return undefined;
+    const [name, path, excmd, ...extensions] = fields;
+    if (name === undefined ||
+        path === undefined ||
+        excmd === undefined ||
+        name.length === 0 ||
+        path.length === 0 ||
+        path.startsWith('/') ||
+        path.includes('\\') ||
+        path.split('/').some((part) => part === '' || part === '.' || part === '..'))
+        return undefined;
+    const match = /^([1-9][0-9]*);?"?$/u.exec(excmd);
+    if (match === null)
+        return undefined;
+    const line = Number(match[1]);
+    if (!Number.isSafeInteger(line) || line < 1)
+        return undefined;
+    let kind;
+    let scope;
+    for (const extension of extensions) {
+        if (extension.length === 1)
+            kind ??= extension;
+        else if (extension.startsWith('kind:'))
+            kind ??= extension.slice('kind:'.length);
+        else if (extension.startsWith('scope:') ||
+            extension.startsWith('class:') ||
+            extension.startsWith('namespace:'))
+            scope ??= extension.slice(extension.indexOf(':') + 1);
+    }
+    return { name, path, line, kind, scope };
+}
+export function compareTagNames(left, right) {
+    return Buffer.compare(Buffer.from(left, 'utf8'), Buffer.from(right, 'utf8'));
+}

package/dist/service/code-navigation/ecmascript-path-specifier-resolver.js

@@ -0,0 +1,100 @@
+import { posix } from 'node:path';
+import { trailingPathCandidateScore } from './path-specifier-resolver.js';
+const importExtensionMappings = [
+    { importExtension: '.js', sourceExtensions: ['.ts', '.tsx'] },
+    { importExtension: '.jsx', sourceExtensions: ['.tsx'] },
+    { importExtension: '.mjs', sourceExtensions: ['.mts'] },
+    { importExtension: '.cjs', sourceExtensions: ['.cts'] }
+];
+const extensionlessSourceExtensions = ['.ts', '.tsx', '.js', '.jsx'];
+function accepts(value) {
+    return (/^(?:\.\.?\/)[A-Za-z0-9_./$-]+$/u.test(value) ||
+        /^@\/[A-Za-z0-9_./$-]+$/u.test(value) ||
+        /^(?:@?[A-Za-z0-9_$-]+)(?:\/[A-Za-z0-9_.$-]+)+$/u.test(value));
+}
+function matches(path, currentPath, specifier) {
+    if (!specifier.startsWith('.'))
+        return unresolvedSpecifierScore(path, specifier) !== undefined;
+    const resolved = resolveRelative(currentPath, specifier);
+    return (resolved !== undefined &&
+        candidates(resolved).some((candidate) => path === candidate ||
+            path === `${candidate}/index.ts` ||
+            path === `${candidate}/index.tsx` ||
+            path === `${candidate}/index.js` ||
+            path === `${candidate}/index.jsx`));
+}
+function score(path, currentPath, specifier) {
+    if (!specifier.startsWith('.'))
+        return unresolvedSpecifierScore(path, specifier) ?? Number.MAX_SAFE_INTEGER;
+    const resolved = resolveRelative(currentPath, specifier);
+    if (resolved === undefined)
+        return Number.MAX_SAFE_INTEGER;
+    const resolvedCandidates = candidates(resolved);
+    const exact = resolvedCandidates.indexOf(path);
+    if (exact >= 0)
+        return exact;
+    const index = resolvedCandidates.findIndex((candidate) => path === `${candidate}/index.ts` ||
+        path === `${candidate}/index.tsx` ||
+        path === `${candidate}/index.js` ||
+        path === `${candidate}/index.jsx`);
+    return index >= 0 ? resolvedCandidates.length + index : Number.MAX_SAFE_INTEGER;
+}
+function directCandidates(currentPath, specifier) {
+    if (!specifier.startsWith('.'))
+        return [];
+    const resolved = resolveRelative(currentPath, specifier);
+    if (resolved === undefined)
+        return [];
+    const resolvedCandidates = candidates(resolved);
+    return resolvedCandidates.flatMap((candidate) => [
+        candidate,
+        `${candidate}/index.ts`,
+        `${candidate}/index.tsx`,
+        `${candidate}/index.js`,
+        `${candidate}/index.jsx`
+    ]);
+}
+function resolveRelative(currentPath, specifier) {
+    const resolved = posix.normalize(posix.join(posix.dirname(currentPath), specifier));
+    if (resolved.startsWith('../') || resolved === '..')
+        return undefined;
+    return resolved.replace(/^\.\//u, '');
+}
+function candidates(path) {
+    const mapping = importExtensionMappings.find(({ importExtension }) => path.toLowerCase().endsWith(importExtension));
+    if (mapping !== undefined) {
+        const sourceBase = path.slice(0, -mapping.importExtension.length);
+        return [path, ...mapping.sourceExtensions.map((extension) => `${sourceBase}${extension}`)];
+    }
+    return path.slice(path.lastIndexOf('/') + 1).includes('.')
+        ? [path]
+        : [path, ...extensionlessSourceExtensions.map((extension) => `${path}${extension}`)];
+}
+function sourceFileStem(path) {
+    const name = path.slice(path.lastIndexOf('/') + 1);
+    return name.replace(/(?:\.d)?\.[^.]+$/u, '');
+}
+function unresolvedSpecifierScore(path, specifier) {
+    const normalizedSpecifier = specifier.startsWith('@/') ? specifier.slice(2) : specifier;
+    return trailingPathCandidateScore(path, unresolvedCandidates(normalizedSpecifier));
+}
+function unresolvedCandidates(specifier) {
+    return candidates(specifier).flatMap((candidate) => [
+        candidate,
+        `${candidate}/index.ts`,
+        `${candidate}/index.tsx`,
+        `${candidate}/index.js`,
+        `${candidate}/index.jsx`
+    ]);
+}
+export const ecmascriptPathSpecifierResolver = {
+    id: 'ecmascript.path-specifier',
+    accepts,
+    directCandidates,
+    matches,
+    score
+};
+export const ecmascriptNavigationResolutionDefinition = {
+    languageId: 'ecmascript',
+    resolver: ecmascriptPathSpecifierResolver
+};

package/dist/service/code-navigation/file-reference-parser.js

@@ -0,0 +1,28 @@
+import { fileSpecifierParser } from '@myagentroam/code-navigation';
+const MAX_REFERENCE_REPARSE_POSITIONS = 8;
+export function reparseFileReference(path, requested) {
+    const parser = fileSpecifierParser(path, requested.sourceContext.text);
+    if (parser === undefined)
+        return undefined;
+    for (const position of referenceCandidatePositions(requested)) {
+        const parsed = parser.find(requested.sourceContext.text, position);
+        if (parsed?.value === requested.value && parsed.anchor === requested.anchor)
+            return parsed;
+    }
+    return undefined;
+}
+export function referenceCandidatePositions(requested) {
+    const source = requested.sourceContext.text;
+    const requestedPosition = requested.sourceContext.position;
+    const positions = new Set([requestedPosition, requested.from, requested.to - 1]);
+    const matches = [];
+    for (let offset = source.indexOf(requested.value); offset >= 0;) {
+        matches.push(offset);
+        offset = source.indexOf(requested.value, offset + Math.max(1, requested.value.length));
+    }
+    matches
+        .sort((left, right) => Math.abs(left - requestedPosition) - Math.abs(right - requestedPosition) || left - right)
+        .slice(0, MAX_REFERENCE_REPARSE_POSITIONS - positions.size)
+        .forEach((position) => positions.add(position));
+    return [...positions].filter((position) => position >= 0 && position < source.length);
+}

package/dist/service/code-navigation/go-path-specifier-resolver.js

@@ -0,0 +1,31 @@
+import { matchesPathSuffix } from './path-specifier-resolver.js';
+function accepts(value) {
+    return /^(?:[A-Za-z0-9][A-Za-z0-9._-]*)(?:\/[A-Za-z0-9][A-Za-z0-9._-]*)+$/u.test(value);
+}
+function matches(path, _currentPath, specifier) {
+    if (!path.endsWith('.go'))
+        return false;
+    const directory = path.slice(0, path.lastIndexOf('/'));
+    return packageSuffixes(specifier).some((suffix) => matchesPathSuffix(directory, suffix));
+}
+function score(path, _currentPath, specifier) {
+    const directory = path.slice(0, path.lastIndexOf('/'));
+    const index = packageSuffixes(specifier).findIndex((suffix) => matchesPathSuffix(directory, suffix));
+    return index < 0 ? Number.MAX_SAFE_INTEGER : index * 10_000 + path.length;
+}
+function packageSuffixes(specifier) {
+    const segments = specifier.split('/');
+    return segments.length < 2
+        ? []
+        : segments.slice(0, -1).map((_, index) => segments.slice(index).join('/'));
+}
+export const goPathSpecifierResolver = {
+    id: 'go.path-specifier',
+    accepts,
+    matches,
+    score
+};
+export const goNavigationResolutionDefinition = {
+    languageId: 'go',
+    resolver: goPathSpecifierResolver
+};