@octocodeai/octocode-engine 16.5.0

package/dist/lsp/client.js

@@ -0,0 +1,98 @@
+import { promises as fs } from 'node:fs';
+import { nativeBinding } from './native.js';
+export class LSPClient {
+    nativeClient;
+    initialized = false;
+    constructor(config) {
+        this.nativeClient = new nativeBinding.NativeLspClient({
+            command: config.command,
+            args: config.args,
+            workspaceRoot: config.workspaceRoot,
+            languageId: config.languageId,
+            initializationOptions: config.initializationOptions,
+            env: config.env,
+        });
+    }
+    async start() {
+        await this.nativeClient.start();
+        this.initialized = true;
+    }
+    async stop() {
+        await this.nativeClient.stop();
+        this.initialized = false;
+    }
+    async waitForReady(timeoutMs = 45_000) {
+        await this.nativeClient.waitForReady(timeoutMs);
+    }
+    async gotoDefinition(filePath, position, content) {
+        return this.getDefinition(filePath, position, content);
+    }
+    async getDefinition(filePath, position, content) {
+        await this.openDocument(filePath, content);
+        return (await this.nativeClient.getDefinition(filePath, position.line, position.character));
+    }
+    async findReferences(filePath, position, includeDeclaration = true, content) {
+        await this.openDocument(filePath, content);
+        return (await this.nativeClient.getReferences(filePath, position.line, position.character, includeDeclaration));
+    }
+    async getHover(filePath, position, content) {
+        await this.openDocument(filePath, content);
+        return this.nativeClient.getHover(filePath, position.line, position.character);
+    }
+    async hover(filePath, position, content) {
+        return this.getHover(filePath, position, content);
+    }
+    async getTypeDefinition(filePath, position, content) {
+        await this.openDocument(filePath, content);
+        return (await this.nativeClient.getTypeDefinition(filePath, position.line, position.character));
+    }
+    async typeDefinition(filePath, position, content) {
+        return this.getTypeDefinition(filePath, position, content);
+    }
+    async getImplementation(filePath, position, content) {
+        await this.openDocument(filePath, content);
+        return (await this.nativeClient.getImplementation(filePath, position.line, position.character));
+    }
+    async implementation(filePath, position, content) {
+        return this.getImplementation(filePath, position, content);
+    }
+    async getDocumentSymbols(filePath, content) {
+        await this.openDocument(filePath, content);
+        return this.nativeClient.getDocumentSymbols(filePath);
+    }
+    async documentSymbols(filePath, content) {
+        return this.getDocumentSymbols(filePath, content);
+    }
+    async prepareCallHierarchy(filePath, position, content) {
+        await this.openDocument(filePath, content);
+        const result = await this.nativeClient.prepareCallHierarchy(filePath, position.line, position.character);
+        return Array.isArray(result) ? result : [];
+    }
+    async getIncomingCalls(item) {
+        const result = await this.nativeClient.incomingCalls(item);
+        return Array.isArray(result) ? result : [];
+    }
+    async getOutgoingCalls(item) {
+        const result = await this.nativeClient.outgoingCalls(item);
+        return Array.isArray(result) ? result : [];
+    }
+    hasCapability(_capability) {
+        return (this.initialized &&
+            (this.nativeClient.hasCapability?.(_capability) ?? true));
+    }
+    getRecentStderr() {
+        return this.nativeClient.getRecentStderr?.() ?? [];
+    }
+    async openDocument(filePath, content) {
+        await this.ensureDocumentSynced(filePath, content ?? (await fs.readFile(filePath, 'utf8')));
+    }
+    async ensureDocumentSynced(filePath, content) {
+        await this.nativeClient.openDocument(filePath, content ?? (await fs.readFile(filePath, 'utf8')));
+    }
+    async closeDocument(filePath) {
+        // Drives the native `textDocument/didClose` and clears the document's
+        // version state, so a later openDocument starts a fresh didOpen. A no-op
+        // here leaves the server holding stale in-memory documents forever.
+        await this.nativeClient.closeDocument?.(filePath);
+    }
+}

package/dist/lsp/config.d.ts

@@ -0,0 +1,3 @@
+import type { LanguageServerConfig } from './types.js';
+export declare function detectLanguageId(filePath: string): string;
+export declare function getLanguageServerForFile(filePath: string, workspaceRoot?: string): Promise<LanguageServerConfig | null>;

package/dist/lsp/config.js

@@ -0,0 +1,7 @@
+import { nativeBinding } from './native.js';
+export function detectLanguageId(filePath) {
+    return nativeBinding.detectLanguageId(filePath) ?? 'plaintext';
+}
+export async function getLanguageServerForFile(filePath, workspaceRoot = process.cwd()) {
+    return (nativeBinding.getLanguageServerForFile(filePath, workspaceRoot) ?? null);
+}

package/dist/lsp/evidence.d.ts

@@ -0,0 +1,4 @@
+export declare function attachLspEvidence<T>(result: T, opts: {
+    kind: 'calls' | 'references';
+    paginationKey: 'pagination' | 'outputPagination';
+}): T;

package/dist/lsp/evidence.js

@@ -0,0 +1,28 @@
+export function attachLspEvidence(result, opts) {
+    const status = result.status;
+    if (status !== undefined && status !== 'empty')
+        return result;
+    const hasResults = status === undefined;
+    const pagination = result[opts.paginationKey];
+    const paginationHasMore = pagination?.hasMore ?? false;
+    const reasons = [];
+    if (!hasResults) {
+        reasons.push(opts.kind === 'references'
+            ? 'No references were resolved for the supplied symbol and line hint.'
+            : 'No calls were resolved for the supplied symbol and line hint.');
+    }
+    if (paginationHasMore) {
+        reasons.push(opts.paginationKey === 'pagination'
+            ? 'LSP result pagination has more results.'
+            : 'LSP output pagination has more data.');
+    }
+    const evidence = {
+        kind: opts.kind,
+        answerReady: hasResults,
+        complete: hasResults && !paginationHasMore,
+        confidence: 'high',
+        ...(reasons.length > 0 ? { reason: reasons.join(' ') } : {}),
+    };
+    result.evidence = evidence;
+    return result;
+}

package/dist/lsp/index.d.ts

@@ -0,0 +1,7 @@
+export { LSPClient } from './client.js';
+export { detectLanguageId, getLanguageServerForFile } from './config.js';
+export { acquirePooledClient, getLspStatus, isLanguageServerAvailable, LSP_UNAVAILABLE_HINT, pooledClientCount, releaseAllPooledClients, releasePooledClientForFile, type LspStatusInput, type LspStatusResult, } from './manager.js';
+export { SymbolResolver } from './resolver.js';
+export { safeReadFile, validateLSPServerPath } from './validation.js';
+export { resolveWorkspaceRootForFile } from './workspaceRoot.js';
+export type { CallHierarchyItem, CodeSnippet, ExactPosition, FuzzyPosition, IncomingCall, InitializationOptions, LanguageServerCommand, LanguageServerConfig, LSPPaginationInfo, LSPRange, OutgoingCall, ReferenceLocation, ReferencesByFile, SymbolKind, UserLanguageServerConfig, } from './types.js';

package/dist/lsp/index.js

@@ -0,0 +1,6 @@
+export { LSPClient } from './client.js';
+export { detectLanguageId, getLanguageServerForFile } from './config.js';
+export { acquirePooledClient, getLspStatus, isLanguageServerAvailable, LSP_UNAVAILABLE_HINT, pooledClientCount, releaseAllPooledClients, releasePooledClientForFile, } from './manager.js';
+export { SymbolResolver } from './resolver.js';
+export { safeReadFile, validateLSPServerPath } from './validation.js';
+export { resolveWorkspaceRootForFile } from './workspaceRoot.js';

package/dist/lsp/initConstants.d.ts

@@ -0,0 +1,4 @@
+export declare const CLIENT_NAME = "octocode-engine";
+export declare const CLIENT_VERSION: string;
+export declare const TSSERVER_LANGUAGE_IDS: Set<string>;
+export declare const TSSERVER_DEFAULT_OPTIONS: Record<string, unknown>;

package/dist/lsp/initConstants.js

@@ -0,0 +1,27 @@
+export const CLIENT_NAME = 'octocode-engine';
+export const CLIENT_VERSION = resolveClientVersion();
+function resolveClientVersion() {
+    try {
+        const pkg = require('../../package.json');
+        return pkg.version ?? '0.0.0-dev';
+    }
+    catch {
+        return '0.0.0-dev';
+    }
+}
+export const TSSERVER_LANGUAGE_IDS = new Set([
+    'typescript',
+    'typescriptreact',
+    'javascript',
+    'javascriptreact',
+]);
+export const TSSERVER_DEFAULT_OPTIONS = {
+    tsserver: {
+        maxTsServerMemory: 2048,
+        useSyntaxServer: 'auto',
+        disableAutomaticTypeAcquisition: true,
+    },
+    preferences: {
+        includePackageJsonAutoImports: 'off',
+    },
+};

package/dist/lsp/lspClientPool.d.ts

@@ -0,0 +1,27 @@
+export interface PoolKey {
+    workspaceRoot: string;
+    filePath: string;
+    languageId: string;
+    serverId?: string;
+}
+interface PooledClient {
+    stop(): Promise<void>;
+}
+interface LspClientPoolOptions<T extends PooledClient> {
+    idleTimeoutMs: number;
+    factory: (key: PoolKey) => Promise<T | null>;
+}
+export declare class LspClientPool<T extends PooledClient> {
+    private readonly options;
+    private readonly entries;
+    private readonly inflight;
+    constructor(options: LspClientPoolOptions<T>);
+    acquire(key: PoolKey): Promise<T | null>;
+    clear(key: PoolKey): Promise<void>;
+    clearAll(): Promise<void>;
+    size(): number;
+    keys(): PoolKey[];
+    private resetIdleTimer;
+    private startIdleTimer;
+}
+export {};

package/dist/lsp/lspClientPool.js

@@ -0,0 +1,87 @@
+export class LspClientPool {
+    options;
+    entries = new Map();
+    inflight = new Map();
+    constructor(options) {
+        this.options = options;
+    }
+    async acquire(key) {
+        const k = serializeKey(key);
+        const cached = this.entries.get(k);
+        if (cached) {
+            this.resetIdleTimer(k);
+            return cached.client;
+        }
+        const inflight = this.inflight.get(k);
+        if (inflight)
+            return inflight;
+        const promise = (async () => {
+            try {
+                const client = await this.options.factory(key);
+                if (!client)
+                    return null;
+                const timer = this.startIdleTimer(k);
+                this.entries.set(k, { client, timer, key });
+                return client;
+            }
+            finally {
+                this.inflight.delete(k);
+            }
+        })();
+        this.inflight.set(k, promise);
+        return promise;
+    }
+    async clear(key) {
+        const k = serializeKey(key);
+        const entry = this.entries.get(k);
+        if (!entry)
+            return;
+        clearTimeout(entry.timer);
+        this.entries.delete(k);
+        await safeStop(entry.client);
+    }
+    async clearAll() {
+        const all = [...this.entries.values()];
+        for (const entry of all)
+            clearTimeout(entry.timer);
+        this.entries.clear();
+        await Promise.all(all.map(e => safeStop(e.client)));
+    }
+    size() {
+        return this.entries.size;
+    }
+    keys() {
+        return [...this.entries.values()].map(entry => entry.key);
+    }
+    resetIdleTimer(k) {
+        const entry = this.entries.get(k);
+        if (!entry)
+            return;
+        clearTimeout(entry.timer);
+        entry.timer = this.startIdleTimer(k);
+    }
+    startIdleTimer(k) {
+        const timer = setTimeout(() => {
+            const entry = this.entries.get(k);
+            if (!entry)
+                return;
+            this.entries.delete(k);
+            void safeStop(entry.client);
+        }, this.options.idleTimeoutMs);
+        if (typeof timer === 'object' && 'unref' in timer) {
+            timer.unref();
+        }
+        return timer;
+    }
+}
+function serializeKey(key) {
+    return `${key.serverId ?? key.languageId}\u0000${key.workspaceRoot}`;
+}
+async function safeStop(client) {
+    try {
+        await client.stop();
+    }
+    catch {
+        void 0;
+    }
+}

package/dist/lsp/lspErrorCodes.d.ts

@@ -0,0 +1,12 @@
+export declare const LSP_ERROR_CODES: {
+    readonly LSP_NOT_INSTALLED: "LSP_NOT_INSTALLED";
+    readonly LSP_TIMEOUT: "LSP_TIMEOUT";
+    readonly LSP_INITIALIZE_FAILED: "LSP_INITIALIZE_FAILED";
+    readonly LSP_REQUEST_FAILED: "LSP_REQUEST_FAILED";
+    readonly LSP_EMPTY: "LSP_EMPTY";
+    readonly LSP_CAPABILITY_UNSUPPORTED: "LSP_CAPABILITY_UNSUPPORTED";
+    readonly LSP_FALLBACK_TO_TEXT: "LSP_FALLBACK_TO_TEXT";
+    readonly SYMBOL_NOT_FOUND: "SYMBOL_NOT_FOUND";
+    readonly SYMBOL_AMBIGUOUS: "SYMBOL_AMBIGUOUS";
+    readonly UNSAFE_URI: "UNSAFE_URI";
+};

package/dist/lsp/lspErrorCodes.js

@@ -0,0 +1,12 @@
+export const LSP_ERROR_CODES = {
+    LSP_NOT_INSTALLED: 'LSP_NOT_INSTALLED',
+    LSP_TIMEOUT: 'LSP_TIMEOUT',
+    LSP_INITIALIZE_FAILED: 'LSP_INITIALIZE_FAILED',
+    LSP_REQUEST_FAILED: 'LSP_REQUEST_FAILED',
+    LSP_EMPTY: 'LSP_EMPTY',
+    LSP_CAPABILITY_UNSUPPORTED: 'LSP_CAPABILITY_UNSUPPORTED',
+    LSP_FALLBACK_TO_TEXT: 'LSP_FALLBACK_TO_TEXT',
+    SYMBOL_NOT_FOUND: 'SYMBOL_NOT_FOUND',
+    SYMBOL_AMBIGUOUS: 'SYMBOL_AMBIGUOUS',
+    UNSAFE_URI: 'UNSAFE_URI',
+};

package/dist/lsp/manager.d.ts

@@ -0,0 +1,23 @@
+import { LSPClient } from './client.js';
+import { type PoolKey } from './lspClientPool.js';
+export declare function isLanguageServerAvailable(filePath: string, workspaceRoot?: string): Promise<boolean>;
+export declare const LSP_UNAVAILABLE_HINT = "No language server is available for this file, so no semantic results were returned. Install a matching language server or set the relevant OCTOCODE_*_SERVER_PATH environment variable. For a text-based search meanwhile, use localSearchCode.";
+export declare function acquirePooledClient(workspaceRoot: string, filePath: string): Promise<LSPClient | null>;
+export declare function releaseAllPooledClients(): Promise<void>;
+export declare function releasePooledClientForFile(workspaceRoot: string, filePath: string): Promise<boolean>;
+export type LspStatusInput = {
+    filePath?: string;
+    workspaceRoot?: string;
+};
+export type LspStatusResult = {
+    enabled: true;
+    pooledClientCount: number;
+    pooledClients: PoolKey[];
+    filePath?: string;
+    workspaceRoot?: string;
+    languageId?: string;
+    serverAvailable?: boolean;
+    hints: string[];
+};
+export declare function getLspStatus(input?: LspStatusInput): Promise<LspStatusResult>;
+export declare function pooledClientCount(): number;

package/dist/lsp/manager.js

@@ -0,0 +1,94 @@
+import { LSPClient } from './client.js';
+import { getLanguageServerForFile } from './config.js';
+import { LspClientPool } from './lspClientPool.js';
+import { nativeBinding } from './native.js';
+import { resolveWorkspaceRootForFile } from './workspaceRoot.js';
+export async function isLanguageServerAvailable(filePath, workspaceRoot) {
+    const serverConfig = await getLanguageServerForFile(filePath, workspaceRoot ?? process.cwd());
+    if (!serverConfig)
+        return false;
+    return nativeBinding.isCommandAvailable(serverConfig.command);
+}
+export const LSP_UNAVAILABLE_HINT = 'No language server is available for this file, so no semantic results were returned. Install a matching language server or set the relevant OCTOCODE_*_SERVER_PATH environment variable. For a text-based search meanwhile, use localSearchCode.';
+const POOL_IDLE_TIMEOUT_MS = parseInt(process.env.OCTOCODE_LSP_POOL_IDLE_MS || '60000', 10);
+const sharedPool = new LspClientPool({
+    idleTimeoutMs: POOL_IDLE_TIMEOUT_MS,
+    factory: async (key) => {
+        const serverConfig = await getLanguageServerForFile(synthesizeFilePathForKey(key), key.workspaceRoot);
+        if (!serverConfig)
+            return null;
+        const client = new LSPClient(serverConfig);
+        try {
+            await client.start();
+            return client;
+        }
+        catch {
+            await client.stop().catch(() => undefined);
+            return null;
+        }
+    },
+});
+export async function acquirePooledClient(workspaceRoot, filePath) {
+    const key = await poolKeyForFile(workspaceRoot, filePath);
+    if (!key)
+        return null;
+    return sharedPool.acquire(key);
+}
+export async function releaseAllPooledClients() {
+    await sharedPool.clearAll();
+}
+export async function releasePooledClientForFile(workspaceRoot, filePath) {
+    const key = await poolKeyForFile(workspaceRoot, filePath);
+    if (!key)
+        return false;
+    await sharedPool.clear(key);
+    return true;
+}
+export async function getLspStatus(input = {}) {
+    const base = {
+        enabled: true,
+        pooledClientCount: sharedPool.size(),
+        pooledClients: sharedPool.keys(),
+    };
+    if (!input.filePath) {
+        return {
+            ...base,
+            hints: [
+                'Provide filePath to check language server availability for a specific file.',
+            ],
+        };
+    }
+    const workspaceRoot = input.workspaceRoot ?? (await resolveWorkspaceRootForFile(input.filePath));
+    const serverConfig = await getLanguageServerForFile(input.filePath, workspaceRoot);
+    const languageId = serverConfig?.languageId;
+    const serverAvailable = serverConfig
+        ? nativeBinding.isCommandAvailable(serverConfig.command)
+        : false;
+    return {
+        ...base,
+        filePath: input.filePath,
+        workspaceRoot,
+        languageId,
+        serverAvailable,
+        hints: serverAvailable
+            ? ['Language server appears available for this file.']
+            : [LSP_UNAVAILABLE_HINT],
+    };
+}
+export function pooledClientCount() {
+    return sharedPool.size();
+}
+function synthesizeFilePathForKey(key) {
+    return key.filePath;
+}
+async function poolKeyForFile(workspaceRoot, filePath) {
+    const serverConfig = await getLanguageServerForFile(filePath, workspaceRoot);
+    if (!serverConfig)
+        return null;
+    return {
+        workspaceRoot,
+        filePath,
+        languageId: serverConfig.languageId ?? 'unknown',
+        serverId: `${serverConfig.command} ${(serverConfig.args ?? []).join(' ')}`.trim(),
+    };
+}

package/dist/lsp/native.d.ts

@@ -0,0 +1,35 @@
+export type NativeLspClientBinding = {
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    waitForReady(timeoutMs?: number): Promise<void>;
+    hasCapability?(capability: string): boolean;
+    getRecentStderr?(): string[];
+    openDocument(filePath: string, content: string): Promise<void>;
+    closeDocument?(filePath: string): Promise<void>;
+    getDefinition(filePath: string, line: number, character: number): Promise<unknown[]>;
+    getReferences(filePath: string, line: number, character: number, includeDeclaration?: boolean): Promise<unknown[]>;
+    getHover(filePath: string, line: number, character: number): Promise<unknown>;
+    getTypeDefinition(filePath: string, line: number, character: number): Promise<unknown[]>;
+    getImplementation(filePath: string, line: number, character: number): Promise<unknown[]>;
+    getDocumentSymbols(filePath: string): Promise<unknown>;
+    prepareCallHierarchy(filePath: string, line: number, character: number): Promise<unknown>;
+    incomingCalls(item: unknown): Promise<unknown>;
+    outgoingCalls(item: unknown): Promise<unknown>;
+};
+type NativeBinding = {
+    NativeLspClient: new (config: unknown) => NativeLspClientBinding;
+    resolvePosition(filePath: string, fuzzy: unknown): unknown;
+    resolvePositionFromContent(content: string, fuzzy: unknown): unknown;
+    toUri(path: string): string;
+    fromUri(uri: string): string;
+    resolveWorkspaceRootForFile(filePath: string): string;
+    detectLanguageId(filePath: string): string | undefined;
+    getLanguageServerForFile(filePath: string, workspaceRoot: string): unknown | undefined;
+    isCommandAvailable(command: string): boolean;
+    safeReadFile(filePath: string): string;
+    validateLspServerPath(command: string): string;
+    convertSymbolKind(kind?: number): string;
+    toLspSymbolKind(kind: string): number;
+};
+export declare const nativeBinding: NativeBinding;
+export {};

package/dist/lsp/native.js

@@ -0,0 +1,3 @@
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+export const nativeBinding = require('../../index.cjs');

package/dist/lsp/resolver.d.ts

@@ -0,0 +1,26 @@
+import type { ExactPosition, FuzzyPosition } from './types.js';
+export declare class SymbolResolutionError extends Error {
+    readonly symbolName: string;
+    readonly lineHint: number;
+    readonly reason: string;
+    readonly searchRadius: number;
+    constructor(symbolName: string, lineHint: number, reason: string, searchRadius?: number);
+}
+interface SymbolResolverConfig {
+    lineSearchRadius?: number;
+}
+interface ResolvedSymbol {
+    position: ExactPosition;
+    foundAtLine: number;
+    lineOffset: number;
+    lineContent: string;
+}
+export declare function resolveSymbolPosition(filePath: string, symbolName: string, lineHint?: number, orderHint?: number): Promise<ResolvedSymbol>;
+export declare function resolveSymbolPosition(content: string, fuzzy: FuzzyPosition): ResolvedSymbol;
+export declare class SymbolResolver {
+    readonly lineSearchRadius: number;
+    constructor(config?: SymbolResolverConfig);
+    resolvePosition(filePath: string, fuzzy: FuzzyPosition): Promise<ResolvedSymbol>;
+    resolvePositionFromContent(content: string, fuzzy: FuzzyPosition): ResolvedSymbol;
+}
+export {};

package/dist/lsp/resolver.js

@@ -0,0 +1,73 @@
+import { nativeBinding } from './native.js';
+export class SymbolResolutionError extends Error {
+    symbolName;
+    lineHint;
+    reason;
+    searchRadius;
+    constructor(symbolName, lineHint, reason, searchRadius = 5) {
+        super(`Could not find symbol '${symbolName}' at or near line ${lineHint}. ${reason}`);
+        this.symbolName = symbolName;
+        this.lineHint = lineHint;
+        this.reason = reason;
+        this.searchRadius = searchRadius;
+        this.name = 'SymbolResolutionError';
+    }
+}
+function normalizeResolvedSymbol(value) {
+    const record = value;
+    return {
+        position: record.position,
+        foundAtLine: record.foundAtLine ?? record.found_at_line ?? 0,
+        lineOffset: record.lineOffset ?? record.line_offset ?? 0,
+        lineContent: record.lineContent ?? record.line_content ?? '',
+    };
+}
+function toSymbolResolutionError(error, fuzzy, searchRadius = 5) {
+    if (error instanceof SymbolResolutionError)
+        return error;
+    const reason = error instanceof Error ? error.message : String(error);
+    return new SymbolResolutionError(fuzzy.symbolName, fuzzy.lineHint ?? 0, reason, searchRadius);
+}
+export function resolveSymbolPosition(fileOrContent, fuzzyOrSymbolName, lineHint, orderHint) {
+    if (typeof fuzzyOrSymbolName === 'string') {
+        const fuzzy = {
+            symbolName: fuzzyOrSymbolName,
+            lineHint,
+            orderHint,
+        };
+        try {
+            return Promise.resolve(normalizeResolvedSymbol(nativeBinding.resolvePosition(fileOrContent, fuzzy)));
+        }
+        catch (error) {
+            return Promise.reject(toSymbolResolutionError(error, fuzzy));
+        }
+    }
+    try {
+        return normalizeResolvedSymbol(nativeBinding.resolvePositionFromContent(fileOrContent, fuzzyOrSymbolName));
+    }
+    catch (error) {
+        throw toSymbolResolutionError(error, fuzzyOrSymbolName);
+    }
+}
+export class SymbolResolver {
+    lineSearchRadius;
+    constructor(config) {
+        this.lineSearchRadius = config?.lineSearchRadius ?? 5;
+    }
+    async resolvePosition(filePath, fuzzy) {
+        try {
+            return normalizeResolvedSymbol(nativeBinding.resolvePosition(filePath, fuzzy));
+        }
+        catch (error) {
+            throw toSymbolResolutionError(error, fuzzy, this.lineSearchRadius);
+        }
+    }
+    resolvePositionFromContent(content, fuzzy) {
+        try {
+            return normalizeResolvedSymbol(nativeBinding.resolvePositionFromContent(content, fuzzy));
+        }
+        catch (error) {
+            throw toSymbolResolutionError(error, fuzzy, this.lineSearchRadius);
+        }
+    }
+}

package/dist/lsp/schemas.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const LSPConfigFileSchema: z.ZodObject<{
+    languageServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        command: z.ZodString;
+        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        languageId: z.ZodString;
+        initializationOptions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$loose>>>;
+}, z.core.$loose>;

package/dist/lsp/schemas.js

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+const MAX_COMMAND_LENGTH = 512;
+const MAX_ARG_LENGTH = 1024;
+const MAX_ARGS_COUNT = 64;
+const EXTENSION_KEY_PATTERN = /^\.[a-z0-9._+-]+$/i;
+const UserLanguageServerConfigSchema = z.looseObject({
+    command: z
+        .string()
+        .min(1)
+        .max(MAX_COMMAND_LENGTH)
+        .refine(value => !/[\0\r\n]/.test(value), {
+        message: 'command contains invalid control characters',
+    }),
+    args: z
+        .array(z
+        .string()
+        .max(MAX_ARG_LENGTH)
+        .refine(value => !/[\0\r\n]/.test(value), {
+        message: 'argument contains invalid control characters',
+    }))
+        .max(MAX_ARGS_COUNT)
+        .optional(),
+    languageId: z.string().min(1).max(64),
+    initializationOptions: z.record(z.string(), z.unknown()).optional(),
+});
+export const LSPConfigFileSchema = z.looseObject({
+    languageServers: z
+        .record(z.string().regex(EXTENSION_KEY_PATTERN), UserLanguageServerConfigSchema)
+        .optional(),
+});