@octocodeai/octocode-tools-core 16.6.3 → 17.0.1

package/dist/utils/package/npm/npmDetailsFetchers.d.ts

@@ -0,0 +1,15 @@
+import type { NpmPackageResult, NpmSearchAPIResult, NpmSearchError } from '../types.js';
+export declare function isNetworkFetchError(error: string | undefined): boolean;
+export declare function fetchLastPublished(packageName: string): Promise<{
+    lastPublished?: string;
+    rawResponseChars: number;
+}>;
+export type PackageDetailsLookupResult = {
+    pkg: NpmPackageResult | null;
+    errorDetail?: string;
+    rawResponseChars: number;
+};
+export declare function enrichPackageDetails(packageName: string, pkg: NpmPackageResult, rawResponseChars: number): Promise<PackageDetailsLookupResult>;
+export declare function fetchPackageDetailsFromCdn(packageName: string, includeExtendedMetadata: boolean): Promise<PackageDetailsLookupResult>;
+export declare function fetchPackageDetailsWithError(packageName: string, includeExtendedMetadata?: boolean): Promise<PackageDetailsLookupResult>;
+export declare function fetchNpmPackageByView(packageName: string, fetchMetadata: boolean, allowCdnFallback?: boolean): Promise<NpmSearchAPIResult | NpmSearchError>;

package/dist/utils/package/npm/npmMappers.d.ts

@@ -0,0 +1,12 @@
+import type { NpmPackageResult } from '../types.js';
+import type { NpmCliSearchItem, NpmViewResult } from './npmRegistry.js';
+export declare function cleanRepoUrl(url: string): string;
+export declare function countRawPayloadChars(raw: unknown): number;
+export declare function fetchWeeklyDownloads(packageName: string): Promise<{
+    downloads?: number;
+    rawResponseChars: number;
+}>;
+export declare function mapToResult(data: NpmViewResult, includeExtendedMetadata?: boolean, source?: 'cli' | 'registry' | 'cdn'): NpmPackageResult;
+export declare function mapSearchItemToResult(item: NpmCliSearchItem): NpmPackageResult | null;
+export declare function encodeRegistryPackageName(packageName: string): string;
+export declare function parseRegistrySearchTotal(total: string | number | undefined, fallback: number): number;

package/dist/utils/package/npm/npmRegistry.d.ts

@@ -0,0 +1,79 @@
+export declare const DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org";
+export declare function getNpmRegistryUrl(): Promise<string>;
+export declare function _resetNpmRegistryUrlCache(): void;
+export declare function checkNpmRegistryReachable(): Promise<boolean>;
+export interface NpmViewResult {
+    name: string;
+    version: string;
+    repository?: string | {
+        url?: string;
+        type?: string;
+        directory?: string;
+    };
+    main?: string;
+    module?: string;
+    type?: string;
+    exports?: unknown;
+    bin?: unknown;
+    types?: string;
+    typings?: string;
+    description?: string;
+    keywords?: string[];
+    license?: string | {
+        type?: string;
+    };
+    homepage?: string;
+    author?: string | {
+        name?: string;
+        email?: string;
+        url?: string;
+    };
+    maintainers?: Array<{
+        name?: string;
+        email?: string;
+    }>;
+    engines?: Record<string, string>;
+    dependencies?: Record<string, string>;
+    devDependencies?: Record<string, string>;
+    peerDependencies?: Record<string, string>;
+    time?: {
+        modified?: string;
+        created?: string;
+        [version: string]: string | undefined;
+    };
+}
+export interface NpmRegistrySearchItem {
+    name: string | null | undefined;
+    version: string | null | undefined;
+    description?: string | null;
+    links?: {
+        npm?: string | null;
+        homepage?: string | null;
+        repository?: string | null;
+    };
+}
+export interface NpmCliSearchItem {
+    name?: string;
+    version?: string;
+    description?: string;
+    keywords?: string[];
+    date?: string;
+    links?: {
+        npm?: string;
+        homepage?: string;
+        repository?: string;
+        bugs?: string;
+    };
+    repository?: string | {
+        url?: string;
+        type?: string;
+    };
+    score?: {
+        final?: number;
+        detail?: {
+            quality?: number;
+            popularity?: number;
+            maintenance?: number;
+        };
+    };
+}

package/dist/utils/package/npm/npmSearchStrategies.d.ts

@@ -0,0 +1,6 @@
+import type { NpmSearchAPIResult, NpmSearchError } from '../types.js';
+export declare function searchNpmPackageViaCliSearch(keywords: string, limit: number, fetchMetadata: boolean, from?: number): Promise<NpmSearchAPIResult | NpmSearchError>;
+export declare function searchNpmPackageViaRegistrySearch(keywords: string, limit: number, fetchMetadata: boolean, from?: number): Promise<NpmSearchAPIResult | NpmSearchError>;
+export declare function searchNpmPackageViaWebSearch(packageName: string, limit: number): Promise<NpmSearchAPIResult | NpmSearchError>;
+export declare function searchNpmPackageViaSearch(keywords: string, limit: number, fetchMetadata: boolean, from?: number): Promise<NpmSearchAPIResult | NpmSearchError>;
+export declare function enrichTopSearchResult(result: NpmSearchAPIResult): Promise<NpmSearchAPIResult>;

package/dist/utils/package/npm.d.ts

@@ -1,8 +1,2 @@
-import type { NpmSearchAPIResult, NpmSearchError, DeprecationInfo } from './types.js';
-export declare function getNpmRegistryUrl(): Promise<string>;
-export declare function _resetNpmRegistryUrlCache(): void;
-export declare function checkNpmRegistryReachable(): Promise<boolean>;
-export declare function isExactPackageName(query: string): boolean;
-export declare function _packageNameToSearchKeywords(packageName: string): string;
-export declare function searchNpmPackage(packageName: string, limit: number, fetchMetadata: boolean, from?: number): Promise<NpmSearchAPIResult | NpmSearchError>;
-export declare function checkNpmDeprecation(packageName: string): Promise<DeprecationInfo | null>;
+export { getNpmRegistryUrl, _resetNpmRegistryUrlCache, checkNpmRegistryReachable, } from './npm/npmRegistry.js';
+export { isExactPackageName, _packageNameToSearchKeywords, searchNpmPackage, checkNpmDeprecation, } from './npm/npmDeprecation.js';

package/dist/utils/pagination/boundary.d.ts

@@ -1,11 +1,11 @@
 export declare function isMidBlockCut(paginatedContent: string): boolean;
-export declare function findNextBlockBoundary(content: string, fromChar: number, filePath?: string): number | undefined;
-export declare function buildBlockBoundaryHint(paginatedContent: string, fullContent: string, cutPos: number, currentCharLength: number, filePath?: string): {
+export declare function findNextBlockBoundary(content: string, fromChar: number, filePath?: string): Promise<number | undefined>;
+export declare function buildBlockBoundaryHint(paginatedContent: string, fullContent: string, cutPos: number, currentCharLength: number, filePath?: string): Promise<{
     nextBlockChar: number;
     hint: string;
-} | undefined;
+} | undefined>;
 export type ChunkMode = 'semantic' | 'char-limit';
-export declare function snapToSemanticBoundary(content: string, charOffset: number, charLength: number, filePath?: string): {
+export declare function snapToSemanticBoundary(content: string, charOffset: number, charLength: number, filePath?: string): Promise<{
     length: number;
     chunkMode: ChunkMode;
-};
+}>;

package/dist/utils/response/bulk/pagination.d.ts

@@ -0,0 +1,6 @@
+import type { BulkToolResponse, BulkResponsePagination } from '../../../types/bulk.js';
+export declare function paginateBulkText(text: string, pagination?: BulkResponsePagination): {
+    text: string;
+    pagination?: NonNullable<BulkToolResponse['responsePagination']>;
+};
+export declare function appendResponsePagination<T extends Record<string, unknown>>(structuredContent: T, pagination?: NonNullable<BulkToolResponse['responsePagination']>): T;

package/dist/utils/response/bulk/queries.d.ts

@@ -0,0 +1,19 @@
+import type { ProcessedBulkResult, QueryError } from '../../../types/toolResults.js';
+export declare function computeQueryTimeout(queryCount: number, concurrency: number, minTimeoutMs?: number): number;
+export declare function processBulkQueries<TQuery extends object>(queries: Array<TQuery>, processor: (query: TQuery, index: number) => Promise<ProcessedBulkResult>, concurrency: number, minQueryTimeoutMs?: number): Promise<{
+    results: Array<{
+        result: ProcessedBulkResult;
+        queryIndex: number;
+        originalQuery: TQuery;
+    }>;
+    errors: QueryError[];
+}>;
+export declare function resolveQueryId<TQuery extends object>(originalQuery: TQuery, queryIndex: number): string;
+/**
+ * Resolve one id per query, guaranteed unique within the batch. Everything
+ * downstream (finalizer grouping, per-query pagination maps) keys off these
+ * ids, so two queries submitted with the same explicit `id` would otherwise
+ * silently merge and the second query's pagination would overwrite the first.
+ * Collisions get a `#2`, `#3`… suffix in submission order.
+ */
+export declare function resolveUniqueQueryIds<TQuery extends object>(queries: readonly TQuery[]): string[];

package/dist/utils/response/bulk/response.d.ts

@@ -0,0 +1,4 @@
+import { CallToolResult } from '@modelcontextprotocol/sdk/types';
+import type { ProcessedBulkResult } from '../../../types/toolResults.js';
+import type { BulkResponseConfig, BulkResponsePagination } from '../../../types/bulk.js';
+export declare function executeBulkOperation<TQuery extends object, TOutput extends Record<string, unknown> = Record<string, unknown>>(queries: Array<TQuery>, processor: (query: TQuery, index: number) => Promise<ProcessedBulkResult>, config: BulkResponseConfig<TQuery, TOutput>, pagination?: BulkResponsePagination): Promise<CallToolResult>;

package/dist/utils/response/bulk.d.ts

@@ -1,6 +1,2 @@
-import { CallToolResult } from '@modelcontextprotocol/sdk/types';
-import type { ProcessedBulkResult } from '../../types/toolResults.js';
-import type { BulkResponseConfig, BulkResponsePagination } from '../../types/bulk.js';
-export declare function computeQueryTimeout(queryCount: number, concurrency: number, minTimeoutMs?: number): number;
-export declare function executeBulkOperation<TQuery extends object, TOutput extends Record<string, unknown> = Record<string, unknown>>(queries: Array<TQuery>, processor: (query: TQuery, index: number) => Promise<ProcessedBulkResult>, config: BulkResponseConfig<TQuery, TOutput>, pagination?: BulkResponsePagination): Promise<CallToolResult>;
-export declare function resolveQueryId<TQuery extends object>(originalQuery: TQuery, queryIndex: number): string;
+export { computeQueryTimeout, resolveQueryId, resolveUniqueQueryIds, } from './bulk/queries.js';
+export { executeBulkOperation } from './bulk/response.js';

package/package.json

@@ -1,8 +1,14 @@
 {
   "name": "@octocodeai/octocode-tools-core",
-  "version": "16.6.3",
+  "version": "17.0.1",
   "description": "Core tool implementations for Octocode: GitHub, local filesystem, LSP, and package search tools.",
   "author": "Guy Bary <bgauryy@octocodeai.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bgauryy/octocode.git",
+    "directory": "packages/octocode-tools-core"
+  },
+  "bugs": "https://github.com/bgauryy/octocode/issues",
   "license": "MIT",
   "type": "module",
   "publishConfig": {
@@ -83,8 +89,9 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "@octocodeai/config": "^17.0.1",
     "@octocodeai/octocode-core": "^16.6.3",
-    "@octocodeai/octocode-engine": "^16.7.0",
+    "@octocodeai/octocode-engine": "^17.0.1",
     "@octokit/oauth-methods": "^6.0.2",
     "@octokit/plugin-throttling": "^11.0.3",
     "@octokit/request": "^10.0.10",
@@ -93,7 +100,6 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@octocodeai/config": "workspace:*",
     "@octokit/core": "^7.0.6",
     "@octokit/openapi-types": "^27.0.0",
     "@octokit/plugin-rest-endpoint-methods": "^17.0.0",

package/dist/tools/local_binary_inspect/archiveOps.d.ts

@@ -1,24 +0,0 @@
-/**
- * Archive list/extract operations.
- * Backs mode="list" and mode="extract" in localBinaryInspect.
- *
- * Backend selection (falls through on missing CLI):
- *   .aar/.yaa          → aa only
- *   .dmg/.rar/.cpgz    → 7z → 7zz → bsdtar
- *   .7z/.iso/.cab/…    → bsdtar → 7z → 7zz
- *   .tar.*             → tar → bsdtar → 7z
- *   default (zip-fam.) → unzip → tar → bsdtar → 7z
- */
-export interface ArchiveChainResult {
-    success: boolean;
-    stdout: string;
-    stderr: string;
-    commandUsed?: string;
-    missingCommands?: string[];
-}
-export declare function listArchiveEntries(path: string, verbose: boolean): Promise<ArchiveChainResult & {
-    entries?: string[];
-}>;
-export declare function extractArchiveEntry(path: string, entry: string): Promise<ArchiveChainResult>;
-/** Extracts the whole archive into destDir (which must already exist). */
-export declare function extractArchiveToDir(path: string, destDir: string): Promise<ArchiveChainResult>;

package/dist/tools/local_binary_inspect/binaryInspector.d.ts

@@ -1,86 +0,0 @@
-import type { BinaryInspectQuery } from './scheme.js';
-interface ContentCharPagination {
-    currentPage: number;
-    totalPages: number;
-    hasMore: boolean;
-    charOffset: number;
-    charLength: number;
-    totalChars: number;
-    nextCharOffset?: number;
-}
-export declare function inspectBinary(query: BinaryInspectQuery): Promise<import("../../index.js").UnifiedErrorResult | {
-    warnings?: string[];
-    truncated?: boolean;
-    detailed?: boolean;
-    libraries?: string[];
-    sections?: string[];
-    exports?: string[];
-    imports?: string[];
-    symbols?: string[];
-    symbolCount: number;
-    importCount: number;
-    exportCount: number;
-    entry?: string;
-    stripped?: boolean;
-    endianness?: string;
-    bits?: number;
-    arch?: string;
-    status: "success";
-    mode: "inspect";
-    path: string;
-    format: string;
-    description: string;
-    magicBytes: string;
-} | {
-    pagination: {
-        currentPage: number;
-        totalPages: number;
-        hasMore: boolean;
-        entriesPerPage: number;
-    };
-    status: "success";
-    mode: "list";
-    path: string;
-    backend: string;
-    totalEntries: number;
-    entries: string[];
-} | {
-    pagination?: ContentCharPagination;
-    status: "success";
-    mode: "extract";
-    path: string;
-    archiveFile: string;
-    backend: string;
-    localPath: string;
-    content: string;
-    isPartial: boolean;
-} | {
-    pagination?: ContentCharPagination;
-    status: "success";
-    mode: "decompress";
-    path: string;
-    format: "gzip" | "bzip2" | "xz" | "lzma" | "zstd" | "lz4" | "brotli" | "lzfse";
-    backend: string;
-    localPath: string;
-    content: string;
-    isPartial: boolean;
-} | {
-    nextScanOffset?: number;
-    scanOffset: number;
-    pagination?: ContentCharPagination;
-    totalFound: number;
-    isPartial: boolean;
-    localPath?: string;
-    status: "success";
-    mode: "strings";
-    path: string;
-    content: string;
-} | {
-    status: "success";
-    mode: "unpack";
-    path: string;
-    localPath: string;
-    cached: boolean;
-    topLevelEntries: number;
-}>;
-export {};

package/dist/tools/local_binary_inspect/binaryOps.d.ts

@@ -1,27 +0,0 @@
-/**
- * Binary file inspection (format lane) — native, via octocode-engine.
- * Backs mode="inspect" and mode="strings" in localBinaryInspect.
- *
- * No GNU binutils/coreutils dependency: `goblin`-backed parsing and a native
- * string scanner replace the old `file` / `xxd` / `strings` shell-outs, so this
- * lane works on Windows and on distroless/Alpine Linux, returns parser-stable
- * structured data, and recovers UTF-16 strings GNU `strings -a` misses.
- */
-import type { BinaryInspectInfo } from '@octocodeai/octocode-engine';
-export interface InspectResult {
-    success: boolean;
-    info?: BinaryInspectInfo;
-    error?: string;
-}
-export declare function inspectBinaryFile(path: string): InspectResult;
-export interface StringsResult {
-    success: boolean;
-    strings?: string[];
-    totalFound?: number;
-    /** True when more of the file remains to scan beyond this window (follow nextScanOffset). */
-    truncated?: boolean;
-    /** Absolute byte offset for the next scan window, or undefined at EOF. */
-    nextScanOffset?: number;
-    error?: string;
-}
-export declare function extractStrings(path: string, minLength: number, includeOffsets: boolean, scanOffset?: number): StringsResult;

package/dist/tools/local_binary_inspect/decompressOps.d.ts

@@ -1,16 +0,0 @@
-/**
- * Single-stream decompression.
- * Backs mode="decompress" in localBinaryInspect.
- *
- * Handles: .gz .bz2 .xz .lzma .zst .lz4 .br .lzfse
- * Does NOT handle multi-entry archives (.tar.gz, .zip etc.) — those belong to archiveOps.
- */
-export type DecompressFormat = 'auto' | 'gzip' | 'bzip2' | 'xz' | 'lzma' | 'zstd' | 'lz4' | 'brotli' | 'lzfse';
-export interface DecompressResult {
-    success: boolean;
-    content?: string;
-    format?: Exclude<DecompressFormat, 'auto'>;
-    backend?: string;
-    error?: string;
-}
-export declare function decompressFile(path: string, format: DecompressFormat): Promise<DecompressResult>;

package/dist/tools/local_binary_inspect/execution.d.ts

@@ -1,4 +0,0 @@
-import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { type BinaryInspectQuery } from './scheme.js';
-import type { ToolExecutionArgs } from '../../types/execution.js';
-export declare function executeInspectBinary(args: ToolExecutionArgs<BinaryInspectQuery>): Promise<CallToolResult>;

package/dist/tools/local_binary_inspect/scheme.d.ts

@@ -1,144 +0,0 @@
-import { z } from 'zod';
-export declare const LocalBinaryInspectQuerySchema: z.ZodObject<{
-    entryPageNumber: z.ZodDefault<z.ZodDefault<z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>>>;
-    matchStringContextLines: z.ZodDefault<z.ZodPreprocess<z.ZodNumber>>;
-    charLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
-    page: z.ZodDefault<z.ZodDefault<z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>>>;
-    detailed: z.ZodOptional<z.ZodBoolean>;
-    path: z.ZodString;
-    mode: z.ZodEnum<{
-        list: "list";
-        inspect: "inspect";
-        extract: "extract";
-        decompress: "decompress";
-        strings: "strings";
-        unpack: "unpack";
-    }>;
-    verbose: z.ZodOptional<z.ZodBoolean>;
-    maxEntries: z.ZodDefault<z.ZodNumber>;
-    entriesPerPage: z.ZodOptional<z.ZodNumber>;
-    archiveFile: z.ZodOptional<z.ZodString>;
-    matchString: z.ZodOptional<z.ZodString>;
-    charOffset: z.ZodOptional<z.ZodNumber>;
-    format: z.ZodDefault<z.ZodEnum<{
-        auto: "auto";
-        gzip: "gzip";
-        bzip2: "bzip2";
-        xz: "xz";
-        lzma: "lzma";
-        zstd: "zstd";
-        lz4: "lz4";
-        brotli: "brotli";
-        lzfse: "lzfse";
-    }>>;
-    minLength: z.ZodDefault<z.ZodNumber>;
-    includeOffsets: z.ZodOptional<z.ZodBoolean>;
-    scanOffset: z.ZodOptional<z.ZodNumber>;
-    id: z.ZodOptional<z.ZodString>;
-    mainResearchGoal: z.ZodOptional<z.ZodString>;
-    researchGoal: z.ZodOptional<z.ZodString>;
-    reasoning: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-export type BinaryInspectQuery = z.infer<typeof LocalBinaryInspectQuerySchema>;
-export declare const LocalBinaryInspectBulkQuerySchema: z.ZodObject<{
-    responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
-    responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
-    queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-}, z.core.$strip>;
-export declare const LocalBinaryInspectOutputSchema: z.ZodObject<{
-    results: z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        status: z.ZodOptional<z.ZodEnum<{
-            empty: "empty";
-            error: "error";
-            success: "success";
-        }>>;
-        data: z.ZodUnion<readonly [z.ZodObject<{
-            path: z.ZodString;
-            mode: z.ZodLiteral<"inspect">;
-            format: z.ZodOptional<z.ZodString>;
-            size: z.ZodOptional<z.ZodNumber>;
-            isText: z.ZodOptional<z.ZodBoolean>;
-            encoding: z.ZodOptional<z.ZodString>;
-            symbols: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            imports: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            exports: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            sections: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>, z.ZodObject<{
-            path: z.ZodString;
-            mode: z.ZodLiteral<"list">;
-            entries: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                size: z.ZodOptional<z.ZodNumber>;
-                compressedSize: z.ZodOptional<z.ZodNumber>;
-                isDir: z.ZodOptional<z.ZodBoolean>;
-                modified: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>>;
-            pagination: z.ZodOptional<z.ZodObject<{
-                currentPage: z.ZodNumber;
-                totalPages: z.ZodNumber;
-                hasMore: z.ZodBoolean;
-                nextPage: z.ZodOptional<z.ZodNumber>;
-                pageSize: z.ZodOptional<z.ZodNumber>;
-                totalItems: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-            warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>, z.ZodObject<{
-            path: z.ZodString;
-            mode: z.ZodEnum<{
-                extract: "extract";
-                decompress: "decompress";
-            }>;
-            archiveFile: z.ZodOptional<z.ZodString>;
-            content: z.ZodOptional<z.ZodString>;
-            isPartial: z.ZodOptional<z.ZodBoolean>;
-            pagination: z.ZodOptional<z.ZodObject<{
-                charOffset: z.ZodNumber;
-                charLength: z.ZodNumber;
-                totalChars: z.ZodNumber;
-                hasMore: z.ZodBoolean;
-                nextCharOffset: z.ZodOptional<z.ZodNumber>;
-                currentPage: z.ZodOptional<z.ZodNumber>;
-                totalPages: z.ZodOptional<z.ZodNumber>;
-                chunkMode: z.ZodOptional<z.ZodEnum<{
-                    semantic: "semantic";
-                    "char-limit": "char-limit";
-                }>>;
-            }, z.core.$strip>>;
-            warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>, z.ZodObject<{
-            path: z.ZodString;
-            mode: z.ZodLiteral<"strings">;
-            strings: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                value: z.ZodString;
-                offset: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>>;
-            content: z.ZodOptional<z.ZodString>;
-            totalStrings: z.ZodOptional<z.ZodNumber>;
-            scanOffset: z.ZodOptional<z.ZodNumber>;
-            nextScanOffset: z.ZodOptional<z.ZodNumber>;
-            hasMore: z.ZodOptional<z.ZodBoolean>;
-            warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>, z.ZodObject<{
-            path: z.ZodString;
-            mode: z.ZodLiteral<"unpack">;
-            localPath: z.ZodOptional<z.ZodString>;
-            fileCount: z.ZodOptional<z.ZodNumber>;
-            totalSize: z.ZodOptional<z.ZodNumber>;
-            warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>]>;
-    }, z.core.$strip>>;
-    base: z.ZodOptional<z.ZodString>;
-    shared: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
-    responsePagination: z.ZodOptional<z.ZodObject<{
-        currentPage: z.ZodNumber;
-        totalPages: z.ZodNumber;
-        hasMore: z.ZodBoolean;
-        charOffset: z.ZodNumber;
-        charLength: z.ZodNumber;
-        totalChars: z.ZodNumber;
-        nextCharOffset: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export type LocalBinaryInspectOutput = z.infer<typeof LocalBinaryInspectOutputSchema>;

package/dist/tools/local_ripgrep/lspBoost.d.ts

@@ -1,54 +0,0 @@
-/**
- * Tier 1 Phase 3 — optional, bounded LSP semantic boost for relevance ranking.
- *
- * Runs only for `sort:"relevance"` + `semanticRanking:true`, and only over the
- * top-N relevance candidates already produced by the text/AST scorer. LSP
- * enriches; it never gates. Rules (see RANKING-ARCHITECTURE.md):
- *   1. LSP never adds or removes a result — only reorders the top-N.
- *   2. Failure/timeout degrades to the existing text/AST order (graceful).
- *   3. Boosts are capped and deterministic given the resolver's output.
- *   4. An LSP boost never outweighs a strong exact declaration on its own.
- */
-import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
-import type { FileScore } from './rankingProfile.js';
-/** What LSP can tell us about a candidate's anchor symbol. */
-export interface LspSignal {
-    isDefinition?: boolean;
-    isExportedOrPublic?: boolean;
-    hasCallers?: boolean;
-    isImplementationOrType?: boolean;
-    /** Resolver couldn't anchor / server unavailable — treated as no boost. */
-    unavailable?: boolean;
-}
-/** Capped additive boosts. Sum is bounded by LSP_BOOST_CAP. */
-export declare const LSP_BOOST: {
-    readonly definition: 3;
-    readonly exportedOrPublic: 2;
-    readonly hasCallers: 1;
-    readonly implementationOrType: 1;
-    readonly cap: 5;
-};
-export declare function lspBoostScore(signal: LspSignal | null | undefined): {
-    delta: number;
-    reasons: string[];
-};
-export type LspResolver = (file: LocalSearchCodeFile) => Promise<LspSignal | null>;
-export interface SemanticBoostResult {
-    files: LocalSearchCodeFile[];
-    /** Updated debug scores (boost folded in) keyed by path, when debug is on. */
-    debug?: Map<string, FileScore>;
-    /** True if any candidate was enriched; false means full graceful degrade. */
-    enriched: boolean;
-}
-/**
- * Apply a bounded LSP boost to the top-N already-relevance-ranked files.
- *
- * `baseScores` is the Tier 1 score per path (when available). The resolver is
- * injected so this is unit-testable and the live wiring (lspGetSemantics) stays
- * out of the pure scoring path. Any resolver rejection degrades that one
- * candidate to its base order; the call never throws.
- */
-export declare function applySemanticBoost(rankedFiles: LocalSearchCodeFile[], resolve: LspResolver, opts?: {
-    topN?: number;
-    baseScores?: Map<string, FileScore>;
-}): Promise<SemanticBoostResult>;

package/dist/utils/parsers/ripgrep.d.ts

@@ -1,11 +0,0 @@
-import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
-import type { SearchStats } from '../core/types.js';
-interface RipgrepParserQuery {
-    contextLines?: number;
-    matchContentLength?: number;
-}
-export declare function parseRipgrepJson(jsonOutput: string, query: RipgrepParserQuery): {
-    files: LocalSearchCodeFile[];
-    stats: SearchStats;
-};
-export {};