@octocodeai/octocode-tools-core 17.0.2 → 18.1.0

package/dist/tools/lsp/semantic_content/semanticAnchored.d.ts

@@ -3,5 +3,11 @@ import type { SymbolAnchor } from '../shared/resolveSymbolAnchor.js';
 import type { LspSemanticEnvelope, SymbolAnchoredSemanticQuery } from '../shared/semanticTypes.js';
 declare const CONSUMER_SCOPED_TYPES: ReadonlySet<string>;
 export { CONSUMER_SCOPED_TYPES };
-export declare function warmLikelyConsumers(client: NonNullable<Awaited<ReturnType<typeof acquirePooledClient>>>, anchor: SymbolAnchor, workspaceRoot: string): Promise<void>;
-export declare function dispatchAnchoredSemantic(query: SymbolAnchoredSemanticQuery, anchor: SymbolAnchor, client: NonNullable<Awaited<ReturnType<typeof acquirePooledClient>>>): Promise<LspSemanticEnvelope>;
+export type ConsumerWarmupStats = {
+    candidates: number;
+    warmedFiles: number;
+    skippedLarge: number;
+    possiblyTruncated: boolean;
+};
+export declare function warmLikelyConsumers(client: NonNullable<Awaited<ReturnType<typeof acquirePooledClient>>>, anchor: SymbolAnchor, workspaceRoot: string): Promise<ConsumerWarmupStats>;
+export declare function dispatchAnchoredSemantic(query: SymbolAnchoredSemanticQuery, anchor: SymbolAnchor, client: NonNullable<Awaited<ReturnType<typeof acquirePooledClient>>>, warmupStats?: ConsumerWarmupStats): Promise<LspSemanticEnvelope>;

package/dist/tools/lsp/semantic_content/semanticEnvelopes/locationEnvelopes.d.ts

@@ -1,8 +1,9 @@
 import type { LSPRange, ReferenceLocation, ReferencesByFile, CodeSnippet } from '@octocodeai/octocode-engine/lsp/types';
 import { type LspSemanticEnvelope, type SymbolAnchoredSemanticQuery } from '../../shared/semanticTypes.js';
 import type { SymbolAnchor } from '../../shared/resolveSymbolAnchor.js';
+import type { ConsumerWarmupStats } from '../semanticAnchored.js';
 export declare function locationsEnvelope(query: SymbolAnchoredSemanticQuery, anchor: SymbolAnchor, kind: 'definition' | 'typeDefinition' | 'implementation', provider: string, locations: CodeSnippet[]): LspSemanticEnvelope;
-export declare function referencesEnvelope(query: SymbolAnchoredSemanticQuery, anchor: SymbolAnchor, locations: CodeSnippet[]): LspSemanticEnvelope;
+export declare function referencesEnvelope(query: SymbolAnchoredSemanticQuery, anchor: SymbolAnchor, locations: CodeSnippet[], warmupStats?: ConsumerWarmupStats): LspSemanticEnvelope;
 export declare function hoverEnvelope(_query: SymbolAnchoredSemanticQuery, anchor: SymbolAnchor, hover: unknown): Promise<LspSemanticEnvelope>;
 export declare function buildReferencesByFile(locations: readonly ReferenceLocation[]): ReferencesByFile[];
 export declare function normalizeHover(hover: unknown): {

package/dist/tools/lsp/semantic_content/semanticFileOps/anchor.d.ts

@@ -9,7 +9,10 @@ export declare function isNativeJsTsFile(uri: string): boolean;
  * search instead. documentSymbols/structural search keep their tree-sitter path
  * and never reach here.
  */
-export declare function throwLspUnavailable(uri: string, op: SemanticContentType): never;
+export declare function throwLspUnavailable(uri: string, op: SemanticContentType, detail?: {
+    kind?: string;
+    message?: string;
+}): never;
 export declare function toLocalPath(value: string, workspaceRoot: string): string;
 export declare function workspaceSymbolAnchorExtensions(): string[];
 export declare function workspaceSymbolAnchorIncludeGlobs(): string[];
@@ -22,3 +25,16 @@ export declare function lspErrorMessage(error: unknown): string;
  * to the "no symbols" empty state.
  */
 export declare function nativeDocumentSymbols(uri: string, content: string): unknown[] | null;
+/**
+ * Fallback document-symbol source for JS/TS files oxc's full-fidelity symbol
+ * extractor (`extractJsSymbols`) declines — notably Flow-typed `.js` (Flow
+ * syntax like type annotations/generics can make oxc's default JS grammar
+ * fail the whole-file parse, returning an empty body). `extractGraphFacts`
+ * uses a more lenient extraction already proven elsewhere (localFindDeadCode)
+ * to tolerate this exact file class, and its declarations already carry
+ * 0-based LSP `range`s — so they slot into the same DocumentSymbol shape
+ * `nativeDocumentSymbols` produces, just without a full symbol hierarchy
+ * (flat top-level declarations only; `kind` is used as-is by `symbolKindName`,
+ * which already passes string kinds through unchanged).
+ */
+export declare function graphFactsDocumentSymbols(uri: string, content: string): unknown[] | null;

package/dist/tools/lsp/semantic_content/semanticNext.d.ts

@@ -0,0 +1,2 @@
+import { type LspGetSemanticsQuery, type LspSemanticEnvelope } from '../shared/semanticTypes.js';
+export declare function withSemanticNext(query: LspGetSemanticsQuery, result: LspSemanticEnvelope | Record<string, unknown>): LspSemanticEnvelope | Record<string, unknown>;

package/dist/tools/lsp/semantic_content/semanticPresentation.d.ts

@@ -21,7 +21,7 @@ export type CompactCall = {
 };
 export declare function attachSemanticRawEvidence<T extends object>(result: T): T;
 export declare function formatSemanticResult(query: LspGetSemanticsQuery, result: LspSemanticEnvelope | Record<string, unknown>): LspSemanticEnvelope | Record<string, unknown>;
-export declare function withSemanticNext(result: LspSemanticEnvelope | Record<string, unknown>): LspSemanticEnvelope | Record<string, unknown>;
+export { withSemanticNext } from './semanticNext.js';
 export declare function isSemanticEnvelope(value: LspSemanticEnvelope | Record<string, unknown>): value is LspSemanticEnvelope;
 export declare function compactSemanticEnvelope(envelope: LspSemanticEnvelope): LspSemanticEnvelope;
 export declare function compactSemanticPayload(payload: LspSemanticEnvelope['payload']): LspSemanticEnvelope['payload'];

package/dist/tools/lsp/shared/callHierarchyTraversal.d.ts

@@ -3,9 +3,21 @@ import type { CallHierarchyItem, IncomingCall, OutgoingCall } from '@octocodeai/
 export type TraversalResult<T> = {
     calls: T[];
     truncatedByDepth: boolean;
+    truncatedByBudget: boolean;
+    visitedNodeCount: number;
+    requestCount: number;
     cycleCount: number;
     failedRequestCount: number;
 };
+export type TraversalBudget = {
+    maxNodes: number;
+    maxRequests: number;
+};
+export type MutableTraversalBudget = TraversalBudget & {
+    visitedNodeCount: number;
+    requestCount: number;
+    truncatedByBudget: boolean;
+};
 export declare function createCallItemKey(item: CallHierarchyItem): string;
-export declare function gatherIncomingCallsRecursive(client: LSPClient | null, item: CallHierarchyItem, remainingDepth: number, visited: Set<string>, contextLines: number): Promise<TraversalResult<IncomingCall>>;
-export declare function gatherOutgoingCallsRecursive(client: LSPClient | null, item: CallHierarchyItem, remainingDepth: number, visited: Set<string>, contextLines: number): Promise<TraversalResult<OutgoingCall>>;
+export declare function gatherIncomingCallsRecursive(client: LSPClient | null, item: CallHierarchyItem, remainingDepth: number, visited: Set<string>, contextLines: number, budget?: MutableTraversalBudget): Promise<TraversalResult<IncomingCall>>;
+export declare function gatherOutgoingCallsRecursive(client: LSPClient | null, item: CallHierarchyItem, remainingDepth: number, visited: Set<string>, contextLines: number, budget?: MutableTraversalBudget): Promise<TraversalResult<OutgoingCall>>;

package/dist/tools/lsp/shared/semanticTypes.d.ts

@@ -46,6 +46,9 @@ export type ResolvedSymbol = {
     orderHint?: number;
     position: ExactPosition;
     isAmbiguous?: boolean;
+    /** Lines between the caller's lineHint and the line actually bound —
+     * present only when nonzero, so a stale hint is visible in the result. */
+    lineDeviation?: number;
 };
 export type CompactResolvedSymbol = {
     name: string;
@@ -53,6 +56,7 @@ export type CompactResolvedSymbol = {
     foundAtLine: number;
     orderHint?: number;
     isAmbiguous?: boolean;
+    lineDeviation?: number;
 };
 export declare function compactResolvedSymbol(symbol: ResolvedSymbol): CompactResolvedSymbol;
 export type CompactLocation = {
@@ -99,6 +103,12 @@ export type LspSemanticEnvelope = {
         byFile?: unknown[];
         totalReferences: number;
         totalFiles: number;
+        warmup?: {
+            candidates: number;
+            warmedFiles: number;
+            skippedLarge: number;
+            possiblyTruncated: boolean;
+        };
         empty?: SemanticEmptyState;
     } | {
         kind: 'callers' | 'callees' | 'callHierarchy';
@@ -110,6 +120,9 @@ export type LspSemanticEnvelope = {
         completeness: {
             complete: boolean;
             truncatedByDepth: boolean;
+            truncatedByBudget?: boolean;
+            visitedNodeCount?: number;
+            requestCount?: number;
             cycleCount: number;
             failedRequestCount: number;
             dynamicCallsExcluded: true;
@@ -165,6 +178,6 @@ export type LspSemanticEnvelope = {
         tool: string;
         query: Record<string, unknown>;
         why?: string;
-        confidence?: 'exact' | 'heuristic';
+        confidence?: 'exact' | 'high' | 'medium' | 'low';
     }>;
 };

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

@@ -2,8 +2,17 @@ import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 import type { z } from 'zod';
 import type { NpmPackageQuerySchema } from '@octocodeai/octocode-core/schemas';
 type NpmSearchQuery = z.input<typeof NpmPackageQuerySchema>;
+export { foldKeywords, isPackageNotFoundError } from './queryHelpers.js';
 import type { PackageResult } from '../../utils/package/common.js';
 import type { ToolExecutionArgs } from '../../types/execution.js';
+/**
+ * Normalize the many repository URL shapes npm packages carry
+ * (ssh://git@…, git+https://…, git://…, git@host:owner/repo, and npm's
+ * `github:owner/repo` / `gitlab:` / `bitbucket:` shorthands) into a
+ * canonical `https://host/owner/repo` form. Falls back to the cleaned
+ * original when the shape is unrecognized.
+ */
+export declare function normalizeRepoUrl(url: string | null | undefined): string | undefined;
 type PackageData = {
     name: string;
     version?: string;
@@ -15,11 +24,6 @@ type PackageData = {
     repositoryId?: string;
     next?: Record<string, unknown>;
     warnings?: string[];
-    diagnostics?: Array<{
-        level: 'info' | 'warning' | 'error';
-        message: string;
-        code?: string;
-    }>;
 };
 type PackageRepositoryData = {
     repository: string;
@@ -45,4 +49,3 @@ type PackagePagination = {
 };
 export declare function buildPackagePagination(query: NpmSearchQuery, totalFound: number, returned: number, isKeyword: boolean): PackagePagination;
 export declare function searchPackages(args: ToolExecutionArgs<NpmSearchQuery>): Promise<CallToolResult>;
-export {};

package/dist/tools/package_search/queryHelpers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Fold a `keywords` field (string as-is, or an array joined with spaces) into a
+ * single registry query string. Sibling tools (ghSearchCode/localSearchCode)
+ * take keyword arrays, so agents pass arrays here too — the scheme accepts both
+ * shapes and this is where the array is collapsed. Returns undefined when empty.
+ */
+export declare function foldKeywords(keywords: string | string[] | undefined): string | undefined;
+export declare function isPackageNotFoundError(message: string): boolean;

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

@@ -1,6 +1,9 @@
 import { z } from 'zod';
+import type { ItemPagination, ToolContinuation } from '../../scheme/pagination.js';
+import type { BulkToolOutput } from '../../types/toolOutput.js';
 export declare const NpmSearchQueryLocalSchema: z.ZodObject<{
     packageName: z.ZodString;
+    keywords: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
     page: z.ZodDefault<z.ZodNumber>;
     id: z.ZodOptional<z.ZodString>;
     mainResearchGoal: z.ZodOptional<z.ZodString>;
@@ -12,89 +15,30 @@ export declare const NpmSearchBulkQueryLocalSchema: z.ZodObject<{
     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 NpmSearchOutputLocalSchema: z.ZodObject<{
-    results: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodString;
-        data: z.ZodOptional<z.ZodObject<{
-            packages: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                name: z.ZodString;
-                version: z.ZodOptional<z.ZodString>;
-                description: z.ZodOptional<z.ZodString>;
-                license: z.ZodOptional<z.ZodString>;
-                downloads: z.ZodOptional<z.ZodNumber>;
-                repository: z.ZodOptional<z.ZodString>;
-                repositoryDirectory: z.ZodOptional<z.ZodString>;
-                repositoryId: z.ZodOptional<z.ZodString>;
-                next: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-                    tool: z.ZodString;
-                    query: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                    why: z.ZodOptional<z.ZodString>;
-                    confidence: z.ZodOptional<z.ZodEnum<{
-                        exact: "exact";
-                        heuristic: "heuristic";
-                    }>>;
-                }, z.core.$strip>>>;
-                warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
-                    level: z.ZodEnum<{
-                        error: "error";
-                        info: "info";
-                        warning: "warning";
-                    }>;
-                    message: z.ZodString;
-                    field: z.ZodOptional<z.ZodString>;
-                    code: z.ZodOptional<z.ZodString>;
-                }, z.core.$strip>>>;
-            }, z.core.$loose>>>;
-            repositories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-                repository: z.ZodString;
-                owner: z.ZodString;
-                repo: z.ZodString;
-                repositoryDirectory: z.ZodOptional<z.ZodString>;
-                next: z.ZodRecord<z.ZodString, z.ZodObject<{
-                    tool: z.ZodString;
-                    query: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-                    why: z.ZodOptional<z.ZodString>;
-                    confidence: z.ZodOptional<z.ZodEnum<{
-                        exact: "exact";
-                        heuristic: "heuristic";
-                    }>>;
-                }, z.core.$strip>>;
-            }, z.core.$loose>>>;
-            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>;
-                perPage: z.ZodOptional<z.ZodNumber>;
-                totalFound: z.ZodOptional<z.ZodNumber>;
-                returned: z.ZodOptional<z.ZodNumber>;
-                totalMatches: z.ZodOptional<z.ZodNumber>;
-                reportedTotalMatches: z.ZodOptional<z.ZodNumber>;
-                reachableTotalMatches: z.ZodOptional<z.ZodNumber>;
-                totalMatchesKind: z.ZodOptional<z.ZodEnum<{
-                    exact: "exact";
-                    reported: "reported";
-                    lowerBound: "lowerBound";
-                }>>;
-                totalMatchesCapped: z.ZodOptional<z.ZodBoolean>;
-                totalResults: z.ZodOptional<z.ZodNumber>;
-                itemsPerPage: z.ZodOptional<z.ZodNumber>;
-            }, z.core.$strip>>;
-        }, z.core.$loose>>;
-        status: z.ZodOptional<z.ZodString>;
-    }, z.core.$loose>>>;
-    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 interface NpmSearchPackage {
+    name: string;
+    version?: string;
+    description?: string;
+    license?: string;
+    downloads?: number;
+    repository?: string;
+    repositoryDirectory?: string;
+    repositoryId?: string;
+    next?: Record<string, ToolContinuation>;
+    [key: string]: unknown;
+}
+export interface NpmSearchRepository {
+    repository: string;
+    owner: string;
+    repo: string;
+    repositoryDirectory?: string;
+    next: Record<string, ToolContinuation>;
+    [key: string]: unknown;
+}
+export interface NpmSearchData {
+    packages?: NpmSearchPackage[];
+    repositories?: Record<string, NpmSearchRepository>;
+    pagination?: ItemPagination;
+    [key: string]: unknown;
+}
+export type NpmSearchOutputLocal = BulkToolOutput<NpmSearchData>;

package/dist/tools/providerMappers/codeSearch.d.ts

@@ -34,7 +34,6 @@ export interface CodeSearchGroupedMatch {
         end: number;
         lineOffset: number;
     }>;
-    url?: string;
 }
 export interface CodeSearchGroupedResult {
     id: string;

package/dist/tools/providerMappers/pullRequests.d.ts

@@ -14,15 +14,10 @@ export declare function mapPullRequestToolQuery(query: PartialPRQuery): {
     author: string;
     assignee: string;
     commenter: string;
-    involves: string;
     mentions: string;
     reviewRequested: string;
     reviewedBy: string;
     labels: string[];
-    noLabel: boolean;
-    noMilestone: boolean;
-    noProject: boolean;
-    noAssignee: boolean;
     baseBranch: string;
     headBranch: string;
     created: string;
@@ -31,17 +26,10 @@ export declare function mapPullRequestToolQuery(query: PartialPRQuery): {
     mergedAt: string;
     comments: string;
     reactions: string;
-    interactions: string;
     draft: boolean;
     match: ("title" | "body" | "comments")[];
-    milestone: string;
-    language: string;
     checks: "success" | "failure" | "pending";
     review: "none" | "approved" | "changes_requested" | "required";
-    locked: boolean;
-    visibility: "public" | "private";
-    teamMentions: string;
-    project: string;
     archived: boolean | undefined;
     content: unknown;
     reviewMode: "full" | "summary";
@@ -111,7 +99,6 @@ export declare function mapPullRequestProviderResultData(data: ProviderPullReque
             line?: number;
             in_reply_to_id?: number;
         }[];
-        url: string;
         state: "open" | "closed" | "merged";
         draft: boolean;
         author: string;

package/dist/tools/providerMappers/repoSearch.d.ts

@@ -9,17 +9,13 @@ export declare function mapRepoSearchToolQuery(query: WithOptionalMeta<GitHubRep
     topics: string[];
     owner: string;
     stars: string;
-    size: string;
-    created: string;
     updated: string;
     language: string;
     archived: boolean | undefined;
     visibility: "public" | "private" | undefined;
-    forks: string | undefined;
     license: string | undefined;
-    goodFirstIssues: string | undefined;
     match: ("description" | "name" | "readme")[];
-    sort: "stars" | "forks" | "updated" | "created" | "best-match" | undefined;
+    sort: "updated" | "best-match" | "stars" | "forks" | "help-wanted-issues";
     limit: number | undefined;
     page: number;
     mainResearchGoal: string;

package/dist/tools/providerMappers/repoStructure.d.ts

@@ -12,6 +12,10 @@ export declare function mapRepoStructureToolQuery(query: PartialRepoStructureQue
     itemsPerPage: number;
     page: number;
     includeSizes: boolean;
+    includeLanguages: boolean;
+    includeContributors: boolean;
+    includeBranches: boolean;
+    includeTags: boolean;
     mainResearchGoal: string;
     researchGoal: string;
     reasoning: string;

package/dist/tools/toolCatalogFactory.d.ts

@@ -0,0 +1,25 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ToolNames } from '@octocodeai/octocode-core/types';
+import { type z } from 'zod';
+import { type ToolMetadataGateway } from './toolMetadata/gateway.js';
+export type ToolDirectSecurity = 'basic' | 'remote';
+export interface ToolDirectExecutionConfig {
+    schema: z.ZodType;
+    inputSchema: z.ZodType;
+    executionFn: (input: never) => Promise<CallToolResult>;
+    security: ToolDirectSecurity;
+    requiresServerRuntime?: boolean;
+    requiresProviders?: boolean;
+}
+export interface ToolConfig {
+    name: string;
+    description: string;
+    isDefault: boolean;
+    isLocal: boolean;
+    isClone?: boolean;
+    type: 'search' | 'content' | 'history' | 'debug';
+    skipMetadataCheck?: boolean;
+    direct: ToolDirectExecutionConfig;
+}
+export declare const getDescription: (toolName: string, gateway?: Pick<ToolMetadataGateway, "getDescription">) => string;
+export declare function createTool(gateway: ToolMetadataGateway, nameKey: keyof ToolNames, config: Omit<ToolConfig, 'name' | 'description'>): ToolConfig;

package/dist/tools/toolConfig.d.ts

@@ -1,40 +1,25 @@
-import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { type z } from 'zod';
 import { DEFAULT_TOOL_METADATA_GATEWAY, type ToolMetadataGateway } from './toolMetadata/gateway.js';
+import { getDescription, type ToolConfig, type ToolDirectExecutionConfig, type ToolDirectSecurity } from './toolCatalogFactory.js';
 export type { ToolMetadataGateway };
 export { DEFAULT_TOOL_METADATA_GATEWAY };
+export { getDescription };
+export type { ToolConfig, ToolDirectExecutionConfig, ToolDirectSecurity };
 export type { ToolInvocationCallback } from '../types/toolResults.js';
-export type ToolDirectSecurity = 'basic' | 'remote';
-export interface ToolDirectExecutionConfig {
-    schema: z.ZodType;
-    inputSchema: z.ZodType;
-    executionFn: (input: never) => Promise<CallToolResult>;
-    security: ToolDirectSecurity;
-    requiresServerRuntime?: boolean;
-    requiresProviders?: boolean;
-}
-export interface ToolConfig {
-    name: string;
-    description: string;
-    isDefault: boolean;
-    isLocal: boolean;
-    isClone?: boolean;
-    type: 'search' | 'content' | 'history' | 'debug';
-    skipMetadataCheck?: boolean;
-    direct: ToolDirectExecutionConfig;
-}
-export declare const getDescription: (toolName: string, gateway?: Pick<ToolMetadataGateway, "getDescription">) => string;
 export declare const GITHUB_SEARCH_CODE: ToolConfig;
 export declare const GITHUB_FETCH_CONTENT: ToolConfig;
 export declare const GITHUB_VIEW_REPO_STRUCTURE: ToolConfig;
 export declare const GITHUB_SEARCH_REPOSITORIES: ToolConfig;
-export declare const GITHUB_SEARCH_PULL_REQUESTS: ToolConfig;
+export declare const GITHUB_PULL_REQUESTS: ToolConfig;
+export declare const GITHUB_ISSUES: ToolConfig;
+export declare const GITHUB_COMMITS: ToolConfig;
+export declare const GITHUB_RELEASES: ToolConfig;
+export declare const GITHUB_DISCUSSIONS: ToolConfig;
 export declare const PACKAGE_SEARCH: ToolConfig;
 export declare const GITHUB_CLONE_REPO: ToolConfig;
 export declare const LOCAL_RIPGREP: ToolConfig;
 export declare const LOCAL_VIEW_STRUCTURE: ToolConfig;
 export declare const LOCAL_FIND_FILES: ToolConfig;
+export declare const LOCAL_FIND_DEAD_CODE: ToolConfig;
 export declare const LOCAL_FETCH_CONTENT: ToolConfig;
 export declare const LSP_GET_SEMANTIC_CONTENT: ToolConfig;
-export declare const OQL_SEARCH: ToolConfig;
 export declare const ALL_TOOLS: ToolConfig[];

package/dist/tools/toolNames.d.ts

@@ -1,5 +1,5 @@
 export declare const STATIC_TOOL_NAMES: import("@octocodeai/octocode-core/types").ToolNames;
 export declare const LSP_GET_SEMANTICS_TOOL_NAME: "lspGetSemantics";
-export declare const OQL_SEARCH_TOOL_NAME = "oqlSearch";
-export declare function isOqlEnabled(env?: NodeJS.ProcessEnv): boolean;
+export declare function isReleasesEnabled(env?: NodeJS.ProcessEnv): boolean;
+export declare function isDiscussionsEnabled(env?: NodeJS.ProcessEnv): boolean;
 export declare function isLocalTool(toolName: string): boolean;

package/dist/tools/toolSchemaImports.d.ts

@@ -2,12 +2,14 @@ export { CloneRepoQueryLocalSchema, BulkCloneRepoLocalSchema, } from './github_c
 export { FileContentQueryLocalSchema, FileContentBulkQueryLocalSchema, } from './github_fetch_content/scheme.js';
 export { GitHubCodeSearchQueryLocalSchema, GitHubCodeSearchBulkQueryLocalSchema, } from './github_search_code/scheme.js';
 export { GitHubPullRequestSearchQueryLocalSchema, GitHubPullRequestSearchBulkQueryLocalSchema, } from './github_search_pull_requests/scheme.js';
+export { SearchPullRequestsLocalSchema, SearchPullRequestsBulkLocalSchema, SearchIssuesLocalSchema, SearchIssuesBulkLocalSchema, SearchCommitsLocalSchema, SearchCommitsBulkLocalSchema, ListReleasesLocalSchema, ListReleasesBulkLocalSchema, } from './github_search_pull_requests/splitSchemes.js';
+export { SearchDiscussionsLocalSchema, SearchDiscussionsBulkLocalSchema, } from './github_search_discussions/scheme.js';
 export { GitHubReposSearchSingleQueryLocalSchema, GitHubReposSearchBulkQueryLocalSchema, } from './github_search_repos/scheme.js';
 export { GitHubViewRepoStructureQueryLocalSchema, GitHubViewRepoStructureBulkQueryLocalSchema, } from './github_view_repo_structure/scheme.js';
 export { NpmSearchQueryLocalSchema, NpmSearchBulkQueryLocalSchema, } from './package_search/scheme.js';
 export { LocalFetchContentQuerySchema, LocalFetchContentBulkQuerySchema, } from './local_fetch_content/scheme.js';
 export { LocalFindFilesQuerySchema, LocalFindFilesBulkQuerySchema, } from './local_find_files/scheme.js';
+export { LocalFindDeadCodeQuerySchema, LocalFindDeadCodeBulkQuerySchema, } from './local_dead_code/scheme.js';
 export { LocalRipgrepQuerySchema, LocalRipgrepBulkQuerySchema, } from './local_ripgrep/scheme.js';
 export { LocalViewStructureQuerySchema, LocalViewStructureBulkQuerySchema, } from './local_view_structure/scheme.js';
 export { BulkLspGetSemanticsQuerySchema, LspGetSemanticsQueryDisplaySchema, } from './lsp/semantic_content/scheme.js';
-export { OqlDisplayQuerySchema as OqlSearchQuerySchema, OqlSearchInputSchema, } from '../oql/schema.js';

package/dist/types/execution.d.ts

@@ -6,5 +6,6 @@ export interface ToolExecutionArgs<TQuery> {
     responseCharLength?: number;
     authInfo?: AuthInfo;
     sessionId?: string;
+    signal?: AbortSignal;
     hintContext?: Record<string, unknown>;
 }

package/dist/types/toolOutput.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Hand-written output TYPES for the direct tools.
+ *
+ * The per-tool zod OUTPUT schemas were removed: the MCP server registers no
+ * outputSchema (see octocode-mcp registerBasicTool), so they validated nothing
+ * at runtime, duplicated the tool result shapes, and forced every output-shape
+ * change to be made in twelve places. Tools keep a plain TypeScript output
+ * type instead — one shared envelope generic plus a per-tool `data` interface.
+ *
+ * INPUT/query schemas are unaffected: those are registered and parsed, so they
+ * stay as zod.
+ */
+import type { ToolContinuation } from '../scheme/pagination.js';
+/** Outermost char-window pagination wrapping a whole bulk response. */
+export interface ResponsePaginationInfo {
+    currentPage: number;
+    totalPages: number;
+    hasMore: boolean;
+    charOffset: number;
+    charLength: number;
+    totalChars: number;
+    nextCharOffset?: number;
+}
+/** One result row in a bulk tool response. */
+export interface BulkToolResultRow<TData> {
+    id: string;
+    status?: 'empty' | 'error';
+    data: TData;
+    next?: Record<string, ToolContinuation>;
+}
+/** The shared bulk envelope every direct tool returns, parameterized by its per-query `data` payload. */
+export interface BulkToolOutput<TData> {
+    results: Array<BulkToolResultRow<TData>>;
+    base?: string;
+    shared?: Record<string, string | number | boolean>;
+    responsePagination?: ResponsePaginationInfo;
+    next?: Record<string, ToolContinuation>;
+}

package/dist/utils/contextUtils.d.ts

@@ -49,6 +49,12 @@ export declare const contextUtils: {
     getGraphFactCapabilities(): string;
     structuralSearch(content: string, filePath: string, pattern?: string | null, rule?: string | null): Promise<NativeContextUtils.StructuralMatch[]>;
     structuralSearchFiles(options: NativeContextUtils.StructuralSearchFilesOptions): Promise<NativeContextUtils.StructuralSearchFilesResult>;
+    /**
+     * Detailed structural search: same matching as structuralSearchFiles plus a
+     * query explanation (kind, literal anchor, pre-filter mode) and staged
+     * diagnostics with recovery hints — the payload zero-match guidance needs.
+     */
+    structuralSearchFilesDetailed(options: NativeContextUtils.StructuralSearchFilesOptions): NativeContextUtils.StructuralSearchFilesDetailedResult;
     getSupportedStructuralExtensions(): string[];
     validateRipgrepPattern(pattern: string, fixedString?: boolean | null, perlRegex?: boolean | null): NativeContextUtils.RipgrepPatternValidationResult;
     getSemanticBoundaryOffsets(content: string, filePath: string): Promise<number[]>;

package/dist/utils/core/types.d.ts

@@ -29,6 +29,10 @@ export interface SearchStats {
     filesSearched?: number;
     bytesSearched?: number;
     searchTime?: string;
+    /** The scan consumed its entire maxFiles candidate budget — totals reflect
+     * only the scanned subset and may understate the true count; raise maxFiles
+     * to count exhaustively. (Typed signal: responses carry no warnings.) */
+    capReached?: boolean;
 }
 export interface CacheStats {
     hits: number;