@octocodeai/octocode-tools-core 16.2.0

package/dist/tools/local_binary_inspect/binaryInspector.d.ts

@@ -0,0 +1,49 @@
+import type { BinaryInspectQuery } from './scheme.js';
+export declare function inspectBinary(query: BinaryInspectQuery): Promise<import("../../index.js").UnifiedErrorResult | {
+    status: "success";
+    mode: "identify";
+    path: string;
+    fileType: string;
+    magicBytes: string;
+} | {
+    pagination: {
+        currentPage: number;
+        totalPages: number;
+        hasMore: boolean;
+        entriesPerPage: number;
+        totalEntries: number;
+    };
+    status: "success";
+    mode: "list";
+    path: string;
+    backend: string;
+    totalEntries: number;
+    entries: string[];
+} | {
+    hints: string[];
+    status: "success";
+    mode: "extract";
+    path: string;
+    archiveFile: string;
+    backend: string;
+    content: string;
+    contentLength: number;
+    isPartial: boolean;
+} | {
+    hints: string[];
+    status: "success";
+    mode: "decompress";
+    path: string;
+    format: "gzip" | "bzip2" | "xz" | "lzma" | "zstd" | "lz4" | "brotli" | "lzfse";
+    backend: string;
+    content: string;
+    contentLength: number;
+    isPartial: boolean;
+} | {
+    status: "success";
+    mode: "strings";
+    path: string;
+    strings: string[];
+    totalFound: number;
+    returned: number;
+}>;

package/dist/tools/local_binary_inspect/binaryOps.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Binary file inspection.
+ * Backs mode="identify" and mode="strings" in localBinaryInspect.
+ */
+export interface IdentifyResult {
+    success: boolean;
+    fileType?: string;
+    magicBytes?: string;
+    error?: string;
+}
+export declare function identifyFile(path: string): Promise<IdentifyResult>;
+export interface StringsResult {
+    success: boolean;
+    strings?: string[];
+    totalFound?: number;
+    error?: string;
+}
+export declare function extractStrings(path: string, minLength: number, includeOffsets: boolean): Promise<StringsResult>;

package/dist/tools/local_binary_inspect/decompressOps.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Single-stream decompression.
+ * Backs mode="decompress" in localBinaryInspect.
+ *
+ * Handles: .gz .bz2 .xz .lzma .zst .lz4 .br .lzfse
+ * Does NOT handle multi-entry archives (.tar.gz, .zip etc.) — those belong to archiveOps.
+ */
+export type DecompressFormat = 'auto' | 'gzip' | 'bzip2' | 'xz' | 'lzma' | 'zstd' | 'lz4' | 'brotli' | 'lzfse';
+export interface DecompressResult {
+    success: boolean;
+    content?: string;
+    format?: Exclude<DecompressFormat, 'auto'>;
+    backend?: string;
+    error?: string;
+}
+export declare function decompressFile(path: string, format: DecompressFormat): Promise<DecompressResult>;

package/dist/tools/local_binary_inspect/execution.d.ts

@@ -0,0 +1,4 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { type BinaryInspectQuery } from './scheme.js';
+import type { ToolExecutionArgs } from '../../types/execution.js';
+export declare function executeInspectBinary(args: ToolExecutionArgs<BinaryInspectQuery>): Promise<CallToolResult>;

package/dist/tools/local_binary_inspect/scheme.d.ts

@@ -0,0 +1,44 @@
+import { z } from 'zod';
+export declare const LocalBinaryInspectQuerySchema: z.ZodObject<{
+    entryPageNumber: z.ZodDefault<z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>>>;
+    matchStringContextLines: z.ZodDefault<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    charLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    page: z.ZodDefault<z.ZodDefault<z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>>>;
+    path: z.ZodString;
+    mode: z.ZodEnum<{
+        list: "list";
+        identify: "identify";
+        extract: "extract";
+        decompress: "decompress";
+        strings: "strings";
+    }>;
+    verbose: z.ZodOptional<z.ZodBoolean>;
+    maxEntries: z.ZodDefault<z.ZodNumber>;
+    entriesPerPage: z.ZodOptional<z.ZodNumber>;
+    archiveFile: z.ZodOptional<z.ZodString>;
+    matchString: z.ZodOptional<z.ZodString>;
+    charOffset: z.ZodOptional<z.ZodNumber>;
+    format: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        gzip: "gzip";
+        bzip2: "bzip2";
+        xz: "xz";
+        lzma: "lzma";
+        zstd: "zstd";
+        lz4: "lz4";
+        brotli: "brotli";
+        lzfse: "lzfse";
+    }>>;
+    minLength: z.ZodDefault<z.ZodNumber>;
+    includeOffsets: z.ZodOptional<z.ZodBoolean>;
+    id: z.ZodOptional<z.ZodString>;
+    mainResearchGoal: z.ZodOptional<z.ZodString>;
+    researchGoal: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type BinaryInspectQuery = z.infer<typeof LocalBinaryInspectQuerySchema>;
+export declare const LocalBinaryInspectBulkQuerySchema: z.ZodObject<{
+    responseCharOffset: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    responseCharLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$strip>;

package/dist/tools/local_fetch_content/contentExtractor.d.ts

@@ -0,0 +1,9 @@
+export declare function extractMatchingLines(lines: string[], pattern: string, contextLines: number, isRegex?: boolean, caseSensitive?: boolean, maxMatches?: number): {
+    lines: string[];
+    matchRanges: Array<{
+        start: number;
+        end: number;
+    }>;
+    matchCount: number;
+    matchingLines: number[];
+};

package/dist/tools/local_fetch_content/execution.d.ts

@@ -0,0 +1,5 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { type FetchContentQuery } from './scheme.js';
+import type { ToolExecutionArgs } from '../../types/execution.js';
+export { finalizeFetchContentResult } from './fetchContent.js';
+export declare function executeFetchContent(args: ToolExecutionArgs<FetchContentQuery>): Promise<CallToolResult>;

package/dist/tools/local_fetch_content/fetchContent.d.ts

@@ -0,0 +1,4 @@
+import type { LocalGetFileContentToolResult } from '@octocodeai/octocode-core/extra-types';
+import type { FetchContentQuery } from './scheme.js';
+export declare function fetchContent(query: FetchContentQuery): Promise<LocalGetFileContentToolResult>;
+export declare function finalizeFetchContentResult(result: LocalGetFileContentToolResult, _query: FetchContentQuery, _totalLines: number): LocalGetFileContentToolResult;

package/dist/tools/local_fetch_content/hints.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHintGenerators } from '../../types/metadata.js';
+export declare const hints: ToolHintGenerators;

package/dist/tools/local_fetch_content/scheme.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+import { type MinifyMode } from '../../scheme/fields.js';
+export declare const LocalFetchContentQuerySchema: z.ZodObject<{
+    path: z.ZodString;
+    fullContent: z.ZodOptional<z.ZodBoolean>;
+    matchString: z.ZodOptional<z.ZodString>;
+    matchStringIsRegex: z.ZodOptional<z.ZodBoolean>;
+    matchStringCaseSensitive: z.ZodOptional<z.ZodBoolean>;
+    startLine: z.ZodOptional<z.ZodNumber>;
+    endLine: z.ZodOptional<z.ZodNumber>;
+    contextLines: z.ZodDefault<z.ZodNumber>;
+    charOffset: z.ZodOptional<z.ZodNumber>;
+    charLength: z.ZodOptional<z.ZodNumber>;
+    minify: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        standard: "standard";
+        symbols: "symbols";
+    }>>;
+    id: z.ZodOptional<z.ZodString>;
+    mainResearchGoal: z.ZodOptional<z.ZodString>;
+    researchGoal: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type FetchContentQuery = z.infer<typeof LocalFetchContentQuerySchema> & {
+    minify?: MinifyMode;
+};
+export declare const LocalFetchContentBulkQuerySchema: z.ZodObject<{
+    responseCharOffset: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    responseCharLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$strip>;

package/dist/tools/local_find_files/execution.d.ts

@@ -0,0 +1,5 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { type FindFilesQuery } from './scheme.js';
+import type { ToolExecutionArgs } from '../../types/execution.js';
+export { finalizeFindFilesResult } from './findFiles.js';
+export declare function executeFindFiles(args: ToolExecutionArgs<FindFilesQuery>): Promise<CallToolResult>;

package/dist/tools/local_find_files/findFiles.d.ts

@@ -0,0 +1,11 @@
+import type { z } from 'zod';
+import type { FindFilesQuerySchema } from '@octocodeai/octocode-core/schemas';
+import type { LocalFindFilesToolResult } from '@octocodeai/octocode-core/extra-types';
+type UpstreamFindFilesQuery = z.infer<typeof FindFilesQuerySchema>;
+import type { WithOptionalMeta } from '../../types/execution.js';
+type FindFilesQuery = WithOptionalMeta<UpstreamFindFilesQuery>;
+export declare function findFiles(query: FindFilesQuery): Promise<LocalFindFilesToolResult>;
+export declare function finalizeFindFilesResult(result: LocalFindFilesToolResult, _query: FindFilesQuery, _totals: {
+    totalFiles: number;
+}): LocalFindFilesToolResult;
+export {};

package/dist/tools/local_find_files/hints.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHintGenerators } from '../../types/metadata.js';
+export declare const hints: ToolHintGenerators;

package/dist/tools/local_find_files/scheme.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+import { FindFilesQuerySchema as CoreFindFilesQuerySchema } from '@octocodeai/octocode-core/schemas';
+export type FindFilesQuery = Omit<z.infer<typeof CoreFindFilesQuerySchema>, 'regexType'>;
+export declare const LocalFindFilesQuerySchema: z.ZodType<FindFilesQuery>;
+export declare const LocalFindFilesBulkQuerySchema: z.ZodObject<{
+    responseCharOffset: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    responseCharLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$strip>;

package/dist/tools/local_ripgrep/execution.d.ts

@@ -0,0 +1,5 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { type RipgrepQuery } from './scheme.js';
+import type { ToolExecutionArgs } from '../../types/execution.js';
+export { finalizeRipgrepResult } from './ripgrepResultBuilder.js';
+export declare function executeRipgrepSearch(args: ToolExecutionArgs<RipgrepQuery>): Promise<CallToolResult>;

package/dist/tools/local_ripgrep/grepFallbackExecutor.d.ts

@@ -0,0 +1,3 @@
+import type { LocalSearchCodeToolResult } from '@octocodeai/octocode-core/extra-types';
+import { type RipgrepQuery } from './scheme.js';
+export declare function executeGrepFallbackSearch(configuredQuery: RipgrepQuery, unavailableReason?: string): Promise<LocalSearchCodeToolResult>;

package/dist/tools/local_ripgrep/hints.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHintGenerators } from '../../types/metadata.js';
+export declare const hints: ToolHintGenerators;

package/dist/tools/local_ripgrep/patternValidation.d.ts

@@ -0,0 +1,12 @@
+interface RipgrepPatternInput {
+    pattern: string;
+    fixedString?: boolean;
+    perlRegex?: boolean;
+}
+export interface RipgrepPatternValidation {
+    isValid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export declare function preflightValidateRipgrepPattern(input: RipgrepPatternInput): RipgrepPatternValidation;
+export {};

package/dist/tools/local_ripgrep/ripgrepExecutor.d.ts

@@ -0,0 +1,3 @@
+import { type RipgrepQuery } from './scheme.js';
+import type { LocalSearchCodeToolResult } from '@octocodeai/octocode-core/extra-types';
+export declare function executeRipgrepSearchInternal(configuredQuery: RipgrepQuery): Promise<LocalSearchCodeToolResult>;

package/dist/tools/local_ripgrep/ripgrepParser.d.ts

@@ -0,0 +1,9 @@
+import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
+import type { RipgrepQuery } from './scheme.js';
+import type { SearchStats } from '../../utils/core/types.js';
+export declare function parseFilesOnlyOutput(stdout: string): LocalSearchCodeFile[];
+export declare function parseCountOutput(stdout: string): LocalSearchCodeFile[];
+export declare function parseRipgrepOutput(stdout: string, configuredQuery: RipgrepQuery): {
+    files: LocalSearchCodeFile[];
+    stats: SearchStats;
+};

package/dist/tools/local_ripgrep/ripgrepResultBuilder.d.ts

@@ -0,0 +1,9 @@
+import type { LocalSearchCodeFile } from '@octocodeai/octocode-core/types';
+import type { LocalSearchCodeToolResult } from '@octocodeai/octocode-core/extra-types';
+import type { SearchStats } from '../../utils/core/types.js';
+import type { RipgrepQuery } from './scheme.js';
+export declare function buildSearchResult(parsedFiles: LocalSearchCodeFile[], configuredQuery: RipgrepQuery, _searchEngine: 'rg' | 'grep', warnings: string[], stats?: SearchStats): Promise<LocalSearchCodeToolResult>;
+export declare function finalizeRipgrepResult(result: LocalSearchCodeToolResult, _query: RipgrepQuery, _totals: {
+    totalMatches: number;
+    totalFiles: number;
+}): LocalSearchCodeToolResult;

package/dist/tools/local_ripgrep/scheme.d.ts

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+export declare const LocalRipgrepQuerySchema: z.ZodObject<{
+    keywords: z.ZodOptional<z.ZodString>;
+    path: z.ZodString;
+    mode: z.ZodDefault<z.ZodEnum<{
+        paginated: "paginated";
+        discovery: "discovery";
+        detailed: "detailed";
+        structural: "structural";
+    }>>;
+    pattern: z.ZodOptional<z.ZodString>;
+    rule: z.ZodOptional<z.ZodString>;
+    fixedString: z.ZodOptional<z.ZodBoolean>;
+    perlRegex: z.ZodOptional<z.ZodBoolean>;
+    caseInsensitive: z.ZodOptional<z.ZodBoolean>;
+    caseSensitive: z.ZodOptional<z.ZodBoolean>;
+    wholeWord: z.ZodOptional<z.ZodBoolean>;
+    invertMatch: z.ZodOptional<z.ZodBoolean>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    excludeDir: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    noIgnore: z.ZodOptional<z.ZodBoolean>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    filesOnly: z.ZodOptional<z.ZodBoolean>;
+    filesWithoutMatch: z.ZodOptional<z.ZodBoolean>;
+    contextLines: z.ZodOptional<z.ZodNumber>;
+    matchContentLength: z.ZodDefault<z.ZodNumber>;
+    maxMatchesPerFile: z.ZodOptional<z.ZodNumber>;
+    maxFiles: z.ZodOptional<z.ZodNumber>;
+    multiline: z.ZodOptional<z.ZodBoolean>;
+    multilineDotall: z.ZodOptional<z.ZodBoolean>;
+    sort: z.ZodDefault<z.ZodEnum<{
+        path: "path";
+        modified: "modified";
+        created: "created";
+        accessed: "accessed";
+    }>>;
+    sortReverse: z.ZodOptional<z.ZodBoolean>;
+    langType: z.ZodOptional<z.ZodString>;
+    countLinesPerFile: z.ZodOptional<z.ZodBoolean>;
+    countMatchesPerFile: z.ZodOptional<z.ZodBoolean>;
+    matchPage: z.ZodOptional<z.ZodNumber>;
+    itemsPerPage: z.ZodOptional<z.ZodNumber>;
+    page: z.ZodDefault<z.ZodNumber>;
+    id: z.ZodOptional<z.ZodString>;
+    mainResearchGoal: z.ZodOptional<z.ZodString>;
+    researchGoal: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RipgrepQuery = z.infer<typeof LocalRipgrepQuerySchema>;
+export declare const LocalRipgrepBulkQuerySchema: z.ZodObject<{
+    responseCharOffset: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    responseCharLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$strip>;

package/dist/tools/local_ripgrep/searchContentRipgrep.d.ts

@@ -0,0 +1,5 @@
+import type { RipgrepQuery as LocalRipgrepQuery } from './scheme.js';
+type RipgrepQuery = LocalRipgrepQuery;
+import type { LocalSearchCodeToolResult } from '@octocodeai/octocode-core/extra-types';
+export declare function searchContentRipgrep(query: RipgrepQuery): Promise<LocalSearchCodeToolResult>;
+export {};

package/dist/tools/local_ripgrep/structuralSearch.d.ts

@@ -0,0 +1,9 @@
+import type { LocalSearchCodeToolResult } from '@octocodeai/octocode-core/extra-types';
+import type { RipgrepQuery } from './scheme.js';
+/**
+ * mode:"structural" execution path. Resolves candidate files, pre-filters them
+ * with a literal anchor when the pattern provides one, runs the AST engine per
+ * file, and reuses the ripgrep result builder so the output shape (pagination,
+ * sizing) is identical to the other localSearchCode modes.
+ */
+export declare function searchContentStructural(query: RipgrepQuery): Promise<LocalSearchCodeToolResult>;

package/dist/tools/local_view_structure/execution.d.ts

@@ -0,0 +1,5 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { type ViewStructureQuery } from './scheme.js';
+import type { ToolExecutionArgs } from '../../types/execution.js';
+export { finalizeViewStructureResult } from './local_view_structure.js';
+export declare function executeViewStructure(args: ToolExecutionArgs<ViewStructureQuery>): Promise<CallToolResult>;

package/dist/tools/local_view_structure/hints.d.ts

@@ -0,0 +1,2 @@
+import type { ToolHintGenerators } from '../../types/metadata.js';
+export declare const hints: ToolHintGenerators;

package/dist/tools/local_view_structure/local_view_structure.d.ts

@@ -0,0 +1,7 @@
+import type { LocalViewStructureToolResult } from '@octocodeai/octocode-core/extra-types';
+import type { WithOptionalMeta } from '../../types/execution.js';
+import type { ViewStructureQuery as LocalViewStructureQuery } from './scheme.js';
+type ViewStructureQuery = WithOptionalMeta<LocalViewStructureQuery>;
+export declare function viewStructure(query: ViewStructureQuery): Promise<LocalViewStructureToolResult>;
+export declare function finalizeViewStructureResult(result: LocalViewStructureToolResult, _query: ViewStructureQuery): LocalViewStructureToolResult;
+export {};

package/dist/tools/local_view_structure/scheme.d.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+export declare const LocalViewStructureQuerySchema: z.ZodObject<{
+    path: z.ZodString;
+    details: z.ZodOptional<z.ZodBoolean>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    sortBy: z.ZodDefault<z.ZodEnum<{
+        extension: "extension";
+        size: "size";
+        name: "name";
+        time: "time";
+    }>>;
+    reverse: z.ZodOptional<z.ZodBoolean>;
+    pattern: z.ZodOptional<z.ZodString>;
+    directoriesOnly: z.ZodOptional<z.ZodBoolean>;
+    filesOnly: z.ZodOptional<z.ZodBoolean>;
+    recursive: z.ZodOptional<z.ZodBoolean>;
+    extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    showFileLastModified: z.ZodOptional<z.ZodBoolean>;
+    page: z.ZodDefault<z.ZodNumber>;
+    itemsPerPage: z.ZodOptional<z.ZodNumber>;
+    id: z.ZodOptional<z.ZodString>;
+    mainResearchGoal: z.ZodOptional<z.ZodString>;
+    researchGoal: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ViewStructureQuery = z.infer<typeof LocalViewStructureQuerySchema>;
+export declare const LocalViewStructureBulkQuerySchema: z.ZodObject<{
+    responseCharOffset: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    responseCharLength: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodNumber>>;
+    queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$strip>;

package/dist/tools/local_view_structure/structureFilters.d.ts

@@ -0,0 +1,33 @@
+export interface DirectoryEntry {
+    name: string;
+    path?: string;
+    type: 'file' | 'directory' | 'symlink';
+    size?: string;
+    sizeBytes?: number;
+    modified?: string;
+    permissions?: string;
+    extension?: string;
+    depth?: number;
+}
+type EntryFilterQuery = Pick<{
+    pattern?: string;
+    extensions?: string[];
+    directoriesOnly?: boolean;
+    filesOnly?: boolean;
+}, 'pattern' | 'extensions' | 'directoriesOnly' | 'filesOnly'>;
+export declare function applyEntryFilters(entries: DirectoryEntry[], query: EntryFilterQuery): DirectoryEntry[];
+export declare function formatEntryString(entry: DirectoryEntry, indent?: number): string;
+interface EntryOutput {
+    type: 'file' | 'dir' | 'link';
+    depth?: number;
+    size?: string;
+    modified?: string;
+    permissions?: string;
+}
+export declare function toGroupedLists(entries: DirectoryEntry[]): {
+    files?: string[];
+    folders?: string[];
+    links?: string[];
+};
+export declare function toEntryObject(entry: DirectoryEntry): EntryOutput;
+export {};

package/dist/tools/local_view_structure/structureParser.d.ts

@@ -0,0 +1,3 @@
+import type { DirectoryEntry } from './structureFilters.js';
+export declare function parseLsSimple(output: string, basePath: string, showModified?: boolean): Promise<DirectoryEntry[]>;
+export declare function parseLsLongFormat(output: string, showModified?: boolean): DirectoryEntry[];

package/dist/tools/local_view_structure/structureResponse.d.ts

@@ -0,0 +1,32 @@
+import type { DirectoryEntry } from './structureFilters.js';
+export interface WalkStats {
+    skipped: number;
+    permissionDenied: number;
+    wasCapped?: boolean;
+    rootError?: {
+        code: string;
+        message: string;
+    };
+}
+export declare function summarizeEntries(entries: DirectoryEntry[]): string;
+export declare function paginateEntries(entries: DirectoryEntry[], query: {
+    itemsPerPage?: number;
+    page?: number;
+}): {
+    paginatedEntries: DirectoryEntry[];
+    endIdx: number;
+    pagination: {
+        currentPage: number;
+        totalPages: number;
+        entriesPerPage: number;
+        totalEntries: number;
+        hasMore: boolean;
+    };
+};
+export declare function buildEntryPaginationHints(entries: DirectoryEntry[], paginatedCount: number, pagination: {
+    currentPage: number;
+    totalPages: number;
+    totalEntries: number;
+    hasMore: boolean;
+}, endIdx: number): string[];
+export declare function buildWalkWarnings(walkStats: WalkStats): string[];

package/dist/tools/local_view_structure/structureWalker.d.ts

@@ -0,0 +1,24 @@
+import type { DirectoryEntry } from './structureFilters.js';
+export interface WalkStats {
+    skipped: number;
+    permissionDenied: number;
+    wasCapped?: boolean;
+    rootError?: {
+        code: string;
+        message: string;
+    };
+}
+interface WalkDirectoryOptions {
+    basePath: string;
+    currentPath: string;
+    depth: number;
+    maxDepth: number;
+    entries: DirectoryEntry[];
+    maxEntries?: number;
+    showHidden?: boolean;
+    showModified?: boolean;
+    stats: WalkStats;
+    showDetails?: boolean;
+}
+export declare function walkDirectory(options: WalkDirectoryOptions): Promise<void>;
+export {};

package/dist/tools/lsp/semantic_content/execution.d.ts

@@ -0,0 +1,4 @@
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { ToolExecutionArgs } from '../../../types/execution.js';
+import { type LspGetSemanticsQuery } from '../shared/semanticTypes.js';
+export declare function executeLspGetSemantics(args: ToolExecutionArgs<LspGetSemanticsQuery>): Promise<CallToolResult>;

package/dist/tools/lsp/semantic_content/hints.d.ts

@@ -0,0 +1,4 @@
+import type { ToolHintGenerators } from '../../../types/metadata.js';
+import type { SemanticContentType } from '../shared/semanticTypes.js';
+export declare const hints: ToolHintGenerators;
+export declare function semanticHints(type: SemanticContentType, complete: boolean): string[];

package/dist/tools/lsp/semantic_content/index.d.ts

@@ -0,0 +1,2 @@
+export { executeLspGetSemantics } from './execution.js';
+export { BulkLspGetSemanticsQuerySchema, LspGetSemanticsOutputSchema, LspGetSemanticsQuerySchema, } from './scheme.js';