@octocodeai/octocode-engine 16.5.0 → 16.6.0

package/dist/lsp/resolver.d.ts

@@ -1,4 +1,4 @@
-import type { ExactPosition, FuzzyPosition } from './types.js';
+import type { CodeSnippet, ExactPosition, FuzzyPosition } from './types.js';
 export declare class SymbolResolutionError extends Error {
     readonly symbolName: string;
     readonly lineHint: number;
@@ -15,6 +15,11 @@ interface ResolvedSymbol {
     lineOffset: number;
     lineContent: string;
 }
+export interface ImportAliasDefinitionInput {
+    anchorUri: string;
+    symbolName: string;
+    locations: CodeSnippet[];
+}
 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 {
@@ -23,4 +28,5 @@ export declare class SymbolResolver {
     resolvePosition(filePath: string, fuzzy: FuzzyPosition): Promise<ResolvedSymbol>;
     resolvePositionFromContent(content: string, fuzzy: FuzzyPosition): ResolvedSymbol;
 }
+export declare function resolveImportAliasDefinitions({ anchorUri, symbolName, locations, }: ImportAliasDefinitionInput): Promise<CodeSnippet[]>;
 export {};

package/dist/lsp/resolver.js

@@ -1,3 +1,5 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
 import { nativeBinding } from './native.js';
 export class SymbolResolutionError extends Error {
     symbolName;
@@ -71,3 +73,118 @@ export class SymbolResolver {
         }
     }
 }
+export async function resolveImportAliasDefinitions({ anchorUri, symbolName, locations, }) {
+    const resolved = await Promise.all(locations.map(location => resolveImportAliasDefinition(anchorUri, symbolName, location)));
+    return resolved;
+}
+async function resolveImportAliasDefinition(anchorUri, symbolName, location) {
+    const locationPath = snippetPath(location.uri, anchorUri);
+    if (!isSamePath(locationPath, anchorUri))
+        return location;
+    if (!isImportSnippet(location.content))
+        return location;
+    const importTarget = importTargetForSymbol(location.content, symbolName);
+    if (!importTarget?.moduleSpecifier.startsWith('.'))
+        return location;
+    const targetPath = await resolveLocalModulePath(locationPath, importTarget.moduleSpecifier);
+    if (!targetPath)
+        return location;
+    const content = await readFile(targetPath, 'utf-8');
+    const declaration = findExportedDeclaration(content, importTarget.exportedName);
+    if (!declaration)
+        return location;
+    return {
+        uri: targetPath,
+        range: {
+            start: { line: declaration.line - 1, character: declaration.character },
+            end: { line: declaration.line - 1, character: declaration.character },
+        },
+        displayRange: { startLine: declaration.line, endLine: declaration.line },
+        content: declaration.content,
+    };
+}
+function isImportSnippet(content) {
+    return /^\s*import\s/.test(content.trim());
+}
+function importTargetForSymbol(importLine, symbolName) {
+    const namedImport = importLine.match(/import\s*\{([^}]+)\}\s*from\s*['"]([^'"]+)['"]/);
+    const namedImports = namedImport?.[1];
+    const namedModulePath = namedImport?.[2];
+    if (namedImports && namedModulePath) {
+        for (const part of namedImports.split(',')) {
+            const [original, alias] = part
+                .trim()
+                .split(/\s+as\s+/)
+                .map(value => value.trim());
+            if (alias === symbolName || original === symbolName) {
+                return {
+                    moduleSpecifier: namedModulePath,
+                    exportedName: original,
+                };
+            }
+        }
+    }
+    const defaultImport = importLine.match(/import\s+([A-Za-z_$][\w$]*)\s+from\s*['"]([^'"]+)['"]/);
+    const defaultName = defaultImport?.[1];
+    const defaultModulePath = defaultImport?.[2];
+    if (defaultName === symbolName && defaultModulePath) {
+        return { moduleSpecifier: defaultModulePath, exportedName: symbolName };
+    }
+    return undefined;
+}
+async function resolveLocalModulePath(importerPath, moduleSpecifier) {
+    const basePath = path.resolve(path.dirname(filePathFromUri(importerPath)), moduleSpecifier);
+    const extension = path.extname(basePath);
+    const sourcePath = extension ? basePath.slice(0, -extension.length) : basePath;
+    const candidates = [
+        ...(extension === '.js' || extension === '.jsx'
+            ? [`${sourcePath}.ts`, `${sourcePath}.tsx`]
+            : []),
+        basePath,
+        `${basePath}.ts`,
+        `${basePath}.tsx`,
+        `${basePath}.js`,
+        `${basePath}.jsx`,
+        path.join(basePath, 'index.ts'),
+        path.join(basePath, 'index.tsx'),
+        path.join(basePath, 'index.js'),
+        path.join(basePath, 'index.jsx'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            await readFile(candidate, 'utf-8');
+            return candidate;
+        }
+        catch {
+            // Try the next TypeScript/JavaScript resolution candidate.
+        }
+    }
+    return undefined;
+}
+function findExportedDeclaration(content, symbolName) {
+    const escaped = symbolName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const declarationPattern = new RegExp(`^\\s*export\\s+(?:default\\s+)?(?:async\\s+)?(?:function|class|interface|type|const|let|var|enum)\\s+${escaped}\\b`);
+    const lines = content.split(/\r?\n/);
+    for (const [index, line] of lines.entries()) {
+        if (!declarationPattern.test(line))
+            continue;
+        return {
+            line: index + 1,
+            character: Math.max(0, line.indexOf(symbolName)),
+            content: line.trim(),
+        };
+    }
+    return undefined;
+}
+function isSamePath(left, right) {
+    return (path.resolve(filePathFromUri(left)) === path.resolve(filePathFromUri(right)));
+}
+function snippetPath(uri, anchorUri) {
+    const filePath = filePathFromUri(uri);
+    if (path.isAbsolute(filePath))
+        return filePath;
+    return path.resolve(path.dirname(filePathFromUri(anchorUri)), filePath);
+}
+function filePathFromUri(uri) {
+    return uri.startsWith('file://') ? new URL(uri).pathname : uri;
+}

package/dist/lsp/workspaceRoot.d.ts

@@ -1,2 +1,2 @@
-export declare function resolveWorkspaceRootForFile(filePath: string, _workspaceRoot?: string): Promise<string>;
+export declare function resolveWorkspaceRootForFile(filePath: string, workspaceRoot?: string): Promise<string>;
 export declare function findWorkspaceRoot(filePath: string): Promise<string>;

package/dist/lsp/workspaceRoot.js

@@ -1,5 +1,7 @@
 import { nativeBinding } from './native.js';
-export async function resolveWorkspaceRootForFile(filePath, _workspaceRoot) {
+export async function resolveWorkspaceRootForFile(filePath, workspaceRoot) {
+    if (workspaceRoot)
+        return workspaceRoot;
     return nativeBinding.resolveWorkspaceRootForFile(filePath);
 }
 export async function findWorkspaceRoot(filePath) {

package/dist/security/discoveryFilter.d.ts

@@ -0,0 +1,11 @@
+export declare const DISCOVERY_IGNORED_FOLDER_NAMES: string[];
+export declare const DISCOVERY_IGNORED_FILE_NAMES: string[];
+export declare const DISCOVERY_IGNORED_FILE_EXTENSIONS: string[];
+export interface DiscoveryExtensionOptions {
+    lowercase?: boolean;
+    fallback?: string;
+    leadingDot?: boolean;
+}
+export declare function shouldIgnoreDiscoveryDir(folderName: string): boolean;
+export declare function shouldIgnoreDiscoveryFile(filePath: string): boolean;
+export declare function getDiscoveryExtension(filePath: string, options?: DiscoveryExtensionOptions): string;

package/dist/security/discoveryFilter.js

@@ -0,0 +1,261 @@
+export const DISCOVERY_IGNORED_FOLDER_NAMES = [
+    '.github',
+    '.git',
+    '.vscode',
+    '.devcontainer',
+    '.config',
+    '.cargo',
+    '.changeset',
+    '.husky',
+    '.aspect',
+    '.eslint-plugin-local',
+    '.yarn',
+    '.gemini',
+    '.ng-dev',
+    '.configurations',
+    '.tx',
+    'dist',
+    'build',
+    'out',
+    'output',
+    'target',
+    'release',
+    'node_modules',
+    'vendor',
+    'third_party',
+    'tmp',
+    'temp',
+    'cache',
+    '.cache',
+    '.tmp',
+    '.pytest_cache',
+    '.tox',
+    '.venv',
+    '.mypy_cache',
+    '.next',
+    '.svelte-kit',
+    '.turbo',
+    '.angular',
+    '.dart_tool',
+    '__pycache__',
+    '.ruff_cache',
+    '.nox',
+    'htmlcov',
+    'cover',
+    '.gradle',
+    '.m2',
+    '.sbt',
+    '.bloop',
+    '.metals',
+    '.bsp',
+    'bin',
+    'obj',
+    'TestResults',
+    'BenchmarkDotNet.Artifacts',
+    '.vendor-new',
+    'Godeps',
+    'composer.phar',
+    '.phpunit.result.cache',
+    '.bundle',
+    '.byebug_history',
+    '.rspec_status',
+    '.mvn',
+    '.aws',
+    '.gcp',
+    'fastlane',
+    'DerivedData',
+    'xcuserdata',
+    'local.properties',
+    '.navigation',
+    'captures',
+    '.externalNativeBuild',
+    '.cxx',
+    '.idea',
+    '.idea_modules',
+    '.vs',
+    '.history',
+    'coverage',
+    '.nyc_output',
+    '.DS_Store',
+];
+export const DISCOVERY_IGNORED_FILE_NAMES = [
+    'package-lock.json',
+    '.secrets',
+    '.secret',
+    'secrets.json',
+    'secrets.yaml',
+    'secrets.yml',
+    'credentials.json',
+    'credentials.yaml',
+    'credentials.yml',
+    'auth.json',
+    'auth.yaml',
+    'auth.yml',
+    'api-keys.json',
+    'api_keys.json',
+    'service-account.json',
+    'service_account.json',
+    'private-key.pem',
+    'private_key.pem',
+    'id_rsa',
+    'id_dsa',
+    'id_ecdsa',
+    'id_ed25519',
+    'keyfile',
+    'keyfile.json',
+    'gcloud-service-key.json',
+    'firebase-adminsdk.json',
+    'google-services.json',
+    'GoogleService-Info.plist',
+    '.DS_Store',
+    'Thumbs.db',
+    'db.sqlite3',
+    'db.sqlite3-journal',
+    '.eslintcache',
+    '.stylelintcache',
+    '.node_repl_history',
+    '.yarn-integrity',
+    'celerybeat-schedule',
+    'celerybeat.pid',
+    'ThirdPartyNoticeText.txt',
+    'ThirdPartyNotices.txt',
+    'cglicenses.json',
+    'cgmanifest.json',
+];
+export const DISCOVERY_IGNORED_FILE_EXTENSIONS = [
+    '.lock',
+    '.tmp',
+    '.temp',
+    '.cache',
+    '.bak',
+    '.backup',
+    '.orig',
+    '.swp',
+    '.swo',
+    '.rej',
+    '.pid',
+    '.seed',
+    '.old',
+    '.save',
+    '.temporary',
+    '.exe',
+    '.dll',
+    '.so',
+    '.dylib',
+    '.a',
+    '.lib',
+    '.o',
+    '.obj',
+    '.bin',
+    '.class',
+    '.pdb',
+    '.dSYM',
+    '.pyc',
+    '.pyo',
+    '.pyd',
+    '.jar',
+    '.war',
+    '.ear',
+    '.nar',
+    '.db',
+    '.sqlite',
+    '.sqlite3',
+    '.mdb',
+    '.accdb',
+    '.zip',
+    '.tar',
+    '.gz',
+    '.bz2',
+    '.xz',
+    '.lz',
+    '.lzma',
+    '.Z',
+    '.tgz',
+    '.rar',
+    '.7z',
+    '.deb',
+    '.rpm',
+    '.pkg',
+    '.dmg',
+    '.msi',
+    '.appx',
+    '.snap',
+    '.map',
+    '.d.ts.map',
+    '.min.js',
+    '.min.css',
+    '.key',
+    '.pem',
+    '.p12',
+    '.pfx',
+    '.crt',
+    '.cer',
+    '.der',
+    '.csr',
+    '.jks',
+    '.keystore',
+    '.truststore',
+    '.kate-swp',
+    '.gnome-desktop',
+    '.sublime-project',
+    '.sublime-workspace',
+    '.iml',
+    '.iws',
+    '.ipr',
+    '.patch',
+    '.diff',
+    '.prof',
+    '.profile',
+    '.trace',
+    '.perf',
+    '.coverage',
+    '.egg-info',
+    '.egg',
+    '.mo',
+    '.pot',
+    '.setup',
+    '.paket.template',
+];
+export function shouldIgnoreDiscoveryDir(folderName) {
+    const normalized = folderName.replace(/\\/g, '/');
+    const name = normalized.split('/').filter(Boolean).pop() ?? normalized;
+    return DISCOVERY_IGNORED_FOLDER_NAMES.includes(name);
+}
+export function shouldIgnoreDiscoveryFile(filePath) {
+    const normalizedPath = filePath.replace(/\\/g, '/');
+    const fileName = normalizedPath.split('/').pop() || '';
+    for (const ext of DISCOVERY_IGNORED_FILE_EXTENSIONS) {
+        if (fileName.endsWith(ext)) {
+            return true;
+        }
+    }
+    if (DISCOVERY_IGNORED_FILE_NAMES.includes(fileName)) {
+        return true;
+    }
+    const pathParts = normalizedPath.split('/');
+    for (const part of pathParts) {
+        if (DISCOVERY_IGNORED_FOLDER_NAMES.includes(part)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function getDiscoveryExtension(filePath, options) {
+    const basename = filePath.split(/[\\/]/).pop() ?? filePath;
+    const fallback = options?.fallback ?? '';
+    let ext = fallback;
+    if (basename.startsWith('.')) {
+        const dotfileExt = basename.slice(1);
+        ext = dotfileExt.includes('.')
+            ? (basename.split('.').pop() ?? fallback)
+            : dotfileExt;
+    }
+    else {
+        const lastDot = basename.lastIndexOf('.');
+        ext = lastDot === -1 ? fallback : basename.slice(lastDot + 1);
+    }
+    const normalized = options?.lowercase ? ext.toLowerCase() : ext;
+    if (!normalized || !options?.leadingDot)
+        return normalized;
+    return normalized.startsWith('.') ? normalized : `.${normalized}`;
+}

package/dist/security/index.d.ts

@@ -7,6 +7,8 @@ export { withSecurityValidation, withBasicSecurityValidation, configureSecurity,
 export type { SecurityDepsConfig } from './withSecurityValidation.js';
 export { extractResearchFields, extractRepoOwnerFromParams, } from './paramExtractors.js';
 export { shouldIgnore, shouldIgnorePath, shouldIgnoreFile, } from './ignoredPathFilter.js';
+export { DISCOVERY_IGNORED_FILE_EXTENSIONS, DISCOVERY_IGNORED_FILE_NAMES, DISCOVERY_IGNORED_FOLDER_NAMES, getDiscoveryExtension, shouldIgnoreDiscoveryDir, shouldIgnoreDiscoveryFile, } from './discoveryFilter.js';
+export type { DiscoveryExtensionOptions } from './discoveryFilter.js';
 export { redactPath } from './pathUtils.js';
 export { ALLOWED_COMMANDS, DANGEROUS_PATTERNS, PATTERN_DANGEROUS_PATTERNS, } from './securityConstants.js';
 export { IGNORED_PATH_PATTERNS } from './pathPatterns.js';

package/dist/security/index.js

@@ -5,6 +5,7 @@ export { validateCommand } from './commandValidator.js';
 export { withSecurityValidation, withBasicSecurityValidation, configureSecurity, } from './withSecurityValidation.js';
 export { extractResearchFields, extractRepoOwnerFromParams, } from './paramExtractors.js';
 export { shouldIgnore, shouldIgnorePath, shouldIgnoreFile, } from './ignoredPathFilter.js';
+export { DISCOVERY_IGNORED_FILE_EXTENSIONS, DISCOVERY_IGNORED_FILE_NAMES, DISCOVERY_IGNORED_FOLDER_NAMES, getDiscoveryExtension, shouldIgnoreDiscoveryDir, shouldIgnoreDiscoveryFile, } from './discoveryFilter.js';
 export { redactPath } from './pathUtils.js';
 export { ALLOWED_COMMANDS, DANGEROUS_PATTERNS, PATTERN_DANGEROUS_PATTERNS, } from './securityConstants.js';
 export { IGNORED_PATH_PATTERNS } from './pathPatterns.js';

package/dist/security/withSecurityValidation.d.ts

@@ -2,9 +2,6 @@ import type { ISanitizer, ToolResult } from './types.js';
 export interface SecurityDepsConfig {
     sanitizer?: ISanitizer;
     defaultTimeoutMs?: number;
-    logToolCall?: (toolName: string, repos: string[], goal?: string, rGoal?: string, reasoning?: string) => Promise<void>;
-    logSessionError?: (toolName: string, errorCode: string) => Promise<void>;
-    isLoggingEnabled?: () => boolean;
 }
 export declare function configureSecurity(deps: SecurityDepsConfig): void;
 export declare function withSecurityValidation<T extends Record<string, unknown>, TAuth = unknown>(toolName: string, toolHandler: (sanitizedArgs: T, authInfo?: TAuth, sessionId?: string) => Promise<ToolResult>, options?: {

package/dist/security/withSecurityValidation.js

@@ -1,6 +1,4 @@
 import { ContentSanitizer } from './contentSanitizer.js';
-import { extractResearchFields, extractRepoOwnerFromParams, } from './paramExtractors.js';
-const SECURITY_VALIDATION_FAILED_CODE = 'TOOL_SECURITY_VALIDATION_FAILED';
 const DEFAULT_TOOL_TIMEOUT_MS = 60_000;
 let _deps = {};
 function getSanitizer() {
@@ -58,15 +56,9 @@ async function runSecure(opts) {
         }
         const sanitizedParams = validation.sanitizedParams;
         const rawResult = await withToolTimeout(toolName, handler(sanitizedParams, authInfo, sessionId), signal, timeoutMs);
-        if (!rawResult.isError && _deps.isLoggingEnabled?.()) {
-            handleBulk(toolName, sanitizedParams);
-        }
         return rawResult;
     }
     catch (error) {
-        _deps
-            .logSessionError?.(toolName, SECURITY_VALIDATION_FAILED_CODE)
-            .catch(() => { });
         return createErrorResult(`Security validation error: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
 }
@@ -92,16 +84,3 @@ export function withBasicSecurityValidation(toolHandler, toolName, options) {
         timeoutMs: options?.timeoutMs,
     });
 }
-function handleBulk(toolName, params) {
-    const queries = params.queries;
-    const items = queries && Array.isArray(queries) && queries.length > 0
-        ? queries
-        : [params];
-    for (const item of items) {
-        const repos = extractRepoOwnerFromParams(item);
-        const fields = extractResearchFields(item);
-        _deps
-            .logToolCall?.(toolName, repos, fields.mainResearchGoal, fields.researchGoal, fields.reasoning)
-            .catch(() => { });
-    }
-}

package/index.cjs

@@ -75,13 +75,38 @@ function loadNativeBinding() {
     join(__dirname, '..', '..', 'runtime', 'engine', `${binaryName}.${key}.node`),
   ]
 
+  const loadErrors = []
   for (const candidate of candidates) {
     if (existsSync(candidate)) {
-      return require(candidate)
+      try {
+        return require(candidate)
+      } catch (err) {
+        // The .node file exists but the host refused to load it — most often a
+        // hardened/sandboxed runtime (e.g. an editor/app-embedded Node) that
+        // blocks native addons, or an ABI/arch mismatch. Distinguish this from
+        // "binary missing" so callers don't report a generic tool failure.
+        loadErrors.push(`${candidate}: ${err && err.message ? err.message : err}`)
+      }
     }
   }
 
-  return require(`${packageName}-${key}`)
+  try {
+    return require(`${packageName}-${key}`)
+  } catch (err) {
+    loadErrors.push(`${packageName}-${key}: ${err && err.message ? err.message : err}`)
+  }
+
+  const detail = loadErrors.length
+    ? `\nNative load attempts:\n  - ${loadErrors.join('\n  - ')}`
+    : `\nNo native binary found for ${key} (looked in ${candidates.length} locations and the ${packageName}-${key} package).`
+  const error = new Error(
+    `@octocodeai/octocode-engine: could not load the native ${binaryName} addon for ${key}.` +
+      detail +
+      `\nIf a .node file exists above but failed to load, the current Node runtime is likely sandboxed and rejects ` +
+      `native addons (e.g. an editor/app-embedded Node). Re-run with system Node (\`which node\`).`
+  )
+  error.code = 'OCTOCODE_ENGINE_NATIVE_LOAD_FAILED'
+  throw error
 }
 
 const nativeBinding = loadNativeBinding()
@@ -90,6 +115,11 @@ nativeBinding.MINIFY_CONFIG = nativeBinding.getMINIFY_CONFIG()
 nativeBinding.SUPPORTED_SIGNATURE_EXTENSIONS = Object.freeze(
   nativeBinding.getSupportedSignatureExtensions().sort()
 )
+nativeBinding.SUPPORTED_GRAPH_FACT_EXTENSIONS = Object.freeze(
+  typeof nativeBinding.getSupportedGraphFactExtensions === 'function'
+    ? nativeBinding.getSupportedGraphFactExtensions().sort()
+    : []
+)
 nativeBinding.SUPPORTED_STRUCTURAL_EXTENSIONS = Object.freeze(
   nativeBinding.getSupportedStructuralExtensions().sort()
 )