@octocodeai/octocode-tools-core 16.6.3 → 17.0.2

package/dist/oql/adapters/github/execute.d.ts

@@ -0,0 +1,16 @@
+import type { AdapterResult } from '../local.js';
+import type { OqlQuery } from '../../types.js';
+/**
+ * GitHub `files` lane: list files via path-level code search. Positive
+ * text/regex predicates list files *containing* a term (approximate); path-like
+ * field equality (`basename`/`extension`/`path` "=") lists files by provider
+ * path qualifier (the same route as OQL target:"files" path discovery). Predicates the
+ * provider cannot enumerate by (other field ops, structural/PCRE2, negation,
+ * boolean) are routed to materialization by the planner and should not reach
+ * here; if one does, report `requiresMaterialization` rather than silently
+ * returning nothing.
+ */
+export declare function githubFiles(query: OqlQuery): Promise<AdapterResult>;
+export declare function githubCode(query: OqlQuery): Promise<AdapterResult>;
+export declare function githubContent(query: OqlQuery): Promise<AdapterResult>;
+export declare function githubStructure(query: OqlQuery): Promise<AdapterResult>;

package/dist/oql/adapters/github/provider-diagnostics.d.ts

@@ -0,0 +1,14 @@
+/**
+ * GitHub provider adapter — status/error classification. Turns a raw
+ * `CallToolResult` from a GitHub tool runner into OQL diagnostics: provider
+ * failures (rate limit / auth / invalid query), zero-match status, and the
+ * "empty result is not proof" guard for provider reads/searches.
+ */
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { OqlDiagnostic } from '../../types.js';
+/**
+ * Status + gated empty-provider diagnostics. A provider failure (rate limit,
+ * auth, invalid query) already explains the empty result — emitting
+ * providerUnindexed on top would misread a 403/429 as "repo not indexed".
+ */
+export declare function providerDiagnostics(result: CallToolResult, rowCount: number, backend: string): OqlDiagnostic[];

package/dist/oql/adapters/github/shared.d.ts

@@ -0,0 +1,75 @@
+/**
+ * GitHub provider adapter — shared types and pure helpers used by the
+ * per-lane execute functions (code/files/content/structure). Kept separate
+ * from provider-error/status classification (see ./provider-diagnostics.ts).
+ */
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { GitHubFileContentData } from '@octocodeai/octocode-core/types';
+import type { ToolPaginationPayload } from '../pagination.js';
+import type { OqlQuery, OqlTreeResultRow, QuerySource } from '../../types.js';
+export type GitHubContentPagination = {
+    currentPage?: number;
+    totalPages?: number;
+    hasMore?: boolean;
+    charOffset?: number;
+    charLength?: number;
+    totalChars?: number;
+};
+export type GitHubContentRow = GitHubFileContentData & {
+    pagination?: GitHubContentPagination;
+};
+export declare function splitRepo(source: QuerySource | undefined): {
+    owner?: string;
+    repo?: string;
+};
+/** Pull the single query's `data` payload from a bulk CallToolResult. */
+export declare function extractData<T>(result: CallToolResult): T | undefined;
+export declare function extractStatus(result: CallToolResult): string | undefined;
+export interface GithubStructureEntry {
+    dir?: string;
+    files?: readonly string[];
+    folders?: readonly string[];
+}
+export interface GithubCodeSearchMatch {
+    value?: string;
+    matchIndices?: Array<{
+        start: number;
+        end: number;
+        lineOffset?: number;
+    }>;
+}
+export interface GithubCodeSearchFile {
+    owner?: string;
+    repo?: string;
+    queryId?: string;
+    path: string;
+    matches?: readonly GithubCodeSearchMatch[];
+}
+export interface GithubCodeSearchPayload {
+    files?: readonly (GithubCodeSearchFile | string)[];
+    pagination?: ToolPaginationPayload;
+}
+export declare function cleanRepoPath(part: string | undefined): string;
+export declare function joinRepoPath(...parts: Array<string | undefined>): string;
+export declare function normalizeStructure(structure: readonly GithubStructureEntry[] | Record<string, {
+    files?: readonly string[];
+    folders?: readonly string[];
+}> | undefined): GithubStructureEntry[];
+export declare function structureDepth(pathValue: string): number;
+export declare function normalizeExtension(value: string): string;
+export declare function fileExtension(pathValue: string): string;
+export declare function escapeRegex(value: string): string;
+export declare function treePatternMatches(pathValue: string, pattern: string): boolean;
+export declare function filterGithubTreeRows(rows: readonly OqlTreeResultRow[], query: OqlQuery): OqlTreeResultRow[];
+export declare function githubCodeFilePath(file: GithubCodeSearchFile | string): string;
+export declare function githubCodeFileMetadata(file: GithubCodeSearchFile | string): Record<string, unknown> | undefined;
+export declare function githubCodeFileMatches(file: GithubCodeSearchFile | string): readonly GithubCodeSearchMatch[];
+/** GitHub source, guaranteed by dispatch. */
+export type GithubSource = Extract<QuerySource, {
+    kind: 'github';
+}>;
+export declare function ghFrom(query: OqlQuery): GithubSource;
+export declare function normalizeContentRange(range: NonNullable<NonNullable<OqlQuery['fetch']>['content']>['range']): {
+    startLine?: number;
+    endLine?: number;
+};

package/dist/oql/adapters/github.d.ts

@@ -1,3 +1,14 @@
+/**
+ * GitHub provider adapter: compile a canonical OQL query into the existing
+ * GitHub tool runners and map their results. Provider-only lanes (text search,
+ * content read, tree). Local-only predicates over GitHub are handled by the
+ * materialization adapter, not here.
+ *
+ * This file is a thin barrel/orchestrator — the per-lane implementations live
+ * under ./github/ (execute.ts for the code/files/content/structure lanes,
+ * provider-diagnostics.ts for status/error classification, shared.ts for
+ * common helpers and types).
+ */
 import type { AdapterResult } from './local.js';
 import type { OqlQuery } from '../types.js';
 export declare function executeGithub(query: OqlQuery): Promise<AdapterResult>;

package/dist/oql/adapters/graphView/filters.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Graph-view filter logic: parsing `GraphFilters` from raw query params,
+ * matching packets/subjects/relations against them, and the node/fact/edge
+ * accumulator helpers shared by the graph builder and the native-edge
+ * overlay (nativeEdges.ts).
+ */
+import type { EvidenceEdge, EvidenceFact, EvidenceSubject, MissingProof, ResearchEvidencePacket } from '../../research/packets.js';
+export type GraphDirection = 'incoming' | 'outgoing' | 'both';
+export interface GraphFilters {
+    subject?: string;
+    subjectKind?: string;
+    relations?: ReadonlySet<string>;
+    verdicts?: ReadonlySet<string>;
+    direction: GraphDirection;
+    includePackets: boolean;
+    includeFacts: boolean;
+    includeEdges: boolean;
+}
+export declare function graphFilters(p: Record<string, unknown>): GraphFilters;
+export declare function relationAllowed(relation: string | undefined, filters: GraphFilters): boolean;
+export declare function packetMatchesGraphFilters(packet: ResearchEvidencePacket, filters: GraphFilters): boolean;
+export declare function addNode(nodes: Map<string, EvidenceSubject>, subject: EvidenceSubject): void;
+export declare function addFact(facts: Map<string, EvidenceFact>, fact: EvidenceFact, filters: GraphFilters): void;
+export declare function addEdge(nodes: Map<string, EvidenceSubject>, edges: Map<string, EvidenceEdge>, edge: EvidenceEdge, filters: GraphFilters): void;
+export declare function missingProofKey(proof: MissingProof): string;

package/dist/oql/adapters/graphView/nativeEdges.d.ts

@@ -0,0 +1,5 @@
+import type { analyzeResearchFlow } from '../../research/analyze.js';
+import type { EvidenceEdge, EvidenceSubject } from '../../research/packets.js';
+import { type GraphFilters } from './filters.js';
+export declare function nativeGraphSummary(facts: Awaited<ReturnType<typeof analyzeResearchFlow>>['graphFacts']): Record<string, number>;
+export declare function addNativeGraphEdges(root: string, graphFacts: Awaited<ReturnType<typeof analyzeResearchFlow>>['graphFacts'], visibleNodeIds: ReadonlySet<string>, nodes: Map<string, EvidenceSubject>, edges: Map<string, EvidenceEdge>, filters: GraphFilters): void;

package/dist/oql/adapters/graphView.d.ts

@@ -1,28 +1,29 @@
+/**
+ * Graph-view construction for the `research`/`graph` targets: packet paging,
+ * graph filters, node/edge/fact tree building, and native AST edge overlay.
+ *
+ * Pure over research packets + native graph facts — no tool invocation here
+ * (LSP proof escalation lives in graphProof.ts; the execute* adapters stay in
+ * researchTargets.ts).
+ *
+ * Filter parsing/matching lives in graphView/filters.ts; the native AST edge
+ * overlay lives in graphView/nativeEdges.ts. This file re-exports the public
+ * surface and owns the orchestration (`buildGraphView`) that combines them.
+ */
 import type { analyzeResearchFlow } from '../research/analyze.js';
-import type { ResearchEvidencePacket, ResearchGraphSummary } from '../research/packets.js';
+import { type ResearchEvidencePacket, type ResearchGraphSummary } from '../research/packets.js';
 import type { OqlGraphData, OqlQuery, Pagination } from '../types.js';
+import { type GraphFilters } from './graphView/filters.js';
+export type { GraphDirection, GraphFilters } from './graphView/filters.js';
+export { graphFilters, packetMatchesGraphFilters, } from './graphView/filters.js';
+export { nativeGraphSummary } from './graphView/nativeEdges.js';
 export declare function packetPage(query: OqlQuery, totalItems: number): {
     packetsStart: number;
     packetsEnd: number;
     pagination: Pagination;
 };
-type GraphDirection = 'incoming' | 'outgoing' | 'both';
-export interface GraphFilters {
-    subject?: string;
-    subjectKind?: string;
-    relations?: ReadonlySet<string>;
-    verdicts?: ReadonlySet<string>;
-    direction: GraphDirection;
-    includePackets: boolean;
-    includeFacts: boolean;
-    includeEdges: boolean;
-}
-export declare function graphFilters(p: Record<string, unknown>): GraphFilters;
-export declare function packetMatchesGraphFilters(packet: ResearchEvidencePacket, filters: GraphFilters): boolean;
 export declare function buildGraphView(query: OqlQuery, packets: ResearchEvidencePacket[], graphSummary: ResearchGraphSummary, filters: GraphFilters, nativeGraphFacts: Awaited<ReturnType<typeof analyzeResearchFlow>>['graphFacts'], root: string): {
     data: OqlGraphData;
     pagination: Pagination;
 };
-export declare function nativeGraphSummary(facts: Awaited<ReturnType<typeof analyzeResearchFlow>>['graphFacts']): Record<string, number>;
 export declare function summarizePacketGraph(packets: readonly ResearchEvidencePacket[]): ResearchGraphSummary;
-export {};

package/dist/oql/adapters/local/code.d.ts

@@ -0,0 +1,3 @@
+import type { OqlQuery, QuerySource } from '../../types.js';
+import type { AdapterResult } from './types.js';
+export declare function executeCode(query: OqlQuery, source: QuerySource, searchPath: string): Promise<AdapterResult>;

package/dist/oql/adapters/local/codeBoolean.d.ts

@@ -0,0 +1,3 @@
+import type { OqlQuery, Predicate, QuerySource } from '../../types.js';
+import type { AdapterResult } from './types.js';
+export declare function executeCodeBoolean(query: OqlQuery, source: QuerySource, searchPath: string, where: Predicate): Promise<AdapterResult>;

package/dist/oql/adapters/local/fileRowOps.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generic `FileRowMap` / string-set combinators used by the files-target
+ * boolean set algebra (union/intersection/merge). Pure data-shape helpers —
+ * no backend calls — shared by the field-leaf and content-leaf lookups.
+ */
+import type { OqlFileResultRow } from '../../types.js';
+import type { FileRowMap } from './types.js';
+export declare function mergeFileRows(left: OqlFileResultRow | undefined, right: OqlFileResultRow): OqlFileResultRow;
+export declare function rowsByPath(rows: OqlFileResultRow[]): FileRowMap;
+export declare function intersectFileRows(a: FileRowMap, b: FileRowMap): FileRowMap;
+export declare function intersectStringSets(a: Set<string>, b: Set<string>): Set<string>;

package/dist/oql/adapters/local/files.d.ts

@@ -0,0 +1,3 @@
+import type { OqlQuery, QuerySource } from '../../types.js';
+import type { AdapterResult } from './types.js';
+export declare function executeFiles(query: OqlQuery, source: QuerySource, searchPath: string): Promise<AdapterResult>;

package/dist/oql/adapters/local/filesBoolean.d.ts

@@ -0,0 +1,10 @@
+import type { OqlDiagnostic, OqlProvenance, OqlQuery, Predicate, QuerySource } from '../../types.js';
+import type { AdapterResult } from './types.js';
+/**
+ * Evaluate a boolean `where` over the FILES target with file-level set algebra.
+ */
+export declare function executeFilesBoolean(query: OqlQuery, source: QuerySource, searchPath: string, where: Predicate): Promise<AdapterResult>;
+/** All files in scope — the candidate universe for negation. */
+export declare function universeFiles(query: OqlQuery, searchPath: string, prov: OqlProvenance[]): Promise<Set<string>>;
+/** File-set for a single (non-boolean) predicate. */
+export declare function leafFiles(query: OqlQuery, leaf: Predicate, searchPath: string, prov: OqlProvenance[], diags: OqlDiagnostic[]): Promise<Set<string>>;

package/dist/oql/adapters/local/filesContentLeaf.d.ts

@@ -0,0 +1,12 @@
+import type { OqlDiagnostic, OqlProvenance, OqlQuery, Predicate, QuerySource } from '../../types.js';
+import type { AdapterResult, FileRowMap } from './types.js';
+/** File-set for a single content-leaf (text/regex/structural) predicate. */
+export declare function leafContentFileRows(query: OqlQuery, leaf: Predicate, source: QuerySource, searchPath: string, prov: OqlProvenance[], diags: OqlDiagnostic[]): Promise<FileRowMap>;
+export declare function executeFilesWithoutMatch(query: OqlQuery, source: QuerySource, searchPath: string, where: Predicate & {
+    kind: 'not';
+    predicate: Predicate;
+}): Promise<AdapterResult>;
+export declare function executeCodeFilesWithoutMatch(query: OqlQuery, source: QuerySource, searchPath: string, where: Predicate & {
+    kind: 'not';
+    predicate: Predicate;
+}): Promise<AdapterResult>;

package/dist/oql/adapters/local/filesUniverse.d.ts

@@ -0,0 +1,6 @@
+import type { OqlDiagnostic, OqlProvenance, OqlQuery, Predicate, QuerySource } from '../../types.js';
+import type { FileRowMap } from './types.js';
+/** All files in scope — the candidate universe for negation. */
+export declare function universeFileRows(query: OqlQuery, source: QuerySource, searchPath: string, prov: OqlProvenance[]): Promise<FileRowMap>;
+/** File-set for a single field-predicate leaf (attribute lookup). */
+export declare function leafFieldFileRows(query: OqlQuery, leaf: Predicate, source: QuerySource, searchPath: string, prov: OqlProvenance[], diags: OqlDiagnostic[]): Promise<FileRowMap>;

package/dist/oql/adapters/local/findToolType.d.ts

@@ -0,0 +1,10 @@
+/**
+ * `LocalFindToolQuery` on its own, so this is the only sibling module that
+ * needs a runtime import of the file-finder runner purely to derive its
+ * input type via `Parameters<typeof …>`.
+ */
+import { findFiles } from '../../../tools/local_find_files/findFiles.js';
+export type LocalFindToolQuery = Parameters<typeof findFiles>[0] & {
+    page?: number;
+    itemsPerPage?: number;
+};

package/dist/oql/adapters/local/predicates.d.ts

@@ -0,0 +1,18 @@
+import type { OqlDiagnostic, Predicate, OqlProvenance, QuerySource } from '../../types.js';
+import type { LocalFindToolQuery } from './findToolType.js';
+/** A boolean `where` that needs multi-call evaluation (not a single leaf). */
+export declare function needsBooleanEval(p: Predicate): boolean;
+export declare function isRipgrepContentLeaf(p: Predicate): boolean;
+export declare function isNegatedRipgrepContentLeaf(p: Predicate | undefined): p is Predicate & {
+    kind: 'not';
+    predicate: Predicate;
+};
+export declare function isBooleanPredicate(p: Predicate): boolean;
+export declare function isContentPredicate(p: Predicate): boolean;
+export declare function applyFieldPredicate(where: Predicate, toolQuery: Partial<LocalFindToolQuery>, diags: OqlDiagnostic[]): void;
+export declare function resultDiagnostics(result: {
+    status?: string;
+    error?: string;
+    warnings?: string[];
+}, backend: string): OqlDiagnostic[];
+export declare function provenance(backend: string, source: QuerySource, where: Predicate | undefined): OqlProvenance;

package/dist/oql/adapters/local/scope.d.ts

@@ -0,0 +1,14 @@
+import type { OqlQuery, QueryScope } from '../../types.js';
+import type { LocalFindToolQuery } from './findToolType.js';
+import type { LocalSearchToolQuery } from './searchToolType.js';
+export declare const LOCAL_SCOPE_FILTER_CANDIDATE_LIMIT = 10000;
+export declare function scopeToCommon(scope: QueryScope | undefined): Partial<LocalSearchToolQuery>;
+export declare function looksLikeRegex(value: string): boolean;
+export declare function mergeStringArrays(left: unknown, right: readonly string[]): string[];
+export declare function applyLocalSearchLanguage(toolQuery: Partial<LocalSearchToolQuery>, scope: QueryScope | undefined, explicitLangType: string | undefined): void;
+export declare function findFilesNeedsScopePostFilter(scope: QueryScope | undefined): boolean;
+export declare function applyFindFilesScope(toolQuery: Partial<LocalFindToolQuery>, scope: QueryScope | undefined): void;
+export declare function applyFindFilesPagination(toolQuery: Partial<LocalFindToolQuery>, query: OqlQuery): void;
+export declare function applyUnpagedFindFilesWindow(toolQuery: Partial<LocalFindToolQuery>): void;
+export declare function applyFindFilesSort(toolQuery: Partial<LocalFindToolQuery>, query: OqlQuery): void;
+export declare function searchControls(query: OqlQuery): Partial<LocalSearchToolQuery>;

package/dist/oql/adapters/local/searchToolType.d.ts

@@ -0,0 +1,7 @@
+/**
+ * `LocalSearchToolQuery` on its own, so this is the only sibling module that
+ * needs a runtime import of the ripgrep-backed content-search runner purely
+ * to derive its input type via `Parameters<typeof …>`.
+ */
+import { searchContentRipgrep } from '../../../tools/local_ripgrep/searchContentRipgrep.js';
+export type LocalSearchToolQuery = Parameters<typeof searchContentRipgrep>[0];

package/dist/oql/adapters/local/structureContent.d.ts

@@ -0,0 +1,6 @@
+import type { LocalFindFilesToolResult } from '@octocodeai/octocode-core/extra-types';
+import type { OqlQuery, QuerySource } from '../../types.js';
+import type { AdapterResult } from './types.js';
+export declare function executeStructure(query: OqlQuery, source: QuerySource, searchPath: string): Promise<AdapterResult>;
+export declare function executeContent(query: OqlQuery, source: QuerySource, searchPath: string): Promise<AdapterResult>;
+export declare function filterFindFilesResultByScope(result: LocalFindFilesToolResult, query: OqlQuery, searchPath: string): LocalFindFilesToolResult;

package/dist/oql/adapters/local/types.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared types for the local execution adapter split: the public
+ * `AdapterResult` shape, tool-query type aliases derived from each local
+ * runner's real input contract, and small internal helper types used across
+ * the sibling modules in this directory.
+ *
+ * `LocalSearchToolQuery` and `LocalFindToolQuery` live in their own
+ * single-purpose sibling files (searchToolType.ts / findToolType.ts) rather
+ * than here, so that no module other than those two needs a runtime import
+ * of both backing runners at once.
+ */
+import { viewStructure } from '../../../tools/local_view_structure/local_view_structure.js';
+import { fetchContent } from '../../../tools/local_fetch_content/fetchContent.js';
+import type { MappedResult } from '../resultMap.js';
+import type { OqlCodeResultRow, OqlDiagnostic, OqlFileResultRow, OqlProvenance } from '../../types.js';
+export interface AdapterResult extends MappedResult {
+    shared?: Record<string, unknown>;
+    diagnostics: OqlDiagnostic[];
+    provenance: OqlProvenance[];
+}
+export type LocalStructureToolQuery = Parameters<typeof viewStructure>[0] & {
+    page?: number;
+    itemsPerPage?: number;
+};
+export type LocalFetchToolQuery = Parameters<typeof fetchContent>[0];
+export type FileRowMap = Map<string, OqlFileResultRow>;
+/** A boolean-code-eval partial result: satisfying files + positive rows. */
+export interface CodeEval {
+    /** Files satisfying this sub-predicate (the candidate universe slice). */
+    files: Set<string>;
+    /** Positive match occurrences (empty for negation/field constraints). */
+    rows: OqlCodeResultRow[];
+}
+export declare function normalizeGlobPath(value: string): string;

package/dist/oql/adapters/local.d.ts

@@ -1,8 +1,4 @@
-import { type MappedResult } from './resultMap.js';
-import type { OqlDiagnostic, OqlProvenance, OqlQuery } from '../types.js';
-export interface AdapterResult extends MappedResult {
-    shared?: Record<string, unknown>;
-    diagnostics: OqlDiagnostic[];
-    provenance: OqlProvenance[];
-}
+import type { OqlQuery } from '../types.js';
+import type { AdapterResult } from './local/types.js';
+export type { AdapterResult };
 export declare function executeLocal(query: OqlQuery): Promise<AdapterResult>;

package/dist/oql/adapters/researchTargets/diff.d.ts

@@ -0,0 +1,16 @@
+import type { AdapterResult } from '../local.js';
+import type { OqlQuery } from '../../types.js';
+export declare function executeDiff(query: OqlQuery): Promise<AdapterResult>;
+export interface LineDiff {
+    additions: number;
+    deletions: number;
+    unchanged: number;
+    /** Unified-style patch text (`+`/`-`/` ` line prefixes). */
+    patch: string;
+}
+/**
+ * Minimal LCS-based line diff between two file bodies. Pure and dependency-free
+ * so it is unit-testable without any backend. Not a byte-perfect git patch —
+ * a line-granular additions/deletions view for direct two-ref comparison.
+ */
+export declare function computeLineDiff(baseText: string, headText: string): LineDiff;

package/dist/oql/adapters/researchTargets/graph.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterResult } from '../local.js';
+import type { OqlQuery } from '../../types.js';
+export declare function executeGraph(query: OqlQuery): Promise<AdapterResult>;

package/dist/oql/adapters/researchTargets/history.d.ts

@@ -0,0 +1,20 @@
+import type { AdapterResult } from '../local.js';
+import type { OqlQuery } from '../../types.js';
+export declare function executeHistory(query: OqlQuery): Promise<AdapterResult>;
+/**
+ * Keep only commit records whose message contains `needle` (case-insensitive
+ * substring), spotlight where it matched, and surface honest diagnostics — a
+ * `partialResult` when some were dropped, `zeroMatches` when none matched.
+ * Mirrors {@link filterPullRequestsByMatch}; commit text is the commit message.
+ */
+export declare function filterCommitsByMatch(result: AdapterResult, needle: string): AdapterResult;
+export interface PullRequestMatch {
+    needle: string;
+    scope: 'body' | 'title' | 'comments' | 'reviews' | 'all';
+}
+/**
+ * Keep only PR records whose scope text contains `matchString` (case-insensitive
+ * substring), spotlight where each matched, and surface honest diagnostics: a
+ * `partialResult` when some were dropped, `zeroMatches` when none matched.
+ */
+export declare function filterPullRequestsByMatch(result: AdapterResult, match: PullRequestMatch): AdapterResult;

package/dist/oql/adapters/researchTargets/pagination.d.ts

@@ -0,0 +1,54 @@
+import type { AdapterResult } from '../local.js';
+import type { analyzeResearchFlow } from '../../research/analyze.js';
+import type { OqlDiagnostic, OqlQuery, OqlRecordResultRow, Pagination, QuerySource } from '../../types.js';
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+export declare function requestedResearchMode(mode: unknown): 'plan' | 'analyze' | 'prove';
+/**
+ * Build the `view:"detailed"` payload as per-domain *windows* instead of whole
+ * arrays (P1). Each requested domain emits a sliced `data.<domain>` window plus
+ * a typed `data.<domain>Page` pagination object, all sharing the query's
+ * page/itemsPerPage. Returns the combined pagination (max totalPages, OR-ed
+ * hasMore) so a single `next.page` advances every detailed domain together.
+ */
+export declare function buildDetailedDomains(query: OqlQuery, data: Awaited<ReturnType<typeof analyzeResearchFlow>>): {
+    fields: Record<string, unknown>;
+    pagination?: Pagination;
+};
+/** Combine the packet-page window with the detailed-domain window so the
+ *  envelope's `hasMore` (and thus `next.page`) reflects either having more. */
+export declare function combinePagination(a: Pagination | undefined, b: Pagination | undefined): Pagination | undefined;
+export declare function statusDiagnostics(result: CallToolResult, backend: string): OqlDiagnostic[];
+/**
+ * Build an AdapterResult from a backing-tool result: map records (none on
+ * error), carry status diagnostics, and emit `zeroMatches` on a clean empty so
+ * an empty result is never read as silent proof.
+ */
+export declare function finishRecords(result: CallToolResult, recordType: OqlRecordResultRow['recordType'], backend: string, source?: QuerySource): AdapterResult;
+export declare function semanticPageContinuation(pag: {
+    currentPage?: number;
+    nextPage?: number;
+}, query: OqlQuery): {
+    query: {
+        params: {
+            page: number;
+        };
+        schema: "oql";
+        id?: string;
+        target: import("../../types.js").OqlActiveTarget;
+        from?: QuerySource;
+        scope?: import("../../types.js").QueryScope;
+        where?: import("../../types.js").Predicate;
+        materialize?: import("../../types.js").MaterializePolicy;
+        fetch?: import("../../types.js").FetchInstructions;
+        select?: import("../../types.js").SelectField[];
+        view?: import("../../types.js").QueryView;
+        controls?: import("../../types.js").QueryControls;
+        limit?: number;
+        page?: number;
+        itemsPerPage?: number;
+        explain?: boolean;
+    };
+    why: string;
+    confidence: "exact";
+};
+export declare function semanticPagination(data: Record<string, unknown> | undefined, query: OqlQuery): Pagination | undefined;

package/dist/oql/adapters/researchTargets/repositories.d.ts

@@ -0,0 +1,4 @@
+import type { AdapterResult } from '../local.js';
+import type { OqlQuery } from '../../types.js';
+export declare function executeRepositories(query: OqlQuery): Promise<AdapterResult>;
+export declare function executePackages(query: OqlQuery): Promise<AdapterResult>;

package/dist/oql/adapters/researchTargets/research.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterResult } from '../local.js';
+import type { OqlQuery } from '../../types.js';
+export declare function executeResearch(query: OqlQuery): Promise<AdapterResult>;

package/dist/oql/adapters/researchTargets/rows.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Result/record shaping shared by every research-target adapter: turning a
+ * backing tool's `data` payload into generic `OqlRecordResultRow`s, deriving
+ * a citeable `id` per record type, and trimming parent-level metadata/shared
+ * repository refs that ride alongside the array payload.
+ */
+import type { OqlRecordResultRow, QuerySource } from '../../types.js';
+/** Known array-valued payload fields, in priority order. */
+export declare const RECORD_ARRAY_KEYS: string[];
+export declare const RECORD_PARENT_METADATA_EXCLUDE: Set<string>;
+/** Expand a tool `data` payload into row items (an inner array if present). */
+export declare function expandData(data: Record<string, unknown> | undefined): unknown[];
+export declare function sharedRepositoryRefs(parent: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+export declare function parentMetadata(data: Record<string, unknown> | undefined): Record<string, unknown> | undefined;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function records(items: unknown[], recordType: OqlRecordResultRow['recordType'], source?: QuerySource, metadata?: Record<string, unknown>): OqlRecordResultRow[];

package/dist/oql/adapters/researchTargets/semantics.d.ts

@@ -0,0 +1,3 @@
+import type { AdapterResult } from '../local.js';
+import type { OqlQuery } from '../../types.js';
+export declare function executeSemantics(query: OqlQuery): Promise<AdapterResult>;

package/dist/oql/adapters/researchTargets/shared.d.ts

@@ -0,0 +1,11 @@
+import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { OqlQuery, QuerySource } from '../../types.js';
+export declare function errorText(value: unknown, fallback: string): string;
+export declare function materializedClonePath(result: CallToolResult, localPath: string | undefined): string | undefined;
+export declare function isExistingDirectory(path: string): boolean;
+export declare function splitRepo(source: QuerySource | undefined): {
+    owner?: string;
+    repo?: string;
+};
+export declare function params(query: OqlQuery): Record<string, unknown>;
+export declare function withOqlPaging(query: OqlQuery, limitKey?: 'limit' | 'perPage'): Record<string, unknown>;

package/dist/oql/adapters/researchTargets.d.ts

@@ -1,50 +1,8 @@
+import { filterCommitsByMatch, filterPullRequestsByMatch, type PullRequestMatch } from './researchTargets/history.js';
+import { computeLineDiff, executeDiff, type LineDiff } from './researchTargets/diff.js';
 import type { AdapterResult } from './local.js';
 import type { OqlQuery } from '../types.js';
-export declare function executeRepositories(query: OqlQuery): Promise<AdapterResult>;
-export declare function executePackages(query: OqlQuery): Promise<AdapterResult>;
-export declare function executeHistory(query: OqlQuery): Promise<AdapterResult>;
-/**
- * Keep only commit records whose message contains `needle` (case-insensitive
- * substring), spotlight where it matched, and surface honest diagnostics — a
- * `partialResult` when some were dropped, `zeroMatches` when none matched.
- * Mirrors {@link filterPullRequestsByMatch}; commit text is the commit message.
- */
-export declare function filterCommitsByMatch(result: AdapterResult, needle: string): AdapterResult;
-export interface PullRequestMatch {
-    needle: string;
-    scope: 'body' | 'title' | 'comments' | 'reviews' | 'all';
-}
-/**
- * Keep only PR records whose scope text contains `matchString` (case-insensitive
- * substring), spotlight where each matched, and surface honest diagnostics: a
- * `partialResult` when some were dropped, `zeroMatches` when none matched.
- */
-export declare function filterPullRequestsByMatch(result: AdapterResult, match: PullRequestMatch): AdapterResult;
-/**
- * `target:"diff"` has two typed lanes, discriminated by params shape:
- *   - PR patch:    { prNumber, files? }            -> ghHistoryResearch patches
- *   - direct file: { baseRef, headRef, path }      -> two ghGetFileContent reads
- *                                                     + a pure local line diff
- * A request that fits neither returns a repair diagnostic rather than silently
- * falling through to a PR-patch call.
- */
-export declare function executeDiff(query: OqlQuery): Promise<AdapterResult>;
-export interface LineDiff {
-    additions: number;
-    deletions: number;
-    unchanged: number;
-    /** Unified-style patch text (`+`/`-`/` ` line prefixes). */
-    patch: string;
-}
-/**
- * Minimal LCS-based line diff between two file bodies. Pure and dependency-free
- * so it is unit-testable without any backend. Not a byte-perfect git patch —
- * a line-granular additions/deletions view for direct two-ref comparison.
- */
-export declare function computeLineDiff(baseText: string, headText: string): LineDiff;
-export declare function executeArtifacts(query: OqlQuery): Promise<AdapterResult>;
-export declare function executeSemantics(query: OqlQuery): Promise<AdapterResult>;
-export declare function executeResearch(query: OqlQuery): Promise<AdapterResult>;
-export declare function executeGraph(query: OqlQuery): Promise<AdapterResult>;
+export { filterCommitsByMatch, filterPullRequestsByMatch, executeDiff, computeLineDiff, };
+export type { PullRequestMatch, LineDiff };
 /** Dispatch map: target -> adapter. */
 export declare const RESEARCH_TARGET_ADAPTERS: Record<string, (q: OqlQuery) => Promise<AdapterResult>>;

package/dist/oql/defaults.d.ts

@@ -12,7 +12,7 @@ export declare const DEFAULTS: {
     textCase: "smart";
     regexDialectLocal: "rust";
     regexCase: "smart";
-    contentView: "compact";
+    contentView: "standard";
     contentCharLength: number;
     matchContentLength: number;
     maxPlanNodes: number;