@octocodeai/octocode-tools-core 17.0.2 → 18.1.0

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

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

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

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

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

@@ -1,11 +0,0 @@
-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,8 +0,0 @@
-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 { 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/adapters/resultMap.d.ts

@@ -1,27 +0,0 @@
-/**
- * Map typed tool results into OQL result rows + pagination. Pure functions —
- * no I/O — so they are unit-testable without backends.
- */
-import type { LocalFindFilesToolResult, LocalGetFileContentToolResult, LocalSearchCodeToolResult, LocalViewStructureToolResult } from '@octocodeai/octocode-core/extra-types';
-import type { OqlContentResultRow, OqlResultRow, Pagination, QuerySource } from '../types.js';
-export interface MappedResult {
-    results: OqlResultRow[];
-    pagination?: Pagination;
-}
-export declare function mapCodeResult(result: LocalSearchCodeToolResult, source: QuerySource): MappedResult;
-/**
- * Mark file-unit code pagination: `page`/`itemsPerPage` count matched FILES
- * while OQL code rows are individual matches. `filesUnit` forces the marker
- * for providers (GitHub code search) whose totalItemsKind carries exactness
- * (`lowerBound`/`reported`) instead of the local `'files'` unit tag.
- */
-export declare function enrichCodePagination(pagination: Pagination | undefined, rowCount: number, filesUnit?: boolean): Pagination | undefined;
-export declare function mapFilesResult(result: LocalFindFilesToolResult, source: QuerySource): MappedResult;
-export declare function mapStructureResult(result: LocalViewStructureToolResult, source: QuerySource): MappedResult;
-export declare function mapContentResult(result: LocalGetFileContentToolResult, source: QuerySource, path: string, 
-/**
- * The view the OQL query *requested*. The backing tool does not reliably echo
- * the minify mode back (e.g. a `symbols` read reports `standard`), so the row
- * must report the requested view to satisfy "report the view used".
- */
-requestedView?: OqlContentResultRow['contentView']): MappedResult;

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

@@ -1,11 +0,0 @@
-/**
- * Serialize an OQL JSON `StructuralRule` into the engine's YAML rule string.
- *
- * The structural engine's `rule` field is a YAML string with a top-level
- * `rule:` key (matching the `search --rule` surface). OQL accepts that YAML
- * string directly, or this JSON object form for typed callers. Covers the
- * currently supported rule fields: pattern, kind, inside, has, not, all, any,
- * stopBy.
- */
-import type { StructuralRule } from '../types.js';
-export declare function structuralRuleToYaml(rule: StructuralRule): string;

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

@@ -1,21 +0,0 @@
-/**
- * Single entry for OQL adapters to invoke a backing tool.
- *
- * Routes through `executeDirectTool` — the SAME path the CLI's `tools <name>`
- * uses — so OQL gets identical credential resolution (withSecurityValidation),
- * provider initialization, input validation, and secret sanitization. Calling
- * the bulk runners directly bypassed auth (the CLI runs `runOqlSearch` without
- * an MCP `authInfo`), which silently failed GitHub/npm calls.
- *
- * GitHub/package tools require `mainResearchGoal`; we fill OQL defaults.
- */
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-/** Run one backing tool with a single query, via the shared direct-tool path. */
-export declare function runDirect(name: string, query: Record<string, unknown>): Promise<CallToolResult>;
-/** Pull the single query's `{data,status}` out of a bulk-shaped tool result. */
-export declare function firstQueryData<T = Record<string, unknown>>(result: CallToolResult): {
-    data?: T;
-    status?: string;
-};
-export declare function numberFrom(value: unknown): number | undefined;
-export declare function stringFrom(value: unknown): string | undefined;

package/dist/oql/capabilities.d.ts

@@ -1,31 +0,0 @@
-/**
- * OQL capability registry — makes backend limits explicit and testable.
- *
- * Given the source kind, target, materialization stance, and a single leaf
- * predicate, decide how that predicate can be evaluated:
- *   PUSHDOWN   backend evaluates it directly (exact or approximate)
- *   RESIDUAL   fetch bounded candidates and filter locally
- *   ROUTE      move to another lane (materialize -> local)
- *   UNSUPPORTED cannot be evaluated; emit a diagnostic
- *
- * This is intentionally conservative: anything that cannot be proven exactly is
- * flagged so the planner never reports `proof` it cannot back.
- */
-import type { DiagnosticCode, LeafPredicate, MaterializePolicy, OqlActiveTarget, PlanRoute, QuerySource } from './types.js';
-export interface CapabilityContext {
-    sourceKind: QuerySource['kind'];
-    target: OqlActiveTarget;
-    materialize: MaterializePolicy | undefined;
-}
-export interface CapabilityDecision {
-    route: PlanRoute;
-    backend: string;
-    /** Whether the backend evaluates the predicate exactly (proof-grade). */
-    exact: boolean;
-    reason: string;
-    diagnostic?: {
-        code: DiagnosticCode;
-        message: string;
-    };
-}
-export declare function routeLeafPredicate(ctx: CapabilityContext, predicate: LeafPredicate, inNegation?: boolean): CapabilityDecision;

package/dist/oql/defaults.d.ts

@@ -1,26 +0,0 @@
-/**
- * OQL defaults (see OCTOCODE_QUERY_LANGUAGE.md §defaults). `--explain` must
- * surface every applied default, so they live in one place.
- */
-import type { OqlQuery } from './types.js';
-export declare const DEFAULTS: {
-    schema: "oql";
-    view: "paginated";
-    page: number;
-    itemsPerPage: number;
-    githubMaterializeMode: "never";
-    textCase: "smart";
-    regexDialectLocal: "rust";
-    regexCase: "smart";
-    contentView: "standard";
-    contentCharLength: number;
-    matchContentLength: number;
-    maxPlanNodes: number;
-    maxBooleanExpansion: number;
-    normalCodeContext: number;
-    detailedCodeContext: number;
-    localSearchSort: "relevance";
-    localRankingProfile: "auto";
-};
-/** The subset of defaults actually applied to (or relevant for) this query. */
-export declare function appliedDefaults(query: OqlQuery): Record<string, unknown>;

package/dist/oql/diagnostics.d.ts

@@ -1,25 +0,0 @@
-/**
- * OQL diagnostic helpers. Diagnostics are first-class typed output, not prose
- * hints. `blocksAnswer:true` marks diagnostics that prevent `proof`.
- */
-import type { DiagnosticCode, OqlContinuation, OqlDiagnostic, OqlSearchInput } from './types.js';
-export interface DiagnosticOptions {
-    queryPath?: string;
-    predicateId?: string;
-    backend?: string;
-    blocksAnswer?: boolean;
-    severity?: OqlDiagnostic['severity'];
-    repair?: {
-        message: string;
-        suggestedQuery?: OqlSearchInput;
-    };
-    continuation?: OqlContinuation;
-}
-export declare function diagnostic(code: DiagnosticCode, message: string, options?: DiagnosticOptions): OqlDiagnostic;
-export declare function blocksAnswer(diagnostics: OqlDiagnostic[]): boolean;
-export declare function hasErrors(diagnostics: OqlDiagnostic[]): boolean;
-/** Error raised when validation/normalization cannot produce a canonical query. */
-export declare class OqlValidationError extends Error {
-    readonly diagnostics: OqlDiagnostic[];
-    constructor(diagnostics: OqlDiagnostic[]);
-}

package/dist/oql/diffLanes.d.ts

@@ -1,29 +0,0 @@
-/**
- * Single source of truth for the `target:"diff"` lane discriminant.
- *
- * `target:"diff"` has two typed execution lanes plus an invalid shape:
- *   - prPatch:    { prNumber, files? }        -> ghHistoryResearch (PR patches)
- *   - directFile: { baseRef, headRef, path }  -> 2× ghGetFileContent + line diff
- *   - neither:    repair diagnostic, no call
- *
- * Both the planner (to announce the right backend in `--explain --dry-run`) and
- * the diff adapter (to dispatch execution) classify a query off this one
- * helper, so the plan can never contradict execution. Pure: no imports beyond
- * its own return types.
- */
-export type DiffLane = {
-    kind: 'prPatch';
-    prNumber: number;
-    files?: string[];
-} | {
-    kind: 'directFile';
-    baseRef: string;
-    headRef: string;
-    path: string;
-} | {
-    kind: 'neither';
-};
-/** Unified lane discriminant for target:"diff". Single source of truth. */
-export declare function classifyDiffLane(params: Record<string, unknown> | undefined): DiffLane;
-/** Backend name the planner should announce for a lane (`''` = no call). */
-export declare function diffLaneBackend(lane: DiffLane): string;

package/dist/oql/envelope.d.ts

@@ -1,21 +0,0 @@
-import type { OqlBackendCall, OqlDiagnostic, OqlExplainPlan, OqlProofGradedResultRow, OqlProvenance, OqlResultEnvelope, Pagination } from './types.js';
-export interface BuildEnvelopeArgs {
-    queryId?: string;
-    queryIndex?: number;
-    results: OqlProofGradedResultRow[];
-    shared?: OqlResultEnvelope['shared'];
-    pagination?: Pagination;
-    next?: OqlResultEnvelope['next'];
-    nextHints?: OqlResultEnvelope['nextHints'];
-    diagnostics: OqlDiagnostic[];
-    provenance: OqlProvenance[];
-    /** Whether the plan was executable (no UNSUPPORTED nodes / blocking errors). */
-    executable: boolean;
-    /** Whether any backend call was approximate (exact:false). */
-    approximate?: boolean;
-    plan?: OqlExplainPlan;
-}
-export declare function buildEnvelope(args: BuildEnvelopeArgs): OqlResultEnvelope;
-export declare function backendsApproximate(calls: OqlBackendCall[]): boolean;
-/** Envelope for a query that failed validation/planning (no execution). */
-export declare function unsupportedEnvelope(diagnostics: OqlDiagnostic[], plan?: OqlExplainPlan, queryId?: string, queryIndex?: number, next?: OqlResultEnvelope['next']): OqlResultEnvelope;

package/dist/oql/features.d.ts

@@ -1,7 +0,0 @@
-import type { OqlDiagnostic, OqlQuery } from './types.js';
-/**
- * Diagnose requested-but-unbackable output features. Pure; emits zero or more
- * non-blocking diagnostics. Called by the planner so the limitation rides in the
- * plan and the envelope alike.
- */
-export declare function checkOutputFeatures(query: OqlQuery): OqlDiagnostic[];

package/dist/oql/index.d.ts

@@ -1,27 +0,0 @@
-/**
- * Octocode Query Language (OQL) public surface.
- *
- * `octocode search` (CLI) and the OQL MCP tool both consume this module:
- *   - `runOqlSearch` executes a query/batch and returns a typed envelope.
- *   - `normalizeInput` / `planQuery` expose the normalize + explain stages.
- *   - `oqlSchemaText()` / `OQL_SCHEMA_JSON` back `octocode search --scheme`.
- *
- * Schemas/types co-locate here for now (tools-core). They may migrate to
- * `@octocodeai/octocode-core/oql` once a second consumer needs OQL validation
- * without the rest of tools-core.
- */
-export * from './types.js';
-export { OqlQuerySchema, OqlBatchSchema, OqlCanonicalInputSchema, OqlInputQuerySchema, OqlInputBatchSchema, OqlSearchInputSchema, PredicateSchema, QuerySourceSchema, StructuralRuleSchema, } from './schema.js';
-export { normalizeInput, normalizeQuery } from './normalize.js';
-export { planQuery, type PlanQueryResult } from './planner.js';
-export { DEFAULTS, appliedDefaults } from './defaults.js';
-export { diagnostic, blocksAnswer, hasErrors, OqlValidationError, } from './diagnostics.js';
-export { buildEnvelope, unsupportedEnvelope, backendsApproximate, } from './envelope.js';
-export { runOqlSearch, type RunOptions } from './run.js';
-export { buildShorthandInput, type SearchShorthand, type ShorthandCorpus, type ShorthandResult, } from './shorthand.js';
-export { listTransformerEntries, findTransformerById, findTransformerEntry, backendCallsForTransformer, } from './transformers/registry.js';
-export type { TransformerRegistryEntry, TransformerStatus, } from './transformers/contract.js';
-export { oqlSchemaText, oqlCompactSchemeText, oqlCompactSchemeJson, OQL_SCHEMA_DOC, } from './schemeText.js';
-export { sanitizeStructuredContent } from '../responses.js';
-export { analyzeResearchFlow, type AnalyzeResearchOptions, type ResearchAnalysisResult, type ResearchDependencyIssue, type ResearchFileIssue, type ResearchFlowStep, type ResearchIntent, type ResearchManifestSummary, type ResearchMode, type ResearchSymbolRow, type ResearchSymbolVerdict, } from './research/analyze.js';
-export { buildResearchPackets, type EvidenceClaim, type EvidenceConfidence, type EvidenceEdge, type EvidenceFact, type EvidenceFlag, type EvidenceLocation, type EvidenceRelation, type EvidenceSource, type EvidenceSubject, type MissingProof, type MissingProofKind, type PacketProofStatus, type PacketVerdict, type ResearchEvidencePacket, type ResearchGraphSummary, type ResearchPacketBundle, } from './research/packets.js';