@octocodeai/octocode-tools-core 16.5.1 → 16.6.0

package/dist/tools/directToolCatalog.d.ts

@@ -1,56 +1,15 @@
-import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
-export type DirectToolInput = Record<string, unknown> & {
-    queries: unknown[];
-};
-export interface DirectToolDefinition {
-    name: string;
-    schema: z.ZodType;
-    inputSchema: z.ZodType;
-}
-export type DirectToolCategory = 'GitHub' | 'Local' | 'LSP' | 'Package' | 'Other';
-export declare const DIRECT_TOOL_CATEGORIES: readonly DirectToolCategory[];
-export interface DirectToolDisplayField {
-    name: string;
-    required: boolean;
-    type: string;
-    /** Numeric bounds and default, e.g. "1-100, default 30" — surfaced inline so
-     * agents see the full constraint without fetching the raw JSON schema. */
-    constraints?: string;
-    description?: string;
-}
-export interface DirectToolOutputField {
-    name: string;
-    type: string;
-    optional?: boolean;
-}
-export interface DirectToolMetadata {
-    tools?: Record<string, {
-        description?: string;
-        schema?: Record<string, string>;
-    }>;
-}
-export interface PrepareDirectToolInputOptions {
-    sourceLabel?: string;
-    onUnknownFields?: (unknownFields: string[], queryIndex: number) => void;
-}
-export declare class DirectToolInputError extends Error {
-    readonly details: string[];
-    constructor(message: string, details?: string[]);
-}
-export declare const DIRECT_TOOL_DEFINITIONS: DirectToolDefinition[];
-export declare function findDirectToolDefinition(name: string): DirectToolDefinition | undefined;
-export declare function getDirectToolCategory(toolName: string): DirectToolCategory;
-export declare function sortDirectToolNames(toolNames: string[]): string[];
-export declare function formatDirectToolSchemaText(toolName: string): string;
-export declare function formatDirectToolMetadataSchemaText(schema: Record<string, string> | undefined): string;
-export declare function getDirectToolAutoFilledFields(toolName: string): string[];
-export declare function getDirectToolOutputFields(): DirectToolOutputField[];
-export declare function formatDirectToolOutputSchemaText(): string;
-export declare function getDirectToolDescription(toolName: string, metadata?: DirectToolMetadata | null): string;
-export declare function getDirectToolDisplayFields(toolName: string): DirectToolDisplayField[];
-export declare function buildDirectToolExampleQuery(toolName: string): Record<string, unknown>;
-export declare function prepareDirectToolInputFromJsonText(toolName: string, inputText: string | undefined, options?: PrepareDirectToolInputOptions): DirectToolInput | null;
-export declare function prepareDirectToolInput(toolName: string, rawPayload: unknown, options?: PrepareDirectToolInputOptions): DirectToolInput;
-export declare function formatDirectToolValidationIssues(error: z.ZodError): string[];
-export declare function executeDirectTool(name: string, input: unknown): Promise<CallToolResult>;
+/**
+ * Direct-tool catalog barrel (P3). The catalog is split so the schema/help path
+ * never loads the native engine:
+ *   - `directToolCatalog.meta.ts` — engine-free definitions, schema text,
+ *     display fields, input preparation (also exposed via the `/schema` subpath).
+ *   - `directToolCatalog.exec.ts` — `executeDirectTool` + the engine/runtime.
+ *
+ * This barrel preserves the historical `@octocodeai/octocode-tools-core/direct`
+ * surface (meta + executeDirectTool). Importing it still eagerly loads the engine
+ * (via the exec module) — execution consumers want that. Pure schema/help/
+ * `--scheme`/`context` callers must import from `/schema` (meta only) instead, so
+ * they run on engine-less runtimes.
+ */
+export * from './directToolCatalog.meta.js';
+export { executeDirectTool } from './directToolCatalog.exec.js';

package/dist/tools/directToolCatalog.exec.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Direct-tool EXECUTION path (P3). This module imports the engine (native LSP
+ * client pool) and every tool's execution function via `ALL_TOOLS`, so it is the
+ * one that loads the native `.node` addon at eval. It is reached only when a tool
+ * actually runs — schema/help/`--scheme`/`context` use `directToolCatalog.meta.ts`
+ * (and the `@octocodeai/octocode-tools-core/schema` subpath), which is engine-free.
+ */
+import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import { DirectToolInputError } from './directToolCatalog.meta.js';
+export declare function executeDirectTool(name: string, input: unknown): Promise<CallToolResult>;
+export { DirectToolInputError };

package/dist/tools/directToolCatalog.meta.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Engine-free direct-tool catalog metadata (P3).
+ *
+ * This module holds EVERYTHING the schema/help/`--scheme`/`context` paths need
+ * — tool definitions (name + display/bulk zod schemas), schema-text formatters,
+ * display-field extraction, example builders, and input preparation — WITHOUT
+ * importing `@octocodeai/octocode-engine` (no native `.node` load at module
+ * eval). The schemas are sourced from each tool's engine-free `scheme.ts`, the
+ * same modules `toolConfig.ts` consumes, so the two cannot drift on shape (a
+ * drift test asserts name/schema parity against the runtime `ALL_TOOLS`).
+ *
+ * The execution path (`executeDirectTool`) lives in `directToolCatalog.exec.ts`,
+ * which DOES import the engine; it is only reached when a tool actually runs.
+ * The `@octocodeai/octocode-tools-core/schema` subpath re-exports only this
+ * module so engine-less runtimes (e.g. Codex.app Node) can read schemas.
+ */
+import { z } from 'zod';
+export type DirectToolInput = Record<string, unknown> & {
+    queries: unknown[];
+};
+export interface DirectToolDefinition {
+    name: string;
+    schema: z.ZodType;
+    inputSchema: z.ZodType;
+}
+export type DirectToolCategory = 'GitHub' | 'Local Code' | 'Package' | 'Other';
+export declare const DIRECT_TOOL_CATEGORIES: readonly DirectToolCategory[];
+export interface DirectToolDisplayField {
+    name: string;
+    required: boolean;
+    type: string;
+    /** Numeric bounds and default, e.g. "1-100, default 30" — surfaced inline so
+     * agents see the full constraint without fetching the raw JSON schema. */
+    constraints?: string;
+    description?: string;
+}
+export interface DirectToolCommandPattern {
+    label: string;
+    query: Record<string, unknown>;
+    command: string;
+}
+export interface DirectToolOutputField {
+    name: string;
+    type: string;
+    optional?: boolean;
+}
+export interface DirectToolMetadata {
+    tools?: Record<string, {
+        description?: string;
+        schema?: Record<string, string>;
+    }>;
+}
+export interface PrepareDirectToolInputOptions {
+    sourceLabel?: string;
+    onUnknownFields?: (unknownFields: string[], queryIndex: number) => void;
+}
+export declare class DirectToolInputError extends Error {
+    readonly details: string[];
+    constructor(message: string, details?: string[]);
+}
+/**
+ * Engine-free tool definitions (name + display/bulk schema). Order mirrors
+ * `ALL_TOOLS` in `toolConfig.ts`; each schema is the SAME object that
+ * `toolConfig` attaches an executionFn to. Kept in lockstep by a drift test.
+ */
+export declare const DIRECT_TOOL_DEFINITIONS: DirectToolDefinition[];
+export declare function findDirectToolDefinition(name: string): DirectToolDefinition | undefined;
+export declare function getDirectToolCategory(toolName: string): DirectToolCategory;
+export declare function sortDirectToolNames(toolNames: string[]): string[];
+export declare function formatDirectToolSchemaText(toolName: string): string;
+export declare function formatDirectToolMetadataSchemaText(schema: Record<string, string> | undefined): string;
+export declare function getDirectToolAutoFilledFields(toolName: string): string[];
+export declare function getDirectToolOutputFields(): DirectToolOutputField[];
+export declare function formatDirectToolOutputSchemaText(): string;
+export declare function getDirectToolDescription(toolName: string, metadata?: DirectToolMetadata | null): string;
+export declare function getDirectToolDisplayFields(toolName: string): DirectToolDisplayField[];
+export declare function formatDirectToolCommandPattern(toolName: string, query: Record<string, unknown>): string;
+export declare function buildDirectToolCommandPatterns(toolName: string): DirectToolCommandPattern[];
+export declare function buildDirectToolExampleQuery(toolName: string): Record<string, unknown>;
+export declare function prepareDirectToolInputFromJsonText(toolName: string, inputText: string | undefined, options?: PrepareDirectToolInputOptions): DirectToolInput | null;
+export declare function prepareDirectToolInput(toolName: string, rawPayload: unknown, options?: PrepareDirectToolInputOptions): DirectToolInput;
+export declare function formatDirectToolValidationIssues(error: z.ZodError): string[];

package/dist/tools/github_clone_repo/cache.d.ts

@@ -16,7 +16,7 @@ export declare function isCacheHit(cloneDir: string): {
 export declare function getCacheTTL(): number;
 export declare function getMaxCacheSizeBytes(): number;
 export declare function getMaxCloneCount(): number;
-export declare function createCacheMeta(owner: string, repo: string, branch: string, source: CacheSource, sparsePath?: string, sizeBytes?: number): CloneCacheMeta;
+export declare function createCacheMeta(owner: string, repo: string, branch: string, source: CacheSource, sparsePath?: string, sizeBytes?: number, commitSha?: string): CloneCacheMeta;
 export declare function ensureCloneParentDir(cloneDir: string): void;
 export declare function removeCloneDir(cloneDir: string): void;
 export declare function evictExpiredClones(octocodeDir: string): number;

package/dist/tools/github_clone_repo/types.d.ts

@@ -5,6 +5,8 @@ export interface CloneCacheMeta {
     owner: string;
     repo: string;
     branch: string;
+    /** HEAD commit SHA at the time this entry was written. Absent on legacy entries. */
+    commitSha?: string;
     sparsePath?: string;
     source: CacheSource;
     sizeBytes?: number;

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

@@ -104,6 +104,26 @@ export declare const GitHubFetchContentOutputLocalSchema: z.ZodObject<{
             repoRoot: z.ZodOptional<z.ZodString>;
             fileCount: z.ZodNumber;
             totalSize: z.ZodNumber;
+            complete: z.ZodOptional<z.ZodBoolean>;
+            directoryEntryCount: z.ZodOptional<z.ZodNumber>;
+            eligibleFileCount: z.ZodOptional<z.ZodNumber>;
+            savedFileCount: z.ZodOptional<z.ZodNumber>;
+            skipped: z.ZodOptional<z.ZodObject<{
+                nonFile: z.ZodNumber;
+                missingDownloadUrl: z.ZodNumber;
+                oversized: z.ZodNumber;
+                binary: z.ZodNumber;
+                fileLimit: z.ZodNumber;
+                fetchFailed: z.ZodNumber;
+                totalSizeLimit: z.ZodNumber;
+                pathTraversal: z.ZodNumber;
+            }, z.core.$strip>>;
+            limits: z.ZodOptional<z.ZodObject<{
+                maxDirectoryFiles: z.ZodNumber;
+                maxTotalSize: z.ZodNumber;
+                maxFileSize: z.ZodNumber;
+            }, z.core.$strip>>;
+            warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
             files: z.ZodOptional<z.ZodArray<z.ZodObject<{
                 path: z.ZodString;
                 size: z.ZodNumber;
@@ -112,6 +132,90 @@ export declare const GitHubFetchContentOutputLocalSchema: z.ZodObject<{
             cached: z.ZodOptional<z.ZodBoolean>;
             resolvedBranch: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
+        data: z.ZodOptional<z.ZodObject<{
+            owner: z.ZodString;
+            repo: z.ZodString;
+            files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                content: z.ZodString;
+                localPath: z.ZodOptional<z.ZodString>;
+                repoRoot: z.ZodOptional<z.ZodString>;
+                contentView: z.ZodOptional<z.ZodEnum<{
+                    none: "none";
+                    standard: "standard";
+                    symbols: "symbols";
+                }>>;
+                isSkeleton: z.ZodOptional<z.ZodBoolean>;
+                totalLines: z.ZodOptional<z.ZodNumber>;
+                sourceChars: z.ZodOptional<z.ZodNumber>;
+                sourceBytes: z.ZodOptional<z.ZodNumber>;
+                resolvedBranch: z.ZodOptional<z.ZodString>;
+                pagination: z.ZodOptional<z.ZodObject<{
+                    currentPage: z.ZodNumber;
+                    totalPages: z.ZodNumber;
+                    hasMore: z.ZodBoolean;
+                    nextPage: z.ZodOptional<z.ZodNumber>;
+                    nextMatchPage: z.ZodOptional<z.ZodNumber>;
+                    charOffset: z.ZodOptional<z.ZodNumber>;
+                    charLength: z.ZodOptional<z.ZodNumber>;
+                    totalChars: z.ZodOptional<z.ZodNumber>;
+                    nextCharOffset: z.ZodOptional<z.ZodNumber>;
+                    filesPerPage: z.ZodOptional<z.ZodNumber>;
+                    totalFiles: z.ZodOptional<z.ZodNumber>;
+                    entriesPerPage: z.ZodOptional<z.ZodNumber>;
+                    totalEntries: z.ZodOptional<z.ZodNumber>;
+                    matchesPerPage: z.ZodOptional<z.ZodNumber>;
+                    totalMatches: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                isPartial: z.ZodOptional<z.ZodBoolean>;
+                startLine: z.ZodOptional<z.ZodNumber>;
+                endLine: z.ZodOptional<z.ZodNumber>;
+                matchRanges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    start: z.ZodNumber;
+                    end: z.ZodNumber;
+                }, z.core.$strip>>>;
+                lastModified: z.ZodOptional<z.ZodString>;
+                lastModifiedBy: z.ZodOptional<z.ZodString>;
+                warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                matchNotFound: z.ZodOptional<z.ZodBoolean>;
+                searchedFor: z.ZodOptional<z.ZodString>;
+                cached: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            directories: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                path: z.ZodString;
+                localPath: z.ZodString;
+                repoRoot: z.ZodOptional<z.ZodString>;
+                fileCount: z.ZodNumber;
+                totalSize: z.ZodNumber;
+                complete: z.ZodOptional<z.ZodBoolean>;
+                directoryEntryCount: z.ZodOptional<z.ZodNumber>;
+                eligibleFileCount: z.ZodOptional<z.ZodNumber>;
+                savedFileCount: z.ZodOptional<z.ZodNumber>;
+                skipped: z.ZodOptional<z.ZodObject<{
+                    nonFile: z.ZodNumber;
+                    missingDownloadUrl: z.ZodNumber;
+                    oversized: z.ZodNumber;
+                    binary: z.ZodNumber;
+                    fileLimit: z.ZodNumber;
+                    fetchFailed: z.ZodNumber;
+                    totalSizeLimit: z.ZodNumber;
+                    pathTraversal: z.ZodNumber;
+                }, z.core.$strip>>;
+                limits: z.ZodOptional<z.ZodObject<{
+                    maxDirectoryFiles: z.ZodNumber;
+                    maxTotalSize: z.ZodNumber;
+                    maxFileSize: z.ZodNumber;
+                }, z.core.$strip>>;
+                warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    path: z.ZodString;
+                    size: z.ZodNumber;
+                    type: z.ZodString;
+                }, z.core.$strip>>>;
+                cached: z.ZodOptional<z.ZodBoolean>;
+                resolvedBranch: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;

package/dist/tools/github_fetch_content/types.d.ts

@@ -57,6 +57,33 @@ export interface DirectoryFetchResult {
     }>;
     fileCount: number;
     totalSize: number;
+    /** true = no files were skipped by size/type/limit/error */
+    complete: boolean;
+    /** true = completeness was proven against the remote tree (fresh fetch + complete) */
+    verified: boolean;
+    /** HEAD commit SHA at the time of fetch; absent on cache hits from legacy entries */
+    commitSha?: string;
+    /** true when nonFile > 0 — subdirectory entries were present but not fetched; use ghCloneRepo for full coverage */
+    hasSubdirectories?: boolean;
+    directoryEntryCount: number;
+    eligibleFileCount: number;
+    savedFileCount: number;
+    skipped: {
+        nonFile: number;
+        missingDownloadUrl: number;
+        oversized: number;
+        binary: number;
+        fileLimit: number;
+        fetchFailed: number;
+        totalSizeLimit: number;
+        pathTraversal: number;
+    };
+    limits: {
+        maxDirectoryFiles: number;
+        maxTotalSize: number;
+        maxFileSize: number;
+    };
+    warnings?: string[];
     cached: boolean;
     expiresAt: string;
     owner: string;

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

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 export declare const LspGetSemanticsQueryDisplaySchema: z.ZodObject<{
-    uri: z.ZodString;
+    uri: z.ZodOptional<z.ZodString>;
     type: z.ZodDefault<z.ZodEnum<{
         definition: "definition";
         references: "references";
@@ -11,6 +11,10 @@ export declare const LspGetSemanticsQueryDisplaySchema: z.ZodObject<{
         documentSymbols: "documentSymbols";
         typeDefinition: "typeDefinition";
         implementation: "implementation";
+        workspaceSymbol: "workspaceSymbol";
+        supertypes: "supertypes";
+        subtypes: "subtypes";
+        diagnostic: "diagnostic";
     }>>;
     symbolName: z.ZodOptional<z.ZodString>;
     lineHint: z.ZodOptional<z.ZodNumber>;
@@ -32,7 +36,7 @@ export declare const LspGetSemanticsQueryDisplaySchema: z.ZodObject<{
     reasoning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const LspGetSemanticsQuerySchema: z.ZodObject<{
-    uri: z.ZodString;
+    uri: z.ZodOptional<z.ZodString>;
     type: z.ZodDefault<z.ZodEnum<{
         definition: "definition";
         references: "references";
@@ -43,6 +47,10 @@ export declare const LspGetSemanticsQuerySchema: z.ZodObject<{
         documentSymbols: "documentSymbols";
         typeDefinition: "typeDefinition";
         implementation: "implementation";
+        workspaceSymbol: "workspaceSymbol";
+        supertypes: "supertypes";
+        subtypes: "subtypes";
+        diagnostic: "diagnostic";
     }>>;
     symbolName: z.ZodOptional<z.ZodString>;
     lineHint: z.ZodOptional<z.ZodNumber>;
@@ -156,6 +164,9 @@ export declare const LspGetSemanticsOutputSchema: z.ZodObject<{
                         noReferences: "noReferences";
                         noHover: "noHover";
                         noCalls: "noCalls";
+                        noWorkspaceSymbols: "noWorkspaceSymbols";
+                        noTypeHierarchy: "noTypeHierarchy";
+                        noDiagnostics: "noDiagnostics";
                     }>;
                     reason: z.ZodString;
                 }, z.core.$strip>>;
@@ -215,6 +226,9 @@ export declare const LspGetSemanticsOutputSchema: z.ZodObject<{
                         noReferences: "noReferences";
                         noHover: "noHover";
                         noCalls: "noCalls";
+                        noWorkspaceSymbols: "noWorkspaceSymbols";
+                        noTypeHierarchy: "noTypeHierarchy";
+                        noDiagnostics: "noDiagnostics";
                     }>;
                     reason: z.ZodString;
                 }, z.core.$strip>>;
@@ -255,6 +269,77 @@ export declare const LspGetSemanticsOutputSchema: z.ZodObject<{
                         noReferences: "noReferences";
                         noHover: "noHover";
                         noCalls: "noCalls";
+                        noWorkspaceSymbols: "noWorkspaceSymbols";
+                        noTypeHierarchy: "noTypeHierarchy";
+                        noDiagnostics: "noDiagnostics";
+                    }>;
+                    reason: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"workspaceSymbol">;
+                query: z.ZodString;
+                symbols: z.ZodArray<z.ZodUnknown>;
+                totalSymbols: z.ZodNumber;
+                empty: z.ZodOptional<z.ZodObject<{
+                    category: z.ZodEnum<{
+                        serverUnavailable: "serverUnavailable";
+                        unsupportedOperation: "unsupportedOperation";
+                        symbolNotFound: "symbolNotFound";
+                        anchorFailed: "anchorFailed";
+                        noLocations: "noLocations";
+                        noReferences: "noReferences";
+                        noHover: "noHover";
+                        noCalls: "noCalls";
+                        noWorkspaceSymbols: "noWorkspaceSymbols";
+                        noTypeHierarchy: "noTypeHierarchy";
+                        noDiagnostics: "noDiagnostics";
+                    }>;
+                    reason: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"typeHierarchy">;
+                direction: z.ZodEnum<{
+                    supertypes: "supertypes";
+                    subtypes: "subtypes";
+                }>;
+                root: z.ZodOptional<z.ZodUnknown>;
+                items: z.ZodArray<z.ZodUnknown>;
+                totalItems: z.ZodNumber;
+                empty: z.ZodOptional<z.ZodObject<{
+                    category: z.ZodEnum<{
+                        serverUnavailable: "serverUnavailable";
+                        unsupportedOperation: "unsupportedOperation";
+                        symbolNotFound: "symbolNotFound";
+                        anchorFailed: "anchorFailed";
+                        noLocations: "noLocations";
+                        noReferences: "noReferences";
+                        noHover: "noHover";
+                        noCalls: "noCalls";
+                        noWorkspaceSymbols: "noWorkspaceSymbols";
+                        noTypeHierarchy: "noTypeHierarchy";
+                        noDiagnostics: "noDiagnostics";
+                    }>;
+                    reason: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"diagnostic">;
+                diagnostics: z.ZodArray<z.ZodUnknown>;
+                totalDiagnostics: z.ZodNumber;
+                errorCount: z.ZodNumber;
+                warningCount: z.ZodNumber;
+                empty: z.ZodOptional<z.ZodObject<{
+                    category: z.ZodEnum<{
+                        serverUnavailable: "serverUnavailable";
+                        unsupportedOperation: "unsupportedOperation";
+                        symbolNotFound: "symbolNotFound";
+                        anchorFailed: "anchorFailed";
+                        noLocations: "noLocations";
+                        noReferences: "noReferences";
+                        noHover: "noHover";
+                        noCalls: "noCalls";
+                        noWorkspaceSymbols: "noWorkspaceSymbols";
+                        noTypeHierarchy: "noTypeHierarchy";
+                        noDiagnostics: "noDiagnostics";
                     }>;
                     reason: z.ZodString;
                 }, z.core.$strip>>;
@@ -269,6 +354,9 @@ export declare const LspGetSemanticsOutputSchema: z.ZodObject<{
                     noReferences: "noReferences";
                     noHover: "noHover";
                     noCalls: "noCalls";
+                    noWorkspaceSymbols: "noWorkspaceSymbols";
+                    noTypeHierarchy: "noTypeHierarchy";
+                    noDiagnostics: "noDiagnostics";
                 }>;
                 reason: z.ZodString;
             }, z.core.$strip>], "kind">;
@@ -374,6 +462,9 @@ export declare const LspGetSemanticsOutputSchema: z.ZodObject<{
                         noReferences: "noReferences";
                         noHover: "noHover";
                         noCalls: "noCalls";
+                        noWorkspaceSymbols: "noWorkspaceSymbols";
+                        noTypeHierarchy: "noTypeHierarchy";
+                        noDiagnostics: "noDiagnostics";
                     }>;
                     reason: z.ZodString;
                 }, z.core.$strip>>;
@@ -433,6 +524,9 @@ export declare const LspGetSemanticsOutputSchema: z.ZodObject<{
                         noReferences: "noReferences";
                         noHover: "noHover";
                         noCalls: "noCalls";
+                        noWorkspaceSymbols: "noWorkspaceSymbols";
+                        noTypeHierarchy: "noTypeHierarchy";
+                        noDiagnostics: "noDiagnostics";
                     }>;
                     reason: z.ZodString;
                 }, z.core.$strip>>;
@@ -473,6 +567,77 @@ export declare const LspGetSemanticsOutputSchema: z.ZodObject<{
                         noReferences: "noReferences";
                         noHover: "noHover";
                         noCalls: "noCalls";
+                        noWorkspaceSymbols: "noWorkspaceSymbols";
+                        noTypeHierarchy: "noTypeHierarchy";
+                        noDiagnostics: "noDiagnostics";
+                    }>;
+                    reason: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"workspaceSymbol">;
+                query: z.ZodString;
+                symbols: z.ZodArray<z.ZodUnknown>;
+                totalSymbols: z.ZodNumber;
+                empty: z.ZodOptional<z.ZodObject<{
+                    category: z.ZodEnum<{
+                        serverUnavailable: "serverUnavailable";
+                        unsupportedOperation: "unsupportedOperation";
+                        symbolNotFound: "symbolNotFound";
+                        anchorFailed: "anchorFailed";
+                        noLocations: "noLocations";
+                        noReferences: "noReferences";
+                        noHover: "noHover";
+                        noCalls: "noCalls";
+                        noWorkspaceSymbols: "noWorkspaceSymbols";
+                        noTypeHierarchy: "noTypeHierarchy";
+                        noDiagnostics: "noDiagnostics";
+                    }>;
+                    reason: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"typeHierarchy">;
+                direction: z.ZodEnum<{
+                    supertypes: "supertypes";
+                    subtypes: "subtypes";
+                }>;
+                root: z.ZodOptional<z.ZodUnknown>;
+                items: z.ZodArray<z.ZodUnknown>;
+                totalItems: z.ZodNumber;
+                empty: z.ZodOptional<z.ZodObject<{
+                    category: z.ZodEnum<{
+                        serverUnavailable: "serverUnavailable";
+                        unsupportedOperation: "unsupportedOperation";
+                        symbolNotFound: "symbolNotFound";
+                        anchorFailed: "anchorFailed";
+                        noLocations: "noLocations";
+                        noReferences: "noReferences";
+                        noHover: "noHover";
+                        noCalls: "noCalls";
+                        noWorkspaceSymbols: "noWorkspaceSymbols";
+                        noTypeHierarchy: "noTypeHierarchy";
+                        noDiagnostics: "noDiagnostics";
+                    }>;
+                    reason: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"diagnostic">;
+                diagnostics: z.ZodArray<z.ZodUnknown>;
+                totalDiagnostics: z.ZodNumber;
+                errorCount: z.ZodNumber;
+                warningCount: z.ZodNumber;
+                empty: z.ZodOptional<z.ZodObject<{
+                    category: z.ZodEnum<{
+                        serverUnavailable: "serverUnavailable";
+                        unsupportedOperation: "unsupportedOperation";
+                        symbolNotFound: "symbolNotFound";
+                        anchorFailed: "anchorFailed";
+                        noLocations: "noLocations";
+                        noReferences: "noReferences";
+                        noHover: "noHover";
+                        noCalls: "noCalls";
+                        noWorkspaceSymbols: "noWorkspaceSymbols";
+                        noTypeHierarchy: "noTypeHierarchy";
+                        noDiagnostics: "noDiagnostics";
                     }>;
                     reason: z.ZodString;
                 }, z.core.$strip>>;
@@ -487,6 +652,9 @@ export declare const LspGetSemanticsOutputSchema: z.ZodObject<{
                     noReferences: "noReferences";
                     noHover: "noHover";
                     noCalls: "noCalls";
+                    noWorkspaceSymbols: "noWorkspaceSymbols";
+                    noTypeHierarchy: "noTypeHierarchy";
+                    noDiagnostics: "noDiagnostics";
                 }>;
                 reason: z.ZodString;
             }, z.core.$strip>], "kind">;

package/dist/tools/lsp/shared/resolveSymbolAnchor.d.ts

@@ -1,4 +1,4 @@
-import type { LspGetSemanticsQuery, ResolvedSymbol } from './semanticTypes.js';
+import type { DocumentSymbolsSemanticQuery, SymbolAnchoredSemanticQuery, ResolvedSymbol } from './semanticTypes.js';
 export type FileAnchor = {
     uri: string;
     absolutePath: string;
@@ -17,4 +17,4 @@ export type AnchorResolutionResult<T> = {
 export declare function resolveFileAnchor(query: {
     uri?: string;
 }, toolName: string): Promise<AnchorResolutionResult<FileAnchor>>;
-export declare function resolveSymbolAnchor(query: LspGetSemanticsQuery, toolName: string): Promise<AnchorResolutionResult<SymbolAnchor>>;
+export declare function resolveSymbolAnchor(query: SymbolAnchoredSemanticQuery | DocumentSymbolsSemanticQuery, toolName: string): Promise<AnchorResolutionResult<SymbolAnchor>>;