@octocodeai/octocode-engine 16.5.0

package/index.d.ts

@@ -0,0 +1,934 @@
+/* auto-generated by NAPI-RS */
+/* eslint-disable */
+export declare class NativeLspClient {
+  constructor(config: JsLanguageServerConfig)
+  start(): Promise<void>
+  stop(): Promise<void>
+  waitForReady(timeoutMs?: number | undefined | null): Promise<void>
+  hasCapability(capability: string): boolean
+  getRecentStderr(): Array<string>
+  /**
+   * Sync a document's in-memory content to the server, honoring the LSP
+   * document lifecycle: the FIRST sync of a URI sends `textDocument/didOpen`
+   * (version 1); every subsequent sync sends `textDocument/didChange` with an
+   * incremented version and a full-document content change. Re-sending
+   * `didOpen` (as before) is ignored or rejected by many servers and can make
+   * changed content resolve against the stale original.
+   */
+  openDocument(filePath: string, content: string): Promise<void>
+  /**
+   * Close a previously opened document (`textDocument/didClose`) and forget
+   * its version, so a later `open_document` starts a fresh `didOpen`.
+   */
+  closeDocument(filePath: string): Promise<void>
+  getDefinition(filePath: string, line: number, character: number): Promise<Array<JsCodeSnippet>>
+  getReferences(filePath: string, line: number, character: number, includeDeclaration?: boolean | undefined | null): Promise<Array<JsCodeSnippet>>
+  getHover(filePath: string, line: number, character: number): Promise<any>
+  getTypeDefinition(filePath: string, line: number, character: number): Promise<Array<JsCodeSnippet>>
+  getImplementation(filePath: string, line: number, character: number): Promise<Array<JsCodeSnippet>>
+  getDocumentSymbols(filePath: string): Promise<any>
+  prepareCallHierarchy(filePath: string, line: number, character: number): Promise<any>
+  incomingCalls(item: any): Promise<any>
+  outgoingCalls(item: any): Promise<any>
+}
+
+/**
+ * Agent-readable "standard" view: strips comments and blank-line noise while
+ * preserving indentation and code shape. Capped at 1MB; panic-contained.
+ */
+export declare function applyContentViewMinification(content: string, filePath: string): string
+
+/**
+ * Full minification that never grows the content — returns the minified
+ * form only when it is shorter, otherwise the original. Panic-contained.
+ */
+export declare function applyMinification(content: string, filePath: string): string
+
+/**
+ * Structural inspection of a binary (executable / object / archive) file.
+ *
+ * `format`/`arch`/`bits`/`endianness`/`stripped` are always populated (the
+ * fields the old `identify` mode produced). The list fields are populated only
+ * when the file is a recognized executable format `goblin` could parse; for an
+ * unrecognized file they stay empty and `notes` explains why (e.g. "use
+ * mode=list/decompress for archives").
+ *
+ * Every list is capped (see `crate::binary::inspect::LIST_CAP`); the `*_count`
+ * fields carry the true totals, and `truncated` is set when any list was cut.
+ */
+export interface BinaryInspectInfo {
+  /** elf | macho | macho-fat | pe | coff | archive | wasm | unknown */
+  format: string
+  /** Human-readable one-line summary (drop-in for `file -b`). */
+  description: string
+  /** Space-separated hex of the leading bytes (drop-in for `xxd -p -l 32`). */
+  magicHex: string
+  arch?: string
+  bits?: number
+  /** "little" | "big" */
+  endianness?: string
+  stripped?: boolean
+  /** Hex entry-point address, when the format has one. */
+  entry?: string
+  symbols: Array<string>
+  imports: Array<string>
+  exports: Array<string>
+  sections: Array<string>
+  /** Dynamic dependencies / needed shared libraries. */
+  libraries: Array<string>
+  symbolCount: number
+  importCount: number
+  exportCount: number
+  /** True when any list was capped. */
+  truncated: boolean
+  /** Advisory notes (unrecognized format, parse degradation, size truncation). */
+  notes: Array<string>
+}
+
+/** Result of a strings extraction pass over a binary buffer. */
+export interface BinaryStrings {
+  /**
+   * Printable runs, longest-first. ASCII **and** UTF-16 (LE/BE) — the win
+   * over GNU `strings -a`, which misses wide strings. Each entry is prefixed
+   * with its hex byte offset when offsets were requested.
+   */
+  strings: Array<string>
+  /** Total runs found before any display capping. */
+  totalFound: number
+  /**
+   * True when more of the file remains to scan beyond this window — follow
+   * `next_scan_offset`. Lossless continuation cursor, **not** a data-loss
+   * flag (the old fixed-cap meaning): every byte is reachable by paging.
+   */
+  truncated: boolean
+  /**
+   * Absolute byte offset to start the next scan window, or `None` at EOF.
+   * Rewound to a safe break so no string is split across windows.
+   */
+  nextScanOffset?: number
+}
+
+/** Extract a byte-range substring from `content`. */
+export declare function byteSliceContent(content: string, byteStart: number, byteEnd: number): string
+
+/**
+ * JavaScript UTF-16 code-unit offset for `byte_offset` bytes into `content`.
+ * Zero-allocation — no `Buffer.from()` needed.
+ */
+export declare function byteToCharOffset(content: string, byteOffset: number): number
+
+/**
+ * Number of UTF-8 bytes up to (not including) the `char_index`-th JavaScript
+ * UTF-16 code unit in `content`. Zero-allocation — no `Buffer.from()` needed.
+ */
+export declare function charToByteOffset(content: string, charIndex: number): number
+
+/** Convert an LSP `SymbolKind` numeric code to a human-readable string tag. */
+export declare function convertSymbolKind(kind?: number | undefined | null): string
+
+/** Return the LSP language identifier for the file at `file_path`. */
+export declare function detectLanguageId(filePath: string): string | null
+
+/**
+ * Native strings extraction. Recovers printable ASCII **and** UTF-16 (LE/BE)
+ * runs of at least `min_length` from the scan window of `path` beginning at
+ * `scan_offset`, longest-first, optionally hex offset-prefixed. Replaces the
+ * `strings` shell-out and additionally surfaces the wide strings GNU
+ * `strings -a` misses.
+ *
+ * Lossless pagination: the returned `nextScanOffset` (when set) is the absolute
+ * byte offset of the next window, rewound to a safe break so no string is split
+ * across windows. Pass `scanOffset = 0` for the first window.
+ */
+export declare function extractBinaryStringsNative(path: string, minLength: number, includeOffsets: boolean, scanOffset: number): BinaryStrings
+
+/**
+ * Native JS/TS document symbols (server-free) as a JSON `DocumentSymbol[]`.
+ *
+ * Parses ECMAScript/TypeScript *syntax* with `oxc_parser` and walks
+ * declarations into the LSP `DocumentSymbol` shape (nested, numeric
+ * `SymbolKind`, 0-based UTF-16 ranges). **No type inference** — in-file
+ * scope/binding accuracy only; type-aware outlines still require a language
+ * server. Only `ts/tsx/js/jsx/mjs/cjs/mts/cts` are handled.
+ *
+ * Returns `null` for non-JS/TS files, oversized content, a hard parse failure
+ * (caller should fall back to `extractSignatures`/tree-sitter), or a file with
+ * no extractable top-level symbols.
+ */
+export declare function extractJsSymbols(content: string, filePath: string): string | null
+
+/**
+ * Search `content` line-by-line for `pattern` (literal or regex), returning
+ * matched lines with context windows and omission markers.
+ *
+ * Replaces `extractMatchingLines` (contentExtractor.ts) which performed 2–3
+ * full `forEach` scans with per-line `toLowerCase` + `RegExp.test`.
+ */
+export declare function extractMatchingLines(content: string, pattern: string, options?: ExtractMatchingLinesOptions | undefined | null): ExtractMatchingLinesResult
+
+export interface ExtractMatchingLinesOptions {
+  /** Treat `pattern` as a regex (default false — literal match). */
+  isRegex?: boolean
+  /** Case-sensitive match (default false). */
+  caseSensitive?: boolean
+  /** Lines of context to include around each match (default 0). */
+  contextLines?: number
+  /** Cap the number of matched lines returned. */
+  maxMatches?: number
+}
+
+export interface ExtractMatchingLinesResult {
+  /** Output lines including context and omission markers. */
+  lines: Array<string>
+  /** 1-based line numbers of actual matches (capped by `max_matches`). */
+  matchingLines: Array<number>
+  /** Total matches before `max_matches` cap. */
+  matchCount: number
+  matchRanges: Array<MatchRange>
+}
+
+/**
+ * Structural skeleton with an `NNN| ` line-number gutter, produced purely by
+ * tree-sitter parsing (no regex heuristics). Returns `null` for data/config
+ * formats, any language without a wired grammar, content above the 1MB guard,
+ * and any skeleton that would not be smaller than the source.
+ */
+export declare function extractSignatures(content: string, filePath: string): string | null
+
+export interface FileSystemEntry {
+  /** Absolute or input-root-relative path as returned by the platform. */
+  path: string
+  /** Path relative to the query root. */
+  relativePath: string
+  name: string
+  /** "file", "directory", "symlink", or "other". */
+  entryType: string
+  size?: number
+  modifiedMs?: number
+  accessedMs?: number
+  permissions?: string
+  extension?: string
+  /** Output depth where direct children are 0. */
+  depth: number
+}
+
+export interface FileSystemQueryOptions {
+  path: string
+  /** Include the root path itself in results (default false). */
+  includeRoot?: boolean
+  /** Descend into child directories (default true). */
+  recursive?: boolean
+  /** Maximum depth where direct children are depth 1. */
+  maxDepth?: number
+  /** Minimum depth where direct children are depth 1. */
+  minDepth?: number
+  /** Include dotfiles and dot-directories (default true). */
+  showHidden?: boolean
+  /** Match basename globs, OR-combined. */
+  names?: Array<string>
+  /** Match full path glob. */
+  pathPattern?: string
+  /** Rust regex against basename. */
+  regex?: string
+  /** POSIX find-style entry type: f=file, d=directory, l=symlink. */
+  entryType?: string
+  /** Match only empty files or directories. */
+  empty?: boolean
+  /** Modified within a duration string such as 7d, 2h, 30m. */
+  modifiedWithin?: string
+  /** Modified before a duration string such as 30d. */
+  modifiedBefore?: string
+  /** Accessed within a duration string such as 7d. */
+  accessedWithin?: string
+  /** Size greater than a string such as 100k, 1m, 500b. */
+  sizeGreater?: string
+  /** Size less than a string such as 100k, 1m, 500b. */
+  sizeLess?: string
+  /** Exact octal permissions, e.g. 644. */
+  permissions?: string
+  executable?: boolean
+  readable?: boolean
+  writable?: boolean
+  excludeDir?: Array<string>
+  /** Store at most this many matching entries while still counting matches. */
+  limit?: number
+}
+
+export interface FileSystemQueryResult {
+  entries: Array<FileSystemEntry>
+  totalDiscovered: number
+  wasCapped: boolean
+  skipped: number
+  permissionDenied: number
+  warnings: Array<string>
+}
+
+export interface FileTypeMinifyConfig {
+  strategy: string
+  /** CommentPatternGroup | CommentPatternGroup[] */
+  comments?: any
+}
+
+/**
+ * Filter and optionally trim a unified diff patch.
+ *
+ * Replaces `filterPatch` + `trimDiffContext` from `utils/parsers/diff.ts` which
+ * called `patch.split('
+')` independently in both functions. This combines
+ * both operations in a single pass.
+ */
+export declare function filterPatch(patch: string, options?: FilterPatchOptions | undefined | null): string
+
+export interface FilterPatchOptions {
+  /** Only keep additions at these new-file line numbers. */
+  additions?: Array<number>
+  /** Only keep deletions at these original-file line numbers. */
+  deletions?: Array<number>
+  /** Apply context trimming (equivalent to `trimDiffContext`, default false). */
+  trimContext?: boolean
+  /** Context window size when `trim_context` is true (default 2). */
+  contextLines?: number
+}
+
+/**
+ * Native in-file references (server-free) for the JS/TS symbol under
+ * `(line, character)` (0-based, UTF-16), as a JSON `Range[]` covering the
+ * declaration and every resolved in-file reference (declaration first).
+ *
+ * **Same-file only.** oxc resolves bindings within one module; cross-file
+ * references require a language server. No type inference. Returns `null` for
+ * non-JS/TS files, oversized content, a parse failure, or when the cursor is
+ * not on a resolvable binding/reference.
+ */
+export declare function findInFileReferences(content: string, filePath: string, line: number, character: number): string | null
+
+/** Convert a `file://` URI string back to an absolute filesystem path. */
+export declare function fromUri(uri: string): string
+
+/**
+ * Extract the file extension from a path (dotfile-aware).
+ * Options control lowercasing and the configured default used when no extension exists.
+ */
+export declare function getExtension(filePath: string, options?: GetExtensionOptions | undefined | null): string
+
+export interface GetExtensionOptions {
+  lowercase?: boolean
+  fallback?: string
+}
+
+/**
+ * Return the default language server configuration for `file_path` inside
+ * `workspace_root`.
+ */
+export declare function getLanguageServerForFile(filePath: string, workspaceRoot: string): JsLanguageServerConfig | null
+
+/**
+ * Returns the full MINIFY_CONFIG as a JS-compatible object.
+ * Shape: `{ fileTypes: Record<string, { strategy: string, comments: string | string[] | null }> }`
+ */
+export declare function getMINIFY_CONFIG(): any
+
+/**
+ * Returns a sorted list of JS char offsets (UTF-16 code units) where
+ * top-level semantic blocks begin in `content`.
+ *
+ * **Tree-sitter only** (exact AST): `ts tsx js jsx mjs cjs mts cts py pyi go rs
+ *   java c h cpp cc cxx hpp hh hxx cs sh bash zsh`. Languages without a wired
+ * grammar and structural-only grammars (HTML/CSS/Scala/JSON/YAML/TOML) return
+ * `[]` — there is no regex/heuristic fallback. Also `[]` for data/config files,
+ * plain text, and files above the 1 MB guard.
+ *
+ * Char offsets match JavaScript `string.substring()` — pass them directly to
+ * JavaScript string slicing without conversion.
+ */
+export declare function getSemanticBoundaryOffsets(content: string, filePath: string): Array<number>
+
+/**
+ * Canonical list of file extensions (lowercase, no leading dot) handled by the
+ * native oxc JS/TS path (`extractJsSymbols` / `findInFileReferences`). Callers
+ * should gate native dispatch on this list rather than hardcoding it, so the
+ * Rust and JS sides never drift.
+ */
+export declare function getSupportedJsTsExtensions(): Array<string>
+
+/**
+ * Returns all extensions that have signature-outline support. This is exactly
+ * the set of tree-sitter grammars with a function-body query (no regex
+ * heuristics): structural-only grammars (HTML/CSS/Scala/JSON/YAML/TOML) are
+ * excluded because they produce no outline.
+ */
+export declare function getSupportedSignatureExtensions(): Array<string>
+
+export declare function getSupportedStructuralExtensions(): Array<string>
+
+/**
+ * Native binary inspection (format lane). Parses `path` as an executable /
+ * object / archive and returns its identity plus — for recognized executable
+ * formats — symbols, imports, exports, sections and dynamic dependencies.
+ *
+ * Replaces the `file` + `xxd` shell-outs. Never throws on malformed input: a
+ * parse failure degrades to magic-byte identity with an explanatory note. The
+ * only `Err` cases are unreadable / oversized files.
+ */
+export declare function inspectBinaryNative(path: string): BinaryInspectInfo
+
+/** Check whether `command` is available on `PATH`. */
+export declare function isCommandAvailable(command: string): boolean
+
+export interface JsCodeSnippet {
+  uri: string
+  range: JsRange
+  content: string
+  symbolKind?: string
+  displayRange?: any
+}
+
+export interface JsExactPosition {
+  line: number
+  character: number
+}
+
+export interface JsFuzzyPosition {
+  symbolName: string
+  lineHint?: number
+  orderHint?: number
+}
+
+export interface JsLanguageServerConfig {
+  command: string
+  args?: Array<string>
+  workspaceRoot: string
+  languageId?: string
+  initializationOptions?: any
+  /** Extra environment variables to inject into the language server process. */
+  env?: Record<string, string>
+}
+
+/**
+ * Serialize a JSON value to YAML — the formatter for every MCP tool
+ * response. Optional key sorting and priority-key ordering; multiline
+ * strings become block scalars. Emission is locked by yaml_utils tests.
+ */
+export declare function jsonToYamlString(jsonObject: any, config?: YamlConversionConfig | undefined | null): string
+
+export interface JsRange {
+  start: JsExactPosition
+  end: JsExactPosition
+}
+
+export interface JsResolvedSymbol {
+  position: JsExactPosition
+  foundAtLine: number
+  lineOffset: number
+  lineContent: string
+}
+
+/**
+ * Mask secrets in place: every even-indexed char of a matched secret becomes
+ * `*`, preserving partial readability. File-context patterns are skipped.
+ */
+export declare function maskSensitiveData(text: string): string
+
+export interface MatchRange {
+  /** 1-based inclusive start line. */
+  start: number
+  /** 1-based inclusive end line. */
+  end: number
+}
+
+/**
+ * Aggressive strategy: strip comments, collapse all whitespace, tighten
+ * punctuation. Lossy — for token-budget views only.
+ */
+export declare function minifyAggressiveCore(content: string, config: FileTypeMinifyConfig): string
+
+/**
+ * Whitespace-only code cleanup: trim line ends, collapse 3+ blank lines,
+ * preserve indentation.
+ */
+export declare function minifyCodeCore(content: string): string
+
+/**
+ * Conservative strategy: strip the configured comment groups, collapse blank
+ * runs, preserve indentation.
+ */
+export declare function minifyConservativeCore(content: string, config: FileTypeMinifyConfig): string
+
+/**
+ * Full minification on libuv's worker pool.
+ * Returns a Promise from JavaScript and does not block the event loop.
+ */
+export declare function minifyContent(content: string, filePath: string): Promise<unknown>
+
+/** Synchronous full minification result. */
+export declare function minifyContentResult(content: string, filePath: string): MinifyResult
+
+/**
+ * Full minification, synchronous. Content above the 1MB guard is returned
+ * unchanged; unknown file types use the general strategy.
+ */
+export declare function minifyContentSync(content: string, filePath: string): string
+
+/**
+ * Lightweight CSS cleanup (comment strip + whitespace). See
+ * `minifyCSSQuality` for the lightningcss-backed variant.
+ */
+export declare function minifyCSSCore(content: string): string
+
+/**
+ * CSS minification via lightningcss — parser-grade, strips comments and
+ * redundant units.
+ */
+export declare function minifyCSSQuality(content: string): string
+
+/** Generic text cleanup for unknown file types: trim + collapse blank runs. */
+export declare function minifyGeneralCore(content: string): string
+
+/**
+ * Lightweight HTML/XML cleanup (comment strip + whitespace). See
+ * `minifyHTMLQuality` for the style-aware built-in variant.
+ */
+export declare function minifyHTMLCore(content: string): string
+
+/**
+ * Style-aware HTML cleanup: strips comments, tightens whitespace, and minifies
+ * embedded `<style>` blocks through the existing CSS pipeline.
+ */
+export declare function minifyHTMLQuality(content: string): string
+
+/**
+ * Heuristic JS minifier (comment strip + whitespace tightening) used when
+ * the OXC pipeline declines the input.
+ */
+export declare function minifyJavaScriptCore(content: string): string
+
+/**
+ * Compact JSON to a single line. JSONC/JSON5 noise (comments, trailing
+ * commas) is stripped before parsing; unparseable input is returned trimmed.
+ */
+export declare function minifyJsonCore(content: string): MinifyResult
+
+/**
+ * Readable JSON view: keeps formatting, strips JSONC noise and trailing
+ * whitespace, collapses blank runs. Valid JSON passes through unchanged.
+ */
+export declare function minifyJsonReadable(content: string): MinifyResult
+
+/**
+ * Markdown view: drops HTML comments, badges, and generated TOCs; compacts
+ * tables and headings; preserves code fences and frontmatter verbatim.
+ */
+export declare function minifyMarkdownCore(content: string): string
+
+export interface MinifyResult {
+  content: string
+  failed: boolean
+  /** Strategy name or "failed" */
+  type: string
+  reason?: string
+}
+
+export interface ParsedPatchLine {
+  originalLineNumber?: number
+  newLineNumber?: number
+  content: string
+  lineType: PatchLineType
+}
+
+/**
+ * Parse ripgrep `--json` NDJSON stdout into structured files + stats.
+ *
+ * Replaces the TypeScript `parseRipgrepJson` (utils/parsers/ripgrep.ts) which
+ * used `JSON.parse` + Zod `safeParse` per NDJSON line and a `[...value]`
+ * UTF-16 spread per match snippet. A single `serde_json` streaming pass with
+ * no per-line schema validation.
+ */
+export declare function parseRipgrepJson(stdout: string, options?: RipgrepParseOptions | undefined | null): RipgrepParseResult
+
+export declare const enum PatchLineType {
+  Addition = 'Addition',
+  Deletion = 'Deletion',
+  Context = 'Context'
+}
+
+/** Number of loaded secret-detection patterns (testing / benchmarking). */
+export declare function patternCount(): number
+
+/**
+ * Cross-platform filesystem traversal and metadata filtering for local tools.
+ *
+ * Replaces the POSIX `find`/`ls` execution paths in octocode-tools-core while
+ * keeping MCP response shaping in TypeScript.
+ */
+export declare function queryFileSystem(options: FileSystemQueryOptions): FileSystemQueryResult
+
+/** `commentTypes` accepts a single string or array of strings. */
+export declare function removeComments(content: string, commentTypes: any): string
+
+/**
+ * Resolve a fuzzy symbol position (name + optional line hint) to an exact
+ * line/character position inside the file at `file_path`.
+ */
+export declare function resolvePosition(filePath: string, fuzzy: JsFuzzyPosition): JsResolvedSymbol
+
+/**
+ * Resolve a fuzzy symbol position against in-memory `content` rather than
+ * reading from disk. Use when the caller already holds the file text.
+ */
+export declare function resolvePositionFromContent(content: string, fuzzy: JsFuzzyPosition): JsResolvedSymbol
+
+/** Walk upward from `file_path` to find the workspace root. */
+export declare function resolveWorkspaceRootForFile(filePath: string): string
+
+export interface RipgrepFile {
+  path: string
+  matchCount: number
+  matches: Array<RipgrepMatch>
+}
+
+export interface RipgrepMatch {
+  /** 1-based line number. */
+  line: number
+  /** 0-based column offset of the first submatch. */
+  column: number
+  /** Assembled match + context window, truncated to `max_snippet_chars`. */
+  value: string
+  /** Frequency for this value when `count_unique` is enabled. */
+  count?: number
+  /**
+   * AST node-kind label (declaration|import|export|callsite|identifier|
+   * comment|string|configKey|heading) when `classify_matches` is enabled.
+   * `None` when classification was off, the language is unsupported, or the
+   * file failed to parse.
+   */
+  kind?: string
+  /** Deterministic relevance hint (0.0..1.0) derived from `kind`. */
+  scoreHint?: number
+}
+
+export interface RipgrepParseOptions {
+  /** Number of context lines around each match (default 0). */
+  contextLines?: number
+  /** Max Unicode chars per match snippet (default 500). */
+  maxSnippetChars?: number
+}
+
+export interface RipgrepParseResult {
+  files: Array<RipgrepFile>
+  stats: RipgrepStats
+}
+
+export interface RipgrepPatternValidationResult {
+  valid: boolean
+  error?: string
+}
+
+/**
+ * Options for the in-process ripgrep search (`searchRipgrep`). Field semantics
+ * mirror the ripgrep CLI flags the old `RipgrepCommandBuilder` emitted, so the
+ * search behaves identically to shelling out to `rg`.
+ */
+export interface RipgrepSearchOptions {
+  /** Search root: a directory (recursive) or a single file. */
+  path: string
+  /** The search pattern (rg's positional pattern / `keywords`). */
+  pattern: string
+  /** Treat the pattern as a literal string, not a regex (`-F`). */
+  fixedString?: boolean
+  /** Use the PCRE2 engine for lookaround/backreferences (`-P`). */
+  perlRegex?: boolean
+  /** Case-sensitive match (`-s`). Wins over `case_insensitive`. */
+  caseSensitive?: boolean
+  /** Case-insensitive match (`-i`). Default is smart-case (`-S`). */
+  caseInsensitive?: boolean
+  /** Match whole words only (`-w`). */
+  wholeWord?: boolean
+  /** Invert: report non-matching lines (`-v`). */
+  invertMatch?: boolean
+  /** Multi-line mode: `.` and the pattern may span lines (`-U`). */
+  multiline?: boolean
+  /** In multi-line mode, let `.` match newlines (`--multiline-dotall`). */
+  multilineDotall?: boolean
+  /** List only the paths of files that contain a match (`-l`). */
+  filesOnly?: boolean
+  /** List only the paths of files with no match (`--files-without-match`). */
+  filesWithoutMatch?: boolean
+  /** Per-file count of matching lines (`-c`). */
+  countLinesPerFile?: boolean
+  /** Per-file count of individual matches (`--count-matches`). */
+  countMatchesPerFile?: boolean
+  /** Context lines around each match (`-C`). */
+  contextLines?: number
+  /** Restrict to a ripgrep file type, e.g. `ts`, `py` (`-t`). */
+  langType?: string
+  /** Include globs (`-g <glob>`). */
+  include?: Array<string>
+  /** Exclude globs (`-g !<glob>`). */
+  exclude?: Array<string>
+  /** Exclude directories (`-g !<dir>/`). */
+  excludeDir?: Array<string>
+  /** Do not honor .gitignore/.ignore/etc. (`--no-ignore`). */
+  noIgnore?: boolean
+  /** Search hidden files and directories (`--hidden`). */
+  hidden?: boolean
+  /** Sort key: `path` (default), `modified`, `accessed`, or `created`. */
+  sort?: string
+  /** Reverse the sort order (`--sortr`). */
+  sortReverse?: boolean
+  /** Max Unicode chars per assembled snippet (default 500). */
+  maxSnippetChars?: number
+  /**
+   * When true, label each match with its AST node kind (tree-sitter) for
+   * language-aware ranking. Optional and capped by the caller; degrades to
+   * unlabeled matches on unsupported/unparseable files.
+   */
+  classifyMatches?: boolean
+  /**
+   * Emit one match per *submatch* with `value` set to the matched span
+   * (not the whole line) — ripgrep's `-o`/`--only-matching`. The win on a
+   * minified one-liner: line mode can only count hits, this enumerates them.
+   */
+  onlyMatching?: boolean
+  /**
+   * With `only_matching`, widen each span by this many characters on each
+   * side (char-boundary safe), marking trimmed sides with `…`. 0/unset =
+   * the bare matched span.
+   */
+  matchWindow?: number
+  /**
+   * With `only_matching`, collapse duplicate values per file, preserving
+   * first-occurrence order and anchor.
+   */
+  unique?: boolean
+  /**
+   * With `only_matching`, collapse duplicate values and attach their
+   * frequency, sorted by count descending.
+   */
+  countUnique?: boolean
+}
+
+export interface RipgrepStats {
+  matchCount?: number
+  matchedLines?: number
+  filesMatched?: number
+  filesSearched?: number
+  bytesSearched?: number
+  searchTime?: string
+}
+
+/**
+ * Read `file_path` from disk after canonicalizing it and confirming it is an
+ * absolute regular file.
+ */
+export declare function safeReadFile(filePath: string): string
+
+export interface SanitizationResult {
+  content: string
+  hasSecrets: boolean
+  secretsDetected: Array<string>
+  warnings: Array<string>
+}
+
+/**
+ * Detect and redact all secrets from `content`, returning the sanitized string
+ * with `[REDACTED-*]` placeholders plus detection metadata. `file_path` gates
+ * file-context patterns (e.g. Kubernetes/`.env` secrets).
+ */
+export declare function sanitizeContent(content: string, filePath?: string | undefined | null): SanitizationResult
+
+/**
+ * Run ripgrep in-process: walk `path`, search every file with ripgrep's own
+ * engine, and return the same `{ files, stats }` shape the `--json` parser
+ * produced. Replaces shelling out to an `rg` binary (and the `@vscode/ripgrep`
+ * bundle) — octocode is now its own source of ripgrep.
+ *
+ * Runs on the libuv thread pool so the filesystem walk never blocks the event
+ * loop, mirroring the old async `spawn` of `rg`.
+ */
+export declare function searchRipgrep(options: RipgrepSearchOptions): Promise<unknown>
+
+/** Native exports. */
+export const SIGNATURES_ONLY_HINT: string
+
+/**
+ * Paginate `content` by char offset + length, with optional line-boundary
+ * snapping. Replaces both the char-mode conversion block in `applyPagination`
+ * and the dead-code `sliceByCharRespectLines` (0 callers confirmed by LSP).
+ */
+export declare function sliceContent(content: string, charOffset: number, charLength: number, options?: SliceContentOptions | undefined | null): SliceContentResult
+
+export interface SliceContentOptions {
+  /** When true, snap start to line start and end to line end (default false). */
+  snapToLineBoundary?: boolean
+}
+
+export interface SliceContentResult {
+  text: string
+  /** Actual start char offset (may differ from requested when snapping). */
+  charOffset: number
+  charLength: number
+  byteOffset: number
+  byteLength: number
+  hasMore: boolean
+  nextCharOffset?: number
+}
+
+/**
+ * Remove Python docstrings (module/class/function level) while preserving
+ * all runtime code.
+ */
+export declare function stripPythonDocstrings(content: string): string
+
+/**
+ * A structural match with stable evidence metadata. Existing
+ * `StructuralMatch` remains unchanged for the legacy APIs; detailed APIs add
+ * IDs and confidence without forcing old callers to carry metadata.
+ */
+export interface StructuralDetailedMatch {
+  id: string
+  startLine: number
+  endLine: number
+  startCol: number
+  endCol: number
+  text: string
+  metavars: Record<string, Array<string>>
+  nodeKind?: string
+  confidence: string
+}
+
+export interface StructuralDiagnostic {
+  code: string
+  severity: string
+  stage: string
+  message: string
+  path?: string
+  recovery?: string
+}
+
+/**
+ * One structural match. Line numbers are 1-based so `start_line` can be fed
+ * directly as an `lspGetSemantics` `lineHint`; columns are 0-based char
+ * offsets (tree-sitter native).
+ */
+export interface StructuralMatch {
+  startLine: number
+  endLine: number
+  startCol: number
+  endCol: number
+  text: string
+  /**
+   * Captured metavariables. `$X` yields a single-element list;
+   * `$$$ARGS` yields the full list of captured nodes. Keyed by the bare
+   * metavar name (no leading `$`).
+   */
+  metavars: Record<string, Array<string>>
+}
+
+export interface StructuralQueryExplanation {
+  kind: string
+  source: string
+  literalAnchor?: string
+  preFilter: string
+  unsafeReason?: string
+  diagnostics: Array<StructuralDiagnostic>
+}
+
+/**
+ * Structural (AST) search — octocode's L2 layer. Resolves the grammar from
+ * `file_path`'s extension and matches a code-shaped `pattern` OR a YAML `rule`
+ * (exactly one). Returns node ranges (1-based lines, ready as `lineHint`s)
+ * plus captured metavariables. Throws on unsupported extension, invalid
+ * pattern/rule, or both/neither query supplied.
+ */
+export declare function structuralSearch(content: string, filePath: string, pattern?: string | undefined | null, rule?: string | undefined | null): Array<StructuralMatch>
+
+/**
+ * Detailed structural search. Unlike `structuralSearch`, unsupported
+ * extensions and invalid queries are represented as status + diagnostics so
+ * callers can distinguish true empty results from weak evidence.
+ */
+export declare function structuralSearchDetailed(content: string, filePath: string, pattern?: string | undefined | null, rule?: string | undefined | null): StructuralSearchDetailedResult
+
+export interface StructuralSearchDetailedFileResult {
+  path: string
+  status: string
+  languageId?: string
+  skippedReason?: string
+  matches: Array<StructuralDetailedMatch>
+  diagnostics: Array<StructuralDiagnostic>
+}
+
+export interface StructuralSearchDetailedResult {
+  path: string
+  analyzer: string
+  analyzerVersion: string
+  status: string
+  languageId?: string
+  query: StructuralQueryExplanation
+  matches: Array<StructuralDetailedMatch>
+  diagnostics: Array<StructuralDiagnostic>
+}
+
+export interface StructuralSearchFileResult {
+  path: string
+  matches: Array<StructuralMatch>
+}
+
+export declare function structuralSearchFiles(options: StructuralSearchFilesOptions): StructuralSearchFilesResult
+
+export declare function structuralSearchFilesDetailed(options: StructuralSearchFilesOptions): StructuralSearchFilesDetailedResult
+
+export interface StructuralSearchFilesDetailedResult {
+  files: Array<StructuralSearchDetailedFileResult>
+  totalMatches: number
+  parsedFiles: number
+  skippedByPreFilter: number
+  skippedUnsupported: number
+  skippedUnreadable: number
+  skippedLarge: number
+  analyzer: string
+  analyzerVersion: string
+  status: string
+  query: StructuralQueryExplanation
+  diagnostics: Array<StructuralDiagnostic>
+  warnings: Array<string>
+}
+
+export interface StructuralSearchFilesOptions {
+  path: string
+  pattern?: string
+  rule?: string
+  include?: Array<string>
+  excludeDir?: Array<string>
+  maxFiles?: number
+  maxFileBytes?: number
+}
+
+export interface StructuralSearchFilesResult {
+  files: Array<StructuralSearchFileResult>
+  totalMatches: number
+  parsedFiles: number
+  skippedByPreFilter: number
+  skippedUnreadable: number
+  skippedLarge: number
+  warnings: Array<string>
+}
+
+/**
+ * Convert a human-readable symbol kind string back to the LSP `SymbolKind`
+ * numeric code. Unknown strings return `13` (Variable).
+ */
+export declare function toLspSymbolKind(kind: string): number
+
+/** Convert a filesystem path to a `file://` URI string. */
+export declare function toUri(path: string): string
+
+/** Validate that `command` resolves to an executable LSP server binary. */
+export declare function validateLspServerPath(command: string): string
+
+export declare function validateRipgrepPattern(pattern: string, fixedString?: boolean | undefined | null, perlRegex?: boolean | undefined | null): RipgrepPatternValidationResult
+
+export interface YamlConversionConfig {
+  sortKeys?: boolean
+  keysPriority?: Array<string>
+}