@myagentroam/node 0.9.97 → 0.9.98

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

@@ -0,0 +1,28 @@
+import { matchesPathSuffix } from './path-specifier-resolver.js';
+function accepts(value) {
+    return /^[\p{L}_$][\p{L}\p{N}_$]*(?:\.[\p{L}_$][\p{L}\p{N}_$]*)+$/u.test(value);
+}
+function matches(path, _currentPath, specifier) {
+    return candidates(specifier).some((candidate) => matchesPathSuffix(path, candidate));
+}
+function score(path, _currentPath, specifier) {
+    const exact = candidates(specifier).findIndex((candidate) => matchesPathSuffix(path, candidate));
+    return exact < 0 ? Number.MAX_SAFE_INTEGER : exact * 10_000 + path.length;
+}
+function candidates(specifier) {
+    const segments = specifier.split('.');
+    return segments.flatMap((_, index) => {
+        const value = segments.slice(0, segments.length - index).join('/');
+        return ['.java', '.kt', '.kts'].map((suffix) => `${value}${suffix}`);
+    });
+}
+export const jvmPathSpecifierResolver = {
+    id: 'jvm.path-specifier',
+    accepts,
+    matches,
+    score
+};
+export const jvmNavigationResolutionDefinition = {
+    languageId: 'jvm',
+    resolver: jvmPathSpecifierResolver
+};

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

@@ -0,0 +1,80 @@
+import { posix } from 'node:path';
+function accepts(value) {
+    return value === '.' || /^(?:\.\.?\/)?[A-Za-z0-9_./$+ -]+$/u.test(value);
+}
+function matches(path, currentPath, specifier) {
+    return candidates(currentPath, specifier).includes(path);
+}
+function score(path, currentPath, specifier) {
+    const index = candidates(currentPath, specifier).indexOf(path);
+    return index >= 0 ? index : Number.MAX_SAFE_INTEGER;
+}
+function candidates(currentPath, specifier) {
+    if (specifier === '.')
+        return [currentPath];
+    const resolved = posix.normalize(posix.join(posix.dirname(currentPath), specifier));
+    if (resolved === '..' || resolved.startsWith('../'))
+        return [];
+    const path = resolved.replace(/^\.\//u, '');
+    return path.includes('.')
+        ? [path]
+        : [path, `${path}.md`, `${path}.markdown`, `${path}/README.md`, `${path}/readme.md`];
+}
+export function markdownAnchorLine(source, anchor) {
+    const requested = markdownAnchorSlug(anchor);
+    if (requested === '')
+        return undefined;
+    const counts = new Map();
+    const lines = source.split(/\r?\n/u);
+    for (let index = 0; index < lines.length; index += 1) {
+        const heading = markdownHeading(lines, index);
+        if (heading === undefined)
+            continue;
+        const base = markdownAnchorSlug(heading.text);
+        if (base === '')
+            continue;
+        const count = counts.get(base) ?? 0;
+        counts.set(base, count + 1);
+        const slug = count === 0 ? base : `${base}-${count}`;
+        if (slug === requested)
+            return heading.line;
+    }
+    return undefined;
+}
+function markdownHeading(lines, index) {
+    const atx = /^[ \t]{0,3}#{1,6}[ \t]+(.+?)[ \t]*#*[ \t]*$/u.exec(lines[index] ?? '');
+    if (atx !== null)
+        return { text: atx[1], line: index + 1 };
+    const underline = /^[ \t]{0,3}(?:=+|-+)[ \t]*$/u.test(lines[index + 1] ?? '');
+    return underline && (lines[index] ?? '').trim().length > 0
+        ? { text: lines[index], line: index + 1 }
+        : undefined;
+}
+function markdownAnchorSlug(value) {
+    return decodeURIComponentSafe(value)
+        .trim()
+        .toLowerCase()
+        .replace(/[`*_~[\]()]/gu, '')
+        .replace(/[^\p{L}\p{N}_ -]/gu, '')
+        .replace(/[\s-]+/gu, '-');
+}
+function decodeURIComponentSafe(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
+export const markdownPathSpecifierResolver = {
+    id: 'markdown.path-specifier',
+    accepts,
+    directCandidates: candidates,
+    matches,
+    score,
+    anchorLine: markdownAnchorLine
+};
+export const markdownNavigationResolutionDefinition = {
+    languageId: 'markdown',
+    resolver: markdownPathSpecifierResolver
+};

package/dist/service/code-navigation/navigation-resolution-definition.js

@@ -0,0 +1 @@
+export {};

package/dist/service/code-navigation/navigation-resolution-registry.js

@@ -0,0 +1,36 @@
+import { cFamilyNavigationResolutionDefinition, cNavigationResolutionDefinition, cppNavigationResolutionDefinition, objectiveCNavigationResolutionDefinition, objectiveCppNavigationResolutionDefinition } from './c-family-path-specifier-resolver.js';
+import { csharpNavigationResolutionDefinition } from './csharp-path-specifier-resolver.js';
+import { ecmascriptNavigationResolutionDefinition } from './ecmascript-path-specifier-resolver.js';
+import { goNavigationResolutionDefinition } from './go-path-specifier-resolver.js';
+import { jvmNavigationResolutionDefinition } from './jvm-path-specifier-resolver.js';
+import { markdownNavigationResolutionDefinition } from './markdown-path-specifier-resolver.js';
+import { pythonNavigationResolutionDefinition } from './python-path-specifier-resolver.js';
+import { rustNavigationResolutionDefinition } from './rust-path-specifier-resolver.js';
+import { cssNavigationResolutionDefinition, htmlNavigationResolutionDefinition, lessNavigationResolutionDefinition, sassNavigationResolutionDefinition, scssNavigationResolutionDefinition, vueNavigationResolutionDefinition } from './stylesheet-path-specifier-resolver.js';
+const definitionsByLanguage = {
+    css: cssNavigationResolutionDefinition,
+    ecmascript: ecmascriptNavigationResolutionDefinition,
+    go: goNavigationResolutionDefinition,
+    html: htmlNavigationResolutionDefinition,
+    jvm: jvmNavigationResolutionDefinition,
+    csharp: csharpNavigationResolutionDefinition,
+    less: lessNavigationResolutionDefinition,
+    markdown: markdownNavigationResolutionDefinition,
+    python: pythonNavigationResolutionDefinition,
+    sass: sassNavigationResolutionDefinition,
+    scss: scssNavigationResolutionDefinition,
+    c: cNavigationResolutionDefinition,
+    cpp: cppNavigationResolutionDefinition,
+    'objective-c': objectiveCNavigationResolutionDefinition,
+    'objective-cpp': objectiveCppNavigationResolutionDefinition,
+    'c-family': cFamilyNavigationResolutionDefinition,
+    rust: rustNavigationResolutionDefinition,
+    vue: vueNavigationResolutionDefinition
+};
+export function navigationResolutionDefinitions() {
+    return Object.values(definitionsByLanguage);
+}
+export function pathSpecifierResolver(languageId, specifier) {
+    const definition = definitionsByLanguage[languageId];
+    return definition?.resolver.accepts(specifier) === true ? definition.resolver : undefined;
+}

package/dist/service/code-navigation/navigation-target-validator.js

@@ -0,0 +1,121 @@
+import { lstat, open, readFile, realpath } from 'node:fs/promises';
+import { relative, resolve, sep } from 'node:path';
+const MAX_SOURCE_BYTES = 4 * 1024 * 1024;
+const READ_BLOCK_BYTES = 4096;
+const MAX_TARGET_PREVIEW_CHARACTERS = 512;
+export function sourceFileFingerprint(size, modifiedAt) {
+    return `${size}:${modifiedAt ?? -1}`;
+}
+export async function validateSymbolTarget(root, target, symbol, expectedFingerprint) {
+    const actual = await validatedFile(root, target.path, expectedFingerprint);
+    if (actual === undefined)
+        return undefined;
+    const line = await lineAt(actual, target.line);
+    return line !== undefined && containsSymbol(line, symbol) ? targetPreview(line) : undefined;
+}
+export async function validatePathTarget(root, path, expectedFingerprint, anchor, anchorLine) {
+    const actual = await validatedFile(root, path, expectedFingerprint);
+    if (actual === undefined)
+        return undefined;
+    const line = anchor === undefined || anchorLine === undefined
+        ? 1
+        : anchorLine(await readFile(actual, 'utf8').catch(() => ''), anchor);
+    if (line === undefined)
+        return undefined;
+    const preview = await lineAt(actual, line);
+    return preview === undefined ? undefined : { line, preview };
+}
+async function validatedFile(root, path, expectedFingerprint) {
+    const requested = resolve(root, ...path.split('/'));
+    const requestedMetadata = await lstat(requested).catch(() => undefined);
+    if (requestedMetadata === undefined ||
+        !requestedMetadata.isFile() ||
+        requestedMetadata.isSymbolicLink() ||
+        requestedMetadata.size > MAX_SOURCE_BYTES)
+        return undefined;
+    const actual = await realpath(requested).catch(() => undefined);
+    if (actual === undefined ||
+        relative(root, actual)
+            .split(sep)
+            .some((part) => part === '..'))
+        return undefined;
+    const metadata = await lstat(actual).catch(() => undefined);
+    if (metadata === undefined ||
+        !metadata.isFile() ||
+        metadata.isSymbolicLink() ||
+        metadata.size > MAX_SOURCE_BYTES ||
+        (expectedFingerprint !== undefined &&
+            sourceFileFingerprint(metadata.size, metadata.mtimeMs) !== expectedFingerprint))
+        return undefined;
+    return actual;
+}
+export function targetPreview(line) {
+    if (line.length <= MAX_TARGET_PREVIEW_CHARACTERS)
+        return line;
+    const contentLimit = MAX_TARGET_PREVIEW_CHARACTERS - 1;
+    const end = line.charCodeAt(contentLimit - 1);
+    const safeEnd = end >= 0xd800 && end <= 0xdbff ? contentLimit - 1 : contentLimit;
+    return `${line.slice(0, safeEnd)}…`;
+}
+async function lineAt(path, targetLine) {
+    const handle = await open(path, 'r');
+    try {
+        let offset = 0;
+        let line = 1;
+        let pending = Buffer.alloc(0);
+        while (offset < MAX_SOURCE_BYTES) {
+            const chunk = Buffer.alloc(READ_BLOCK_BYTES);
+            const { bytesRead } = await handle.read(chunk, 0, chunk.length, offset);
+            if (bytesRead === 0)
+                return line === targetLine ? pending.toString('utf8') : undefined;
+            offset += bytesRead;
+            let content = pending.length === 0
+                ? chunk.subarray(0, bytesRead)
+                : Buffer.concat([pending, chunk.subarray(0, bytesRead)]);
+            let newline;
+            while ((newline = content.indexOf(0x0a)) >= 0) {
+                if (line === targetLine)
+                    return content.subarray(0, newline).toString('utf8');
+                line += 1;
+                content = content.subarray(newline + 1);
+            }
+            pending = content;
+        }
+        return line === targetLine ? pending.toString('utf8') : undefined;
+    }
+    finally {
+        await handle.close();
+    }
+}
+export function containsSymbol(line, symbol) {
+    const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+    const optionalScssPrefix = symbol.startsWith('$') ? '' : '\\$?';
+    return new RegExp(`(?:^|[^\\p{L}\\p{N}_$])${optionalScssPrefix}${escaped}(?![\\p{L}\\p{N}_$])`, 'u').test(line);
+}
+export function compareTargets(left, right, currentPath) {
+    const leftScore = targetScore(left, currentPath);
+    const rightScore = targetScore(right, currentPath);
+    return (rightScore - leftScore ||
+        left.path.localeCompare(right.path) ||
+        left.line - right.line ||
+        (left.kind ?? '').localeCompare(right.kind ?? ''));
+}
+function targetScore(target, currentPath) {
+    if (target.path === currentPath)
+        return 100;
+    const currentDirectory = currentPath.includes('/')
+        ? currentPath.slice(0, currentPath.lastIndexOf('/'))
+        : '';
+    const targetDirectory = target.path.includes('/')
+        ? target.path.slice(0, target.path.lastIndexOf('/'))
+        : '';
+    return commonPathSegments(currentDirectory, targetDirectory);
+}
+function commonPathSegments(left, right) {
+    const leftParts = left === '' ? [] : left.split('/');
+    const rightParts = right === '' ? [] : right.split('/');
+    let count = 0;
+    while (count < leftParts.length && leftParts[count] === rightParts[count])
+        count += 1;
+    return count;
+}

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

@@ -0,0 +1,6 @@
+export function matchesPathSuffix(path, suffix) {
+    return path === suffix || path.endsWith(`/${suffix}`);
+}
+export function shortestPathScore(path) {
+    return path.length;
+}

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

@@ -0,0 +1,41 @@
+import { matchesPathSuffix, shortestPathScore } from './path-specifier-resolver.js';
+import { posix } from 'node:path';
+function accepts(value) {
+    return (/^[\p{L}_$][\p{L}\p{N}_$]*(?:\.[\p{L}_$][\p{L}\p{N}_$]*)*$/u.test(value) ||
+        /^\.+(?:[\p{L}_$][\p{L}\p{N}_$]*(?:\.[\p{L}_$][\p{L}\p{N}_$]*)*)?$/u.test(value));
+}
+function matches(path, currentPath, specifier) {
+    return candidates(currentPath, specifier).some((candidate) => matchesPathSuffix(path, candidate));
+}
+function directCandidates(currentPath, specifier) {
+    return specifier.startsWith('.') ? candidates(currentPath, specifier) : [];
+}
+function candidates(currentPath, specifier) {
+    const packagePath = relativePackagePath(currentPath, specifier);
+    if (packagePath === undefined)
+        return [];
+    return packagePath === '.'
+        ? ['__init__.py']
+        : [`${packagePath}.py`, `${packagePath}.pyw`, `${packagePath}/__init__.py`];
+}
+function relativePackagePath(currentPath, specifier) {
+    if (!specifier.startsWith('.'))
+        return specifier.replaceAll('.', '/');
+    const levels = specifier.match(/^\.+/u)?.[0].length ?? 0;
+    const module = specifier.slice(levels).replaceAll('.', '/');
+    const base = posix.normalize(posix.join(posix.dirname(currentPath), ...Array.from({ length: levels - 1 }, () => '..')));
+    if (base === '..' || base.startsWith('../'))
+        return undefined;
+    return module.length === 0 ? base : posix.join(base, module);
+}
+export const pythonPathSpecifierResolver = {
+    id: 'python.path-specifier',
+    accepts,
+    directCandidates,
+    matches,
+    score: shortestPathScore
+};
+export const pythonNavigationResolutionDefinition = {
+    languageId: 'python',
+    resolver: pythonPathSpecifierResolver
+};

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

@@ -0,0 +1,31 @@
+import { posix } from 'node:path';
+function accepts(value) {
+    return (/^[A-Za-z_][A-Za-z0-9_]*$/u.test(value) || /^(?:\.\.?\/)?[A-Za-z0-9_./-]+\.rs$/u.test(value));
+}
+function matches(path, currentPath, specifier) {
+    return candidates(currentPath, specifier).includes(path);
+}
+function score(path, currentPath, specifier) {
+    const index = candidates(currentPath, specifier).indexOf(path);
+    return index >= 0 ? index : Number.MAX_SAFE_INTEGER;
+}
+function candidates(currentPath, specifier) {
+    const directory = posix.dirname(currentPath);
+    if (specifier.endsWith('.rs')) {
+        const resolved = posix.normalize(posix.join(directory, specifier));
+        return resolved.startsWith('../') || resolved === '..' ? [] : [resolved];
+    }
+    const base = directory === '.' ? specifier : `${directory}/${specifier}`;
+    return [`${base}.rs`, `${base}/mod.rs`];
+}
+export const rustPathSpecifierResolver = {
+    id: 'rust.path-specifier',
+    accepts,
+    directCandidates: candidates,
+    matches,
+    score
+};
+export const rustNavigationResolutionDefinition = {
+    languageId: 'rust',
+    resolver: rustPathSpecifierResolver
+};

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

@@ -0,0 +1,55 @@
+import { posix } from 'node:path';
+function accepts(value) {
+    return /^(?:\.\.?\/)?[A-Za-z0-9_./$+@ -]+$/u.test(value);
+}
+function createResolver(languageId, extensions, partials = false) {
+    const candidates = (currentPath, specifier) => pathCandidates(currentPath, specifier, extensions, partials);
+    return {
+        id: `${languageId}.path-specifier`,
+        accepts,
+        directCandidates: candidates,
+        matches: (path, currentPath, specifier) => candidates(currentPath, specifier).includes(path),
+        score: (path, currentPath, specifier) => {
+            const index = candidates(currentPath, specifier).indexOf(path);
+            return index >= 0 ? index : Number.MAX_SAFE_INTEGER;
+        }
+    };
+}
+function pathCandidates(currentPath, specifier, extensions, partials) {
+    const resolved = posix.normalize(posix.join(posix.dirname(currentPath), specifier));
+    if (resolved === '..' || resolved.startsWith('../'))
+        return [];
+    const path = resolved.replace(/^\.\//u, '');
+    if (path.slice(path.lastIndexOf('/') + 1).includes('.'))
+        return [path];
+    const base = extensions.flatMap((extension) => [
+        `${path}${extension}`,
+        `${path}/index${extension}`
+    ]);
+    if (!partials)
+        return base;
+    const directory = posix.dirname(path);
+    const name = path.slice(path.lastIndexOf('/') + 1);
+    return [...base, ...extensions.map((extension) => posix.join(directory, `_${name}${extension}`))];
+}
+function definition(languageId, extensions, partials = false) {
+    return { languageId, resolver: createResolver(languageId, extensions, partials) };
+}
+export const cssNavigationResolutionDefinition = definition('css', ['.css']);
+export const scssNavigationResolutionDefinition = definition('scss', ['.scss', '.css'], true);
+export const sassNavigationResolutionDefinition = definition('sass', ['.sass', '.scss', '.css'], true);
+export const lessNavigationResolutionDefinition = definition('less', ['.less', '.css']);
+export const htmlNavigationResolutionDefinition = definition('html', [
+    '.html',
+    '.htm',
+    '.css',
+    '.js'
+]);
+export const vueNavigationResolutionDefinition = definition('vue', [
+    '.vue',
+    '.html',
+    '.css',
+    '.scss',
+    '.sass',
+    '.less'
+]);