@octocodeai/octocode-tools-core 17.0.2 → 18.1.0

package/dist/utils/file/configFiles.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Common configuration / manifest file detection + coarse file-type
+ * classification.
+ *
+ * `isConfigFile` combines three matching strategies:
+ *  1. Exact basename match (e.g. `package.json`, `Cargo.toml`).
+ *  2. Basename regex match for variadic names (e.g. `.eslintrc.*`, `*.csproj`).
+ *  3. Config-ish extension match for structured formats (e.g. `.toml`, `.ini`).
+ *
+ * `classifyFileType` layers lock/doc/code detection on top so fetch tools can
+ * tell an agent whether a path is a `code`, `config`, `lock`, `doc`, or
+ * `other` file — a cheap signal that changes how the returned bytes should be
+ * read.
+ *
+ * Config vs lock — rule of thumb: a CONFIG/manifest file declares *how* a
+ * package/service/code is meant to work and *which* dependencies it wants
+ * (`package.json`, `Cargo.toml`, `go.mod`, `pyproject.toml`, `tsconfig.json`).
+ * A LOCK file is a generated snapshot pinning the *resolved* dependency tree
+ * (`yarn.lock`, `package-lock.json`, `Cargo.lock`, `go.sum`) — not authored,
+ * rarely worth reading in full, and never the source of truth for intent.
+ *
+ * Scope is deliberately limited to config/manifest/lock files of the top
+ * popular languages and platforms — not every conceivable dotfile.
+ */
+/** Exact config file basenames, grouped by ecosystem for readability. */
+export declare const CONFIG_FILENAMES: readonly string[];
+/**
+ * Dependency lock files — generated snapshots that pin a resolved dependency
+ * tree. Distinct from config/manifests: they are not authored by hand and
+ * rarely need to be read in full. Grouped by ecosystem.
+ */
+export declare const LOCK_FILENAMES: readonly string[];
+/** Regex patterns for variadic / templated config filenames. */
+export declare const CONFIG_FILENAME_PATTERNS: readonly RegExp[];
+/** Extensions that indicate a structured config format. */
+export declare const CONFIG_EXTENSIONS: readonly string[];
+/**
+ * Coarse file-type buckets returned to fetch callers. Deliberately has no
+ * `other`/`unknown` member: when a path can't be confidently placed in one of
+ * these buckets, `classifyFileType` returns `undefined` and callers omit the
+ * field entirely rather than emit a low-confidence guess.
+ */
+export type FileType = 'code' | 'config' | 'lock' | 'doc';
+/**
+ * Returns true when the given path points to a common config / manifest file.
+ *
+ * @param filePath A file path or bare filename.
+ */
+export declare function isConfigFile(filePath: string): boolean;
+/**
+ * Returns true when the path is a dependency lock file (a pinned, generated
+ * resolution snapshot) rather than an authored config/manifest.
+ *
+ * @param filePath A file path or bare filename.
+ */
+export declare function isLockFile(filePath: string): boolean;
+/**
+ * Classify a path into a coarse bucket so agents can decide how to read it.
+ *
+ * Precedence (most specific first): lock → config → doc → code. Lock wins
+ * first (a lockfile is never config/source). Config then wins over code/doc
+ * because manifests like `vite.config.js` or `pyproject.toml` carry a
+ * `.js`/`.toml` extension yet are configuration, not source.
+ *
+ * Returns `undefined` when the path matches none of the buckets — callers
+ * MUST omit the field in that case rather than emit an uncertain guess.
+ *
+ * @param filePath A file path or bare filename.
+ */
+export declare function classifyFileType(filePath: string): FileType | undefined;

package/dist/utils/jsSymbolNames.d.ts

@@ -0,0 +1,6 @@
+/**
+ * True when `name` is a usable JS identifier for a top-level declaration —
+ * i.e. a real symbol name, not a reserved keyword the extractor mis-emitted.
+ * Empty/undefined names are rejected too.
+ */
+export declare function isValidJsSymbolName(name: string | undefined | null): boolean;

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@octocodeai/octocode-tools-core",
   "description": "Core tool implementations for Octocode: GitHub, local filesystem, LSP, and package search tools.",
-  "version": "17.0.2",
+  "version": "18.1.0",
   "author": "Guy Bary <bgauryy@octocodeai.com>",
   "bugs": "https://github.com/bgauryy/octocode/issues",
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@octocodeai/config": "^17.0.2",
-    "@octocodeai/octocode-core": "^16.6.3",
-    "@octocodeai/octocode-engine": "^17.0.2",
+    "@octocodeai/config": "18.0.1",
+    "@octocodeai/octocode-core": "18.2.0",
+    "@octocodeai/octocode-engine": "18.1.1",
     "@octokit/oauth-methods": "^6.0.2",
     "@octokit/plugin-throttling": "^11.0.3",
     "@octokit/request": "^10.0.10",
@@ -43,10 +43,6 @@
       "types": "./dist/schema.d.ts",
       "import": "./dist/schema.js"
     },
-    "./oql": {
-      "types": "./dist/oql/index.d.ts",
-      "import": "./dist/oql/index.js"
-    },
     "./zod": {
       "types": "./dist/zod.d.ts",
       "import": "./dist/zod.js"

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

@@ -1,25 +0,0 @@
-import type { DiagnosticCode, Predicate } from '../types.js';
-export interface CompiledMatch {
-    keywords?: string;
-    fixedString?: boolean;
-    perlRegex?: boolean;
-    caseInsensitive?: boolean;
-    caseSensitive?: boolean;
-    wholeWord?: boolean;
-    multiline?: boolean;
-    multilineDotall?: boolean;
-    mode?: 'structural';
-    pattern?: string;
-    rule?: unknown;
-    langType?: string;
-}
-export interface CompileResult {
-    match?: CompiledMatch;
-    negate?: boolean;
-    unsupported?: {
-        code: DiagnosticCode;
-        message: string;
-        predicateId?: string;
-    };
-}
-export declare function compileWhere(where: Predicate): CompileResult;

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

@@ -1,16 +0,0 @@
-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

@@ -1,14 +0,0 @@
-/**
- * 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

@@ -1,75 +0,0 @@
-/**
- * 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,14 +0,0 @@
-/**
- * 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/graphProof.d.ts

@@ -1,6 +0,0 @@
-import type { ResearchEvidencePacket } from '../research/packets.js';
-import type { OqlDiagnostic, OqlQuery } from '../types.js';
-import { type GraphFilters } from './graphView.js';
-export declare function shouldRunLspProof(mode: 'plan' | 'analyze' | 'prove', p: Record<string, unknown>): boolean;
-export declare function graphProofLimit(query: OqlQuery, p: Record<string, unknown>): number;
-export declare function escalateGraphPacketsWithLsp(root: string, query: OqlQuery, packets: ResearchEvidencePacket[], filters: GraphFilters, limit: number): Promise<OqlDiagnostic[]>;

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

@@ -1,25 +0,0 @@
-/**
- * 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

@@ -1,5 +0,0 @@
-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,29 +0,0 @@
-/**
- * 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, 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;
-};
-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 summarizePacketGraph(packets: readonly ResearchEvidencePacket[]): ResearchGraphSummary;

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

@@ -1,3 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,11 +0,0 @@
-/**
- * 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

@@ -1,3 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,10 +0,0 @@
-/**
- * `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

@@ -1,18 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,7 +0,0 @@
-/**
- * `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

@@ -1,6 +0,0 @@
-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

@@ -1,34 +0,0 @@
-/**
- * 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,4 +0,0 @@
-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/materialize.d.ts

@@ -1,11 +0,0 @@
-import { type AdapterResult } from './local.js';
-import type { OqlQuery } from '../types.js';
-export declare function executeMaterialize(query: OqlQuery): Promise<AdapterResult>;
-/**
- * `target:"materialize"` — addressable materialization. Clone/cache a bounded
- * corpus once and return a stable local checkpoint row (localPath, repoRoot,
- * source, ref, cache, complete) that downstream queries can root at via the
- * `next.search` / `next.structure` / `next.fetch` continuations (attached in
- * run.ts). This makes materialization a first-class step, not a search side-effect.
- */
-export declare function executeMaterializeCheckpoint(query: OqlQuery): Promise<AdapterResult>;

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

@@ -1,21 +0,0 @@
-import type { Pagination } from '../types.js';
-export interface ToolPaginationPayload {
-    currentPage?: number;
-    totalPages?: number;
-    nextPage?: number;
-    hasMore?: boolean;
-    itemsPerPage?: number;
-    entriesPerPage?: number;
-    filesPerPage?: number;
-    perPage?: number;
-    totalItems?: number;
-    totalEntries?: number;
-    totalFiles?: number;
-    totalMatches?: number;
-    reportedTotalMatches?: number;
-    reachableTotalMatches?: number;
-    totalMatchesKind?: string;
-    totalMatchesCapped?: boolean;
-    uniqueFileCount?: number;
-}
-export declare function toOqlPagination(pagination: ToolPaginationPayload | undefined, fallbackHasMore?: boolean): Pagination | undefined;

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

@@ -1,16 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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;