@octocodeai/octocode-tools-core 16.6.3 → 17.0.2

package/dist/oql/research/packets.d.ts

@@ -1,80 +1,21 @@
-import type { OqlContinuation } from '../types.js';
-import type { ResearchAnalysisResult } from './analyze.js';
-export type EvidenceSource = 'ripgrep' | 'regex' | 'ast' | 'symbols' | 'lsp' | 'manifest' | 'graph' | 'exactRead';
-export type EvidenceConfidence = 'exact' | 'heuristic' | 'partial';
-export interface EvidenceLocation {
-    uri: string;
-    range?: {
-        start: {
-            line: number;
-            character?: number;
-        };
-        end?: {
-            line: number;
-            character?: number;
-        };
-    };
-}
-export interface EvidenceSubject extends EvidenceLocation {
-    id: string;
-    kind: 'file' | 'symbol' | 'function' | 'class' | 'method' | 'interface' | 'type' | 'dependency' | 'package' | 'entrypoint';
-    name?: string;
-    symbolKind?: number | string;
-    language?: string;
-}
-export type EvidenceClaim = 'defines' | 'declares' | 'exports' | 'imports' | 'references' | 'calls' | 'extends' | 'implements' | 'typeUses' | 'entrypoint' | 'unresolved' | 'textMatch' | 'structuralMatch';
-export type EvidenceFlag = 'same-file' | 'external' | 'type-only' | 'test-only' | 'dynamic' | 'string-only' | 'unreachable' | 'generated' | 'declaration';
-export interface EvidenceFact {
-    id: string;
-    subject: EvidenceSubject;
-    claim: EvidenceClaim;
-    source: EvidenceSource;
-    confidence: EvidenceConfidence;
-    flags?: EvidenceFlag[];
-    value?: unknown;
-}
-export type EvidenceRelation = 'contains' | 'defines' | 'exports' | 'imports' | 'references' | 'calls' | 'constructs' | 'extends' | 'implements' | 'typeUses' | 'retains' | 'reachableFrom' | 'declaresDependency' | 'usesDependency';
-export interface EvidenceEdge {
-    id: string;
-    from: EvidenceSubject;
-    to: EvidenceSubject;
-    relation: EvidenceRelation;
-    source: EvidenceSource;
-    confidence: EvidenceConfidence;
-    flags?: EvidenceFlag[];
-    via?: EvidenceLocation;
-}
-export type PacketVerdict = 'reachable' | 'candidate-dead' | 'transitive-dead' | 'candidate-unused-file' | 'candidate-unused-dependency' | 'unknown';
-export type PacketProofStatus = 'candidate' | 'confirmed-by-lsp' | 'confirmed-by-ast-and-lsp' | 'needs-framework-graph' | 'conflicting-evidence';
-export type MissingProofKind = 'lsp-unavailable' | 'dynamic-import-unresolved' | 'framework-entrypoint-unknown' | 'tsconfig-paths-unresolved' | 'manifest-rule-missing' | 'parser-failed' | 'pagination-open';
-export interface MissingProof {
-    kind: MissingProofKind;
-    severity: 'low' | 'medium' | 'high';
-    location?: EvidenceLocation;
-}
-export interface ResearchEvidencePacket {
-    subject: EvidenceSubject;
-    verdict: PacketVerdict;
-    proofStatus: PacketProofStatus;
-    why: EvidenceFact[];
-    retainedBy: EvidenceEdge[];
-    retains?: EvidenceEdge[];
-    missingProof: MissingProof[];
-    proof?: Record<string, unknown>;
-    risk: {
-        deleteRisk: 'low' | 'medium' | 'high' | 'unknown';
-        reason: string;
-    };
-    next: Record<string, OqlContinuation>;
-}
-export interface ResearchGraphSummary {
-    subjects: number;
-    facts: number;
-    edges: number;
-    byVerdict: Record<PacketVerdict, number>;
-}
-export interface ResearchPacketBundle {
-    packets: ResearchEvidencePacket[];
-    graphSummary: ResearchGraphSummary;
-}
-export declare function buildResearchPackets(analysis: ResearchAnalysisResult): ResearchPacketBundle;
+/**
+ * Research evidence packets.
+ *
+ * Transforms the heuristic `ResearchAnalysisResult` (reachability + reference +
+ * dependency analysis) into compact, decision-grade `ResearchEvidencePacket`s —
+ * the agent's unit for "what looks dead, why, what keeps it alive, what proof is
+ * missing, and is it safe to delete".
+ *
+ * HONESTY CONTRACT: this layer never invents proof. Native AST facts can prove
+ * syntax-level declarations/imports/exports, but cross-file references remain
+ * heuristic until LSP proof is attached by the graph adapter or followed via
+ * `next.semantic`.
+ *
+ * This module is a thin barrel: the evidence model (types/interfaces) lives in
+ * `./packets/types.ts`, and the packet-construction logic (including
+ * `buildResearchPackets`/`tallyPacketVerdicts`) lives in `./packets/builders.ts`.
+ * Both are re-exported here so existing `from '.../research/packets.js'`
+ * imports keep working unchanged.
+ */
+export type { EvidenceSource, EvidenceConfidence, EvidenceLocation, EvidenceSubject, EvidenceClaim, EvidenceFlag, EvidenceFact, EvidenceRelation, EvidenceEdge, PacketVerdict, PacketProofStatus, MissingProofKind, MissingProof, ResearchEvidencePacket, ResearchGraphSummary, ResearchPacketBundle, } from './packets/types.js';
+export { buildResearchPackets, tallyPacketVerdicts, } from './packets/builders.js';

package/dist/oql/run/batch.d.ts

@@ -0,0 +1,3 @@
+import type { OqlBatch, OqlBatchResultEnvelope } from '../types.js';
+import { type RunOptions } from './single.js';
+export declare function runBatch(batch: OqlBatch, rawInput: unknown, options: RunOptions): Promise<OqlBatchResultEnvelope>;

package/dist/oql/run/continuations/records.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Per-row continuation builders for code/content rows and record rows
+ * (materialized/research/graph). See registry.ts for how these are
+ * wired into ROW_CONTINUATION_BUILDERS and attached to result rows.
+ */
+import type { OqlContinuation, OqlResultRow } from '../../types.js';
+import type { ContinuationCtx } from './types.js';
+export declare function buildCodeContinuations(row: OqlResultRow, ctx: ContinuationCtx): Record<string, OqlContinuation> | undefined;
+export declare function buildContentContinuations(row: OqlResultRow, ctx: ContinuationCtx): Record<string, OqlContinuation> | undefined;
+export declare function buildMaterializedContinuations(row: OqlResultRow): Record<string, OqlContinuation> | undefined;
+/**
+ * `target:"research"` stays candidate-grade — it never runs LSP internally — but
+ * it emits a one-call `next.graph` upgrade. `target:"graph"` emits the same
+ * upgrade when an analyze row still has missing proof. The upgrade is page-aligned
+ * and bounded by `proofLimit`, so agents can close proof without losing the
+ * research/graph honesty boundary.
+ */
+export declare function buildResearchContinuations(row: OqlResultRow, ctx: ContinuationCtx): Record<string, OqlContinuation> | undefined;
+export declare function buildGraphContinuations(row: OqlResultRow, ctx: ContinuationCtx): Record<string, OqlContinuation> | undefined;

package/dist/oql/run/continuations/registry.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Emit executable `next.*` continuations (contract Gate 10). Every continuation
+ * is a full canonical OQL query runnable as-is.
+ *
+ * Envelope-level:
+ *  - next.page      — more result pages remain
+ *  - next.matchPage — per-file matches were capped
+ *
+ * Per-row continuations are produced by a registry keyed by row kind (and, for
+ * record rows, recordType) so adding a new row's continuations is one entry,
+ * never another `else if`:
+ *  - code        → next.fetch (read exact content) [+ next.semantic on local]
+ *  - content     → next.charRange (page the body)
+ *  - materialized→ next.structure / next.files rooted at the checkpoint path
+ *  - semantics   → next.fetch (read the code at a symbol location)
+ *  - graph       → next.graph (bounded LSP proof for candidate graph pages)
+ */
+import type { AdapterResult } from '../../adapters/local.js';
+import type { OqlContinuation, OqlContinuationHint, OqlQuery, OqlResultRow } from '../../types.js';
+export declare function attachContinuations(query: OqlQuery, exec: AdapterResult): Record<string, OqlContinuation>;
+export declare function compactRowContinuationHints(results: OqlResultRow[]): Record<string, OqlContinuationHint> | undefined;
+export declare function hintsEqual(left: OqlContinuationHint, right: OqlContinuationHint): boolean;

package/dist/oql/run/continuations/semantics.d.ts

@@ -0,0 +1,3 @@
+import type { OqlContinuation, OqlResultRow } from '../../types.js';
+import type { ContinuationCtx } from './types.js';
+export declare function buildSemanticsContinuations(row: OqlResultRow, ctx: ContinuationCtx): Record<string, OqlContinuation> | undefined;

package/dist/oql/run/continuations/types.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shared types for the per-row continuation builders (registry.ts, records.ts,
+ * semantics.ts). Split out so builder modules can share the context/type shape
+ * without creating a runtime circular import with the registry.
+ */
+import type { OqlContinuation, OqlQuery, OqlResultRow } from '../../types.js';
+export interface ContinuationCtx {
+    query: OqlQuery;
+    /** code rows: rebuild an absolute `from` from a relativized row path. */
+    fileFrom?: (rowPath: string) => OqlQuery['from'];
+}
+export type RowContinuationBuilder = (row: OqlResultRow, ctx: ContinuationCtx) => Record<string, OqlContinuation> | undefined;

package/dist/oql/run/dryRun.d.ts

@@ -0,0 +1,11 @@
+import type { PlanQueryResult } from '../planner.js';
+import type { OqlQuery, OqlResultEnvelope } from '../types.js';
+/**
+ * `target:"files"` over a GitHub source with no `where` cannot be enumerated by
+ * the provider, so the plan is non-executable (audit #6). Instead of a dead end,
+ * hand the agent a runnable next.materialize query — clone a bounded corpus and
+ * list files from the materialized checkpoint — mirroring the providerUnindexed
+ * recovery path.
+ */
+export declare function blockedMaterializeContinuation(query?: OqlQuery): OqlResultEnvelope['next'] | undefined;
+export declare function unsupportedEnvelopeFromPlan(planned: PlanQueryResult, plan: OqlResultEnvelope['plan'], queryId?: string, queryIndex?: number, dryRun?: boolean, query?: OqlQuery): OqlResultEnvelope;

package/dist/oql/run/paths.d.ts

@@ -0,0 +1,15 @@
+import type { OqlQuery, OqlResultRow } from '../types.js';
+export declare function relativizeBase(root: string): string;
+export declare function queryLocalRoot(query: OqlQuery): string | undefined;
+/**
+ * Relativize absolute local result paths to the query root (see relativizeBase),
+ * keeping `search` aligned with the former grep/ls shortcuts and far less verbose. Provider
+ * (GitHub) paths are already repo-relative and left untouched.
+ */
+export declare function relativizeResultPaths(query: OqlQuery, results: OqlResultRow[]): void;
+/**
+ * For local/materialized sources, return a builder that turns a relativized
+ * row path back into an absolute-file `from` (relativization stripped exactly
+ * `dirname(resolve(root)) + '/'`, so re-adding it round-trips).
+ */
+export declare function localFileSource(query: OqlQuery): ((rowPath: string) => OqlQuery['from']) | undefined;

package/dist/oql/run/proofGrades.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Proof-grade inference: labels every result row with how strong its evidence
+ * is (structural/text/semantic/graph/candidate/missing), defaulting any row a
+ * backend didn't already grade.
+ */
+import type { OqlProofGradedResultRow, OqlQuery, OqlResultRow } from '../types.js';
+export declare function applyProofGrades(query: OqlQuery, results: OqlResultRow[]): asserts results is OqlProofGradedResultRow[];
+export declare function hasMissingProof(data: Record<string, unknown>): boolean;

package/dist/oql/run/select.d.ts

@@ -0,0 +1,10 @@
+import type { OqlQuery, OqlResultEnvelope, OqlResultRow } from '../types.js';
+/**
+ * Project result rows to the requested `select` fields. Projection only: it
+ * filters which fields/continuations appear, never adds data or changes the
+ * result domain. Identity fields always survive. Unknown selectors yield a
+ * non-blocking `unknownField` diagnostic. Dotted record-data selectors
+ * (e.g. `data.summary`) are accepted but not sub-projected (the whole `data`
+ * stays if `data` is selected).
+ */
+export declare function applySelect(query: OqlQuery, results: OqlResultRow[]): OqlResultEnvelope['diagnostics'];

package/dist/oql/run/single.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Single-query execution: normalize -> plan -> (explain) -> execute via
+ * adapter -> envelope. Also the per-result-set helpers (pagination window,
+ * shared-ref pruning, uniform-source stripping) that only apply within one
+ * query's result set.
+ */
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import type { OqlQuery, OqlResultEnvelope, OqlResultRow } from '../types.js';
+export interface RunOptions {
+    authInfo?: AuthInfo;
+    /** Plan only; do not execute. Maps to `octocode search --dry-run`. */
+    dryRun?: boolean;
+}
+/**
+ * Per-row `source` is identical for every row of a single-source query (one
+ * `from`), so repeating it on each row is pure token noise — the source already
+ * lives once in `provenance`. Strip it when uniform. A merged cross-source batch
+ * has rows from different sources (NOT uniform) → kept, so mergeChildren's
+ * rowKey dedup stays exact. Always runs AFTER merge.
+ */
+export declare function stripUniformSource(results: OqlResultRow[]): void;
+export declare function runSingle(query: OqlQuery, rawInput: unknown, options: RunOptions, queryIndex?: number): Promise<OqlResultEnvelope>;

package/dist/oql/run.d.ts

@@ -1,32 +1,5 @@
-import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
-import { type OqlContinuation, type OqlQuery, type OqlResultRow, type OqlRunResult, type OqlSearchInput } from './types.js';
-export interface RunOptions {
-    authInfo?: AuthInfo;
-    /** Plan only; do not execute. Maps to `octocode search --dry-run`. */
-    dryRun?: boolean;
-}
+import { type OqlRunResult, type OqlSearchInput } from './types.js';
+import { type RunOptions } from './run/single.js';
+export type { RunOptions };
+export type { ContinuationCtx } from './run/continuations/types.js';
 export declare function runOqlSearch(input: OqlSearchInput, options?: RunOptions): Promise<OqlRunResult>;
-/**
- * Emit executable `next.*` continuations (contract Gate 10). Every continuation
- * is a full canonical OQL query runnable as-is.
- *
- * Envelope-level:
- *  - next.page      — more result pages remain
- *  - next.matchPage — per-file matches were capped
- *
- * Per-row continuations are produced by a registry keyed by row kind (and, for
- * record rows, recordType) so adding a new row's continuations is one entry,
- * never another `else if`:
- *  - code        → next.fetch (read exact content) [+ next.semantic on local]
- *  - content     → next.charRange (page the body)
- *  - artifact    → next.structure / next.files rooted at the extracted path
- *  - materialized→ next.structure / next.files rooted at the checkpoint path
- *  - semantics   → next.fetch (read the code at a symbol location)
- *  - graph       → next.graph (bounded LSP proof for candidate graph pages)
- */
-export interface ContinuationCtx {
-    query: OqlQuery;
-    /** code rows: rebuild an absolute `from` from a relativized row path. */
-    fileFrom?: (rowPath: string) => OqlQuery['from'];
-}
-export declare function buildArtifactContinuations(row: OqlResultRow, ctx: ContinuationCtx): Record<string, OqlContinuation> | undefined;

package/dist/oql/schema/predicates.d.ts

@@ -0,0 +1,12 @@
+/**
+ * OQL predicate-tree Zod schemas.
+ *
+ * Split out of `../schema.ts` (kept as a barrel) so that file stays under the
+ * repo's `max-lines: 400` ESLint rule. This group is self-contained: the
+ * predicate tree (`PredicateSchema`) and its leaf kinds (text/regex/structural
+ * /field) don't depend on anything else in the OQL schema module.
+ */
+import { z } from 'zod';
+export declare const StructuralRuleSchema: z.ZodType;
+export declare const StructuralRuleInputSchema: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodString]>;
+export declare const PredicateSchema: z.ZodType;

package/dist/oql/schema.d.ts

@@ -10,6 +10,8 @@
  *    decide (accept / `ambiguousSugar` / `unknownField`).
  */
 import { z } from 'zod';
+import { PredicateSchema, StructuralRuleSchema, StructuralRuleInputSchema } from './schema/predicates.js';
+export { PredicateSchema, StructuralRuleSchema, StructuralRuleInputSchema };
 export declare const QuerySourceSchema: z.ZodType;
 export declare const QueryScopeSchema: z.ZodOptional<z.ZodObject<{
     path: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
@@ -22,9 +24,6 @@ export declare const QueryScopeSchema: z.ZodOptional<z.ZodObject<{
     minDepth: z.ZodOptional<z.ZodNumber>;
     maxDepth: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>>;
-export declare const StructuralRuleSchema: z.ZodType;
-export declare const StructuralRuleInputSchema: z.ZodUnion<readonly [z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>, z.ZodString]>;
-export declare const PredicateSchema: z.ZodType;
 export declare const MaterializePolicySchema: z.ZodObject<{
     mode: z.ZodEnum<{
         never: "never";
@@ -52,11 +51,13 @@ export declare const FetchInstructionsSchema: z.ZodObject<{
             regex: z.ZodOptional<z.ZodBoolean>;
             caseSensitive: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict>>;
-        contentView: z.ZodOptional<z.ZodEnum<{
+        contentView: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
             compact: "compact";
-            symbols: "symbols";
             exact: "exact";
-        }>>;
+            none: "none";
+            standard: "standard";
+            symbols: "symbols";
+        }>, z.ZodTransform<"none" | "standard" | "symbols", "compact" | "exact" | "none" | "standard" | "symbols">>>;
         charOffset: z.ZodOptional<z.ZodNumber>;
         charLength: z.ZodOptional<z.ZodNumber>;
         fullContent: z.ZodOptional<z.ZodBoolean>;
@@ -92,10 +93,10 @@ export declare const QueryControlsSchema: z.ZodObject<{
         matchPage: z.ZodOptional<z.ZodNumber>;
         sort: z.ZodOptional<z.ZodEnum<{
             path: "path";
+            modified: "modified";
             size: "size";
             created: "created";
             name: "name";
-            modified: "modified";
             accessed: "accessed";
             relevance: "relevance";
             matchCount: "matchCount";
@@ -160,11 +161,13 @@ export declare const OqlQuerySchema: z.ZodObject<{
                 regex: z.ZodOptional<z.ZodBoolean>;
                 caseSensitive: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strict>>;
-            contentView: z.ZodOptional<z.ZodEnum<{
+            contentView: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
                 compact: "compact";
-                symbols: "symbols";
                 exact: "exact";
-            }>>;
+                none: "none";
+                standard: "standard";
+                symbols: "symbols";
+            }>, z.ZodTransform<"none" | "standard" | "symbols", "compact" | "exact" | "none" | "standard" | "symbols">>>;
             charOffset: z.ZodOptional<z.ZodNumber>;
             charLength: z.ZodOptional<z.ZodNumber>;
             fullContent: z.ZodOptional<z.ZodBoolean>;
@@ -206,10 +209,10 @@ export declare const OqlQuerySchema: z.ZodObject<{
             matchPage: z.ZodOptional<z.ZodNumber>;
             sort: z.ZodOptional<z.ZodEnum<{
                 path: "path";
+                modified: "modified";
                 size: "size";
                 created: "created";
                 name: "name";
-                modified: "modified";
                 accessed: "accessed";
                 relevance: "relevance";
                 matchCount: "matchCount";
@@ -283,11 +286,13 @@ export declare const OqlBatchSchema: z.ZodObject<{
                     regex: z.ZodOptional<z.ZodBoolean>;
                     caseSensitive: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strict>>;
-                contentView: z.ZodOptional<z.ZodEnum<{
+                contentView: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
                     compact: "compact";
-                    symbols: "symbols";
                     exact: "exact";
-                }>>;
+                    none: "none";
+                    standard: "standard";
+                    symbols: "symbols";
+                }>, z.ZodTransform<"none" | "standard" | "symbols", "compact" | "exact" | "none" | "standard" | "symbols">>>;
                 charOffset: z.ZodOptional<z.ZodNumber>;
                 charLength: z.ZodOptional<z.ZodNumber>;
                 fullContent: z.ZodOptional<z.ZodBoolean>;
@@ -329,10 +334,10 @@ export declare const OqlBatchSchema: z.ZodObject<{
                 matchPage: z.ZodOptional<z.ZodNumber>;
                 sort: z.ZodOptional<z.ZodEnum<{
                     path: "path";
+                    modified: "modified";
                     size: "size";
                     created: "created";
                     name: "name";
-                    modified: "modified";
                     accessed: "accessed";
                     relevance: "relevance";
                     matchCount: "matchCount";
@@ -412,11 +417,13 @@ export declare const OqlCanonicalInputSchema: z.ZodUnion<readonly [z.ZodObject<{
                 regex: z.ZodOptional<z.ZodBoolean>;
                 caseSensitive: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strict>>;
-            contentView: z.ZodOptional<z.ZodEnum<{
+            contentView: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
                 compact: "compact";
-                symbols: "symbols";
                 exact: "exact";
-            }>>;
+                none: "none";
+                standard: "standard";
+                symbols: "symbols";
+            }>, z.ZodTransform<"none" | "standard" | "symbols", "compact" | "exact" | "none" | "standard" | "symbols">>>;
             charOffset: z.ZodOptional<z.ZodNumber>;
             charLength: z.ZodOptional<z.ZodNumber>;
             fullContent: z.ZodOptional<z.ZodBoolean>;
@@ -458,10 +465,10 @@ export declare const OqlCanonicalInputSchema: z.ZodUnion<readonly [z.ZodObject<{
             matchPage: z.ZodOptional<z.ZodNumber>;
             sort: z.ZodOptional<z.ZodEnum<{
                 path: "path";
+                modified: "modified";
                 size: "size";
                 created: "created";
                 name: "name";
-                modified: "modified";
                 accessed: "accessed";
                 relevance: "relevance";
                 matchCount: "matchCount";
@@ -534,11 +541,13 @@ export declare const OqlCanonicalInputSchema: z.ZodUnion<readonly [z.ZodObject<{
                     regex: z.ZodOptional<z.ZodBoolean>;
                     caseSensitive: z.ZodOptional<z.ZodBoolean>;
                 }, z.core.$strict>>;
-                contentView: z.ZodOptional<z.ZodEnum<{
+                contentView: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
                     compact: "compact";
-                    symbols: "symbols";
                     exact: "exact";
-                }>>;
+                    none: "none";
+                    standard: "standard";
+                    symbols: "symbols";
+                }>, z.ZodTransform<"none" | "standard" | "symbols", "compact" | "exact" | "none" | "standard" | "symbols">>>;
                 charOffset: z.ZodOptional<z.ZodNumber>;
                 charLength: z.ZodOptional<z.ZodNumber>;
                 fullContent: z.ZodOptional<z.ZodBoolean>;
@@ -580,10 +589,10 @@ export declare const OqlCanonicalInputSchema: z.ZodUnion<readonly [z.ZodObject<{
                 matchPage: z.ZodOptional<z.ZodNumber>;
                 sort: z.ZodOptional<z.ZodEnum<{
                     path: "path";
+                    modified: "modified";
                     size: "size";
                     created: "created";
                     name: "name";
-                    modified: "modified";
                     accessed: "accessed";
                     relevance: "relevance";
                     matchCount: "matchCount";
@@ -654,11 +663,13 @@ export declare const OqlDisplayQuerySchema: z.ZodObject<{
                 regex: z.ZodOptional<z.ZodBoolean>;
                 caseSensitive: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strict>>;
-            contentView: z.ZodOptional<z.ZodEnum<{
+            contentView: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
                 compact: "compact";
-                symbols: "symbols";
                 exact: "exact";
-            }>>;
+                none: "none";
+                standard: "standard";
+                symbols: "symbols";
+            }>, z.ZodTransform<"none" | "standard" | "symbols", "compact" | "exact" | "none" | "standard" | "symbols">>>;
             charOffset: z.ZodOptional<z.ZodNumber>;
             charLength: z.ZodOptional<z.ZodNumber>;
             fullContent: z.ZodOptional<z.ZodBoolean>;
@@ -700,10 +711,10 @@ export declare const OqlDisplayQuerySchema: z.ZodObject<{
             matchPage: z.ZodOptional<z.ZodNumber>;
             sort: z.ZodOptional<z.ZodEnum<{
                 path: "path";
+                modified: "modified";
                 size: "size";
                 created: "created";
                 name: "name";
-                modified: "modified";
                 accessed: "accessed";
                 relevance: "relevance";
                 matchCount: "matchCount";
@@ -788,11 +799,13 @@ export declare const OqlInputQuerySchema: z.ZodObject<{
                 regex: z.ZodOptional<z.ZodBoolean>;
                 caseSensitive: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strict>>;
-            contentView: z.ZodOptional<z.ZodEnum<{
+            contentView: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
                 compact: "compact";
-                symbols: "symbols";
                 exact: "exact";
-            }>>;
+                none: "none";
+                standard: "standard";
+                symbols: "symbols";
+            }>, z.ZodTransform<"none" | "standard" | "symbols", "compact" | "exact" | "none" | "standard" | "symbols">>>;
             charOffset: z.ZodOptional<z.ZodNumber>;
             charLength: z.ZodOptional<z.ZodNumber>;
             fullContent: z.ZodOptional<z.ZodBoolean>;
@@ -834,10 +847,10 @@ export declare const OqlInputQuerySchema: z.ZodObject<{
             matchPage: z.ZodOptional<z.ZodNumber>;
             sort: z.ZodOptional<z.ZodEnum<{
                 path: "path";
+                modified: "modified";
                 size: "size";
                 created: "created";
                 name: "name";
-                modified: "modified";
                 accessed: "accessed";
                 relevance: "relevance";
                 matchCount: "matchCount";
@@ -935,11 +948,13 @@ export declare const OqlSearchInputSchema: z.ZodObject<{
                 regex: z.ZodOptional<z.ZodBoolean>;
                 caseSensitive: z.ZodOptional<z.ZodBoolean>;
             }, z.core.$strict>>;
-            contentView: z.ZodOptional<z.ZodEnum<{
+            contentView: z.ZodOptional<z.ZodPipe<z.ZodEnum<{
                 compact: "compact";
-                symbols: "symbols";
                 exact: "exact";
-            }>>;
+                none: "none";
+                standard: "standard";
+                symbols: "symbols";
+            }>, z.ZodTransform<"none" | "standard" | "symbols", "compact" | "exact" | "none" | "standard" | "symbols">>>;
             charOffset: z.ZodOptional<z.ZodNumber>;
             charLength: z.ZodOptional<z.ZodNumber>;
             fullContent: z.ZodOptional<z.ZodBoolean>;
@@ -981,10 +996,10 @@ export declare const OqlSearchInputSchema: z.ZodObject<{
             matchPage: z.ZodOptional<z.ZodNumber>;
             sort: z.ZodOptional<z.ZodEnum<{
                 path: "path";
+                modified: "modified";
                 size: "size";
                 created: "created";
                 name: "name";
-                modified: "modified";
                 accessed: "accessed";
                 relevance: "relevance";
                 matchCount: "matchCount";