@octocodeai/octocode-tools-core 17.0.2 → 18.0.1

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

@@ -2,14 +2,13 @@ import type { PaginationInfo } from '../../types/toolResults.js';
 export interface GitHubPullRequestApiItem {
     number: number;
     title: string;
-    url: string;
     state: 'open' | 'closed';
     draft: boolean;
     merged: boolean;
-    created_at: string;
-    updated_at: string;
-    closed_at?: string;
-    merged_at?: string;
+    createdAt: string;
+    updatedAt: string;
+    closedAt?: string;
+    mergedAt?: string;
     author: string;
     assignees?: string[];
     labels?: Array<{
@@ -18,12 +17,12 @@ export interface GitHubPullRequestApiItem {
         color: string;
         description?: string;
     }>;
-    head_ref: string;
-    head_sha?: string;
-    base_ref: string;
-    base_sha?: string;
+    headRef: string;
+    headSha?: string;
+    baseRef: string;
+    baseSha?: string;
     body?: string | null;
-    body_pagination?: {
+    bodyPagination?: {
         charOffset: number;
         charLength: number;
         totalChars: number;
@@ -31,25 +30,25 @@ export interface GitHubPullRequestApiItem {
         nextCharOffset?: number;
     };
     comments?: number;
-    comment_details_breakdown?: {
-        inline_review: number;
+    commentDetailsBreakdown?: {
+        inlineReview: number;
         discussion: number;
     };
     commits?: number;
     additions?: number;
     deletions?: number;
-    changed_files?: number;
-    comment_details?: Array<{
+    changedFiles?: number;
+    commentDetails?: Array<{
         id: string;
         user: string;
         body: string;
-        created_at: string;
-        updated_at: string;
+        createdAt: string;
+        updatedAt: string;
         commentType?: 'discussion' | 'review_inline';
         path?: string;
         line?: number;
-        in_reply_to_id?: number | null;
-        body_pagination?: {
+        inReplyToId?: number | null;
+        bodyPagination?: {
             charOffset: number;
             charLength: number;
             totalChars: number;
@@ -57,10 +56,10 @@ export interface GitHubPullRequestApiItem {
             nextCharOffset?: number;
         };
     }>;
-    comment_details_shown?: number;
-    comment_details_total?: number;
-    comment_details_paginated?: boolean;
-    file_changes?: Array<{
+    commentDetailsShown?: number;
+    commentDetailsTotal?: number;
+    commentDetailsPaginated?: boolean;
+    fileChanges?: Array<{
         filename: string;
         status: string;
         additions: number;
@@ -73,10 +72,10 @@ export interface GitHubPullRequestApiItem {
         user: string;
         state: string;
         body: string;
-        submitted_at?: string;
-        commit_id?: string;
+        submittedAt?: string;
+        commitId?: string;
     }>;
-    commit_details?: Array<{
+    commitDetails?: Array<{
         sha: string;
         message: string;
         author: string;
@@ -90,14 +89,14 @@ export interface GitHubPullRequestApiItem {
             patch?: string;
         }>;
     }>;
-    _sanitization_warnings?: string[];
+    sanitizationWarnings?: string[];
 }
 export interface GitHubPullRequestSearchApiData {
     owner?: string;
     repo?: string;
-    pull_requests?: GitHubPullRequestApiItem[];
-    total_count?: number;
-    incomplete_results?: boolean;
+    pullRequests?: GitHubPullRequestApiItem[];
+    totalCount?: number;
+    incompleteResults?: boolean;
     effectiveQuery?: string;
     pagination?: PaginationInfo;
     outputPagination?: {

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

@@ -1,7 +1,5 @@
 import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import type { GitHubRepositoryOutput } from '@octocodeai/octocode-core/extra-types';
 import type { ToolExecutionArgs } from '../../types/execution.js';
 import { type PartialReposSearchQuery } from './execution/queryVariants.js';
 export { buildMergedPagination, buildPartialFailureWarnings, buildResultPagination, } from './execution/pagination.js';
-export declare function formatRepoLine(repo: GitHubRepositoryOutput): string;
 export declare function searchMultipleGitHubRepos(args: ToolExecutionArgs<PartialReposSearchQuery>): Promise<CallToolResult>;

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

@@ -1,13 +1,17 @@
 import { z } from 'zod';
+import type { ItemPagination, ToolContinuation } from '../../scheme/pagination.js';
+import type { BulkToolOutput } from '../../types/toolOutput.js';
 export declare const GitHubReposSearchSingleQueryLocalSchema: z.ZodObject<{
     keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
     topicsToSearch: z.ZodOptional<z.ZodArray<z.ZodString>>;
     language: z.ZodOptional<z.ZodString>;
     owner: z.ZodOptional<z.ZodString>;
     stars: z.ZodOptional<z.ZodString>;
-    size: z.ZodOptional<z.ZodString>;
-    created: z.ZodOptional<z.ZodString>;
+    forks: z.ZodOptional<z.ZodString>;
+    goodFirstIssues: z.ZodOptional<z.ZodString>;
     updated: z.ZodOptional<z.ZodString>;
+    created: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodString>;
     match: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         description: "description";
         name: "name";
@@ -15,8 +19,8 @@ export declare const GitHubReposSearchSingleQueryLocalSchema: z.ZodObject<{
     }>>>;
     sort: z.ZodDefault<z.ZodEnum<{
         stars: "stars";
-        updated: "updated";
         forks: "forks";
+        updated: "updated";
         "help-wanted-issues": "help-wanted-issues";
         "best-match": "best-match";
     }>>;
@@ -27,9 +31,7 @@ export declare const GitHubReposSearchSingleQueryLocalSchema: z.ZodObject<{
         public: "public";
         private: "private";
     }>>;
-    forks: z.ZodOptional<z.ZodString>;
     license: z.ZodOptional<z.ZodString>;
-    goodFirstIssues: z.ZodOptional<z.ZodString>;
     concise: z.ZodOptional<z.ZodBoolean>;
     id: z.ZodOptional<z.ZodString>;
     mainResearchGoal: z.ZodOptional<z.ZodString>;
@@ -41,62 +43,32 @@ export declare const GitHubReposSearchBulkQueryLocalSchema: z.ZodObject<{
     responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
 }, z.core.$strip>;
-export declare const GitHubSearchRepositoriesOutputLocalSchema: z.ZodObject<{
-    results: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        id: z.ZodOptional<z.ZodString>;
-        status: z.ZodOptional<z.ZodString>;
-        data: z.ZodOptional<z.ZodObject<{
-            repositories: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-                owner: z.ZodString;
-                repo: z.ZodString;
-                stars: z.ZodOptional<z.ZodNumber>;
-                forks: z.ZodOptional<z.ZodNumber>;
-                openIssuesCount: z.ZodOptional<z.ZodNumber>;
-                language: z.ZodOptional<z.ZodString>;
-                license: z.ZodOptional<z.ZodString>;
-                description: z.ZodOptional<z.ZodString>;
-                homepage: z.ZodOptional<z.ZodString>;
-                pushedAt: z.ZodOptional<z.ZodString>;
-                createdAt: z.ZodOptional<z.ZodString>;
-                defaultBranch: z.ZodOptional<z.ZodString>;
-                topics: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                visibility: z.ZodOptional<z.ZodString>;
-                url: z.ZodOptional<z.ZodString>;
-                updatedAt: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>]>>>;
-            pagination: z.ZodOptional<z.ZodObject<{
-                currentPage: z.ZodNumber;
-                totalPages: z.ZodNumber;
-                hasMore: z.ZodBoolean;
-                nextPage: z.ZodOptional<z.ZodNumber>;
-                pageSize: z.ZodOptional<z.ZodNumber>;
-                totalItems: z.ZodOptional<z.ZodNumber>;
-                perPage: z.ZodOptional<z.ZodNumber>;
-                totalFound: z.ZodOptional<z.ZodNumber>;
-                returned: z.ZodOptional<z.ZodNumber>;
-                totalMatches: z.ZodOptional<z.ZodNumber>;
-                reportedTotalMatches: z.ZodOptional<z.ZodNumber>;
-                reachableTotalMatches: z.ZodOptional<z.ZodNumber>;
-                totalResults: z.ZodOptional<z.ZodNumber>;
-                itemsPerPage: z.ZodOptional<z.ZodNumber>;
-                totalMatchesKind: z.ZodOptional<z.ZodEnum<{
-                    exact: "exact";
-                    reported: "reported";
-                    lowerBound: "lowerBound";
-                }>>;
-                totalMatchesCapped: z.ZodOptional<z.ZodBoolean>;
-            }, z.core.$strip>>;
-        }, z.core.$loose>>;
-    }, z.core.$loose>>>;
-    base: z.ZodOptional<z.ZodString>;
-    shared: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
-    responsePagination: z.ZodOptional<z.ZodObject<{
-        currentPage: z.ZodNumber;
-        totalPages: z.ZodNumber;
-        hasMore: z.ZodBoolean;
-        charOffset: z.ZodNumber;
-        charLength: z.ZodNumber;
-        totalChars: z.ZodNumber;
-        nextCharOffset: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
+export interface LocalRepositoryDetail {
+    owner: string;
+    repo: string;
+    stars?: number;
+    forks?: number;
+    openIssuesCount?: number;
+    language?: string;
+    license?: string;
+    description?: string;
+    homepage?: string;
+    pushedAt?: string;
+    createdAt?: string;
+    defaultBranch?: string;
+    topics?: string[];
+    visibility?: string;
+    url?: string;
+    updatedAt?: string;
+}
+export interface RepoSearchPagination extends ItemPagination {
+    totalMatchesKind?: 'exact' | 'reported' | 'lowerBound';
+    totalMatchesCapped?: boolean;
+}
+export interface RepositoryResultData {
+    repositories?: Array<string | LocalRepositoryDetail>;
+    pagination?: RepoSearchPagination;
+    next?: Record<string, ToolContinuation>;
+    [key: string]: unknown;
+}
+export type GitHubSearchRepositoriesOutputLocal = BulkToolOutput<RepositoryResultData>;

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

@@ -1,3 +1,5 @@
+import type { ItemPagination, ToolContinuation } from '../../scheme/pagination.js';
+import type { BulkToolOutput } from '../../types/toolOutput.js';
 export declare const GitHubViewRepoStructureQueryLocalSchema: import("zod").ZodObject<{
     owner: import("zod").ZodString;
     repo: import("zod").ZodString;
@@ -6,7 +8,13 @@ export declare const GitHubViewRepoStructureQueryLocalSchema: import("zod").ZodO
     maxDepth: import("zod").ZodOptional<import("zod").ZodNumber>;
     page: import("zod").ZodDefault<import("zod").ZodNumber>;
     itemsPerPage: import("zod").ZodDefault<import("zod").ZodNumber>;
-    includeSizes: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    include: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+        sizes: "sizes";
+        languages: "languages";
+        contributors: "contributors";
+        branches: "branches";
+        tags: "tags";
+    }>>>;
     id: import("zod").ZodOptional<import("zod").ZodString>;
     mainResearchGoal: import("zod").ZodOptional<import("zod").ZodString>;
     researchGoal: import("zod").ZodOptional<import("zod").ZodString>;
@@ -17,68 +25,31 @@ export declare const GitHubViewRepoStructureBulkQueryLocalSchema: import("zod").
     responseCharLength: import("zod").ZodOptional<import("zod").ZodPreprocess<import("zod").ZodNumber>>;
     queries: import("zod").ZodArray<import("zod").ZodType<unknown, unknown, import("zod/v4/core").$ZodTypeInternals<unknown, unknown>>>;
 }, import("zod/v4/core").$strip>;
-export declare const GitHubViewRepoStructureOutputLocalSchema: import("zod").ZodObject<{
-    status: import("zod").ZodOptional<import("zod").ZodEnum<{
-        empty: import("@octocodeai/octocode-core/types").ToolStatus.Empty;
-        error: import("@octocodeai/octocode-core/types").ToolStatus.Error;
-    }>>;
-    data: import("zod").ZodOptional<import("zod").ZodObject<{
-        entries: import("zod").ZodArray<import("zod").ZodObject<{
-            path: import("zod").ZodString;
-            name: import("zod").ZodOptional<import("zod").ZodString>;
-            type: import("zod").ZodOptional<import("zod").ZodString>;
-            size: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$loose>>;
-        pagination: import("zod").ZodOptional<import("zod").ZodObject<{
-            currentPage: import("zod").ZodNumber;
-            totalPages: import("zod").ZodNumber;
-            hasMore: import("zod").ZodBoolean;
-            nextPage: import("zod").ZodOptional<import("zod").ZodNumber>;
-            nextMatchPage: import("zod").ZodOptional<import("zod").ZodNumber>;
-            perPage: import("zod").ZodOptional<import("zod").ZodNumber>;
-            totalMatches: import("zod").ZodOptional<import("zod").ZodNumber>;
-            totalFiles: import("zod").ZodOptional<import("zod").ZodNumber>;
-            totalEntries: import("zod").ZodOptional<import("zod").ZodNumber>;
-            totalResults: import("zod").ZodOptional<import("zod").ZodNumber>;
-            entriesPerPage: import("zod").ZodOptional<import("zod").ZodNumber>;
-            filesPerPage: import("zod").ZodOptional<import("zod").ZodNumber>;
-            matchesPerPage: import("zod").ZodOptional<import("zod").ZodNumber>;
-        }, import("zod/v4/core").$strip>>;
-    }, import("zod/v4/core").$strip>>;
-    entries: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-        path: import("zod").ZodString;
-        name: import("zod").ZodOptional<import("zod").ZodString>;
-        type: import("zod").ZodOptional<import("zod").ZodString>;
-        size: import("zod").ZodOptional<import("zod").ZodNumber>;
-    }, import("zod/v4/core").$loose>>>;
-    pagination: import("zod").ZodOptional<import("zod").ZodObject<{
-        currentPage: import("zod").ZodNumber;
-        totalPages: import("zod").ZodNumber;
-        hasMore: import("zod").ZodBoolean;
-        nextPage: import("zod").ZodOptional<import("zod").ZodNumber>;
-        nextMatchPage: import("zod").ZodOptional<import("zod").ZodNumber>;
-        perPage: import("zod").ZodOptional<import("zod").ZodNumber>;
-        totalMatches: import("zod").ZodOptional<import("zod").ZodNumber>;
-        totalFiles: import("zod").ZodOptional<import("zod").ZodNumber>;
-        totalEntries: import("zod").ZodOptional<import("zod").ZodNumber>;
-        totalResults: import("zod").ZodOptional<import("zod").ZodNumber>;
-        entriesPerPage: import("zod").ZodOptional<import("zod").ZodNumber>;
-        filesPerPage: import("zod").ZodOptional<import("zod").ZodNumber>;
-        matchesPerPage: import("zod").ZodOptional<import("zod").ZodNumber>;
-    }, import("zod/v4/core").$strip>>;
-    warnings: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodObject<{
-        kind: import("zod").ZodString;
-    }, import("zod/v4/core").$loose>]>>>;
-    error: import("zod").ZodOptional<import("zod").ZodString>;
-    base: import("zod").ZodOptional<import("zod").ZodString>;
-    shared: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodNumber, import("zod").ZodBoolean]>>>;
-    responsePagination: import("zod").ZodOptional<import("zod").ZodObject<{
-        currentPage: import("zod").ZodNumber;
-        totalPages: import("zod").ZodNumber;
-        hasMore: import("zod").ZodBoolean;
-        charOffset: import("zod").ZodNumber;
-        charLength: import("zod").ZodNumber;
-        totalChars: import("zod").ZodNumber;
-        nextCharOffset: import("zod").ZodOptional<import("zod").ZodNumber>;
-    }, import("zod/v4/core").$strip>>;
-}, import("zod/v4/core").$loose>;
+export interface StructureDirEntry {
+    dir?: string;
+    files?: string[];
+    folders?: string[];
+    [key: string]: unknown;
+}
+export interface RepoStructureResultData {
+    structure?: StructureDirEntry[];
+    fileSizes?: Record<string, number>;
+    summary?: {
+        totalFiles?: number;
+        totalFolders?: number;
+        truncated?: boolean;
+        [key: string]: unknown;
+    };
+    resolvedBranch?: string;
+    pagination?: ItemPagination;
+    next?: Record<string, ToolContinuation>;
+    warnings?: string[];
+    owner?: string;
+    repo?: string;
+    path?: string;
+    error?: string;
+    statusCode?: number;
+    errorType?: string;
+    [key: string]: unknown;
+}
+export type GitHubViewRepoStructureOutputLocal = BulkToolOutput<RepoStructureResultData>;

package/dist/tools/local_dead_code/deadCodeScan.d.ts

@@ -0,0 +1,26 @@
+import type { DeadClusterOutput, DeadExportOutput, FindDeadCodeQuery as StrictFindDeadCodeQuery } from './scheme.js';
+import type { WithOptionalMeta } from '../../types/execution.js';
+type FindDeadCodeQuery = WithOptionalMeta<StrictFindDeadCodeQuery>;
+export interface DeadCodeScanResult {
+    filesScanned: number;
+    filesSkipped: number;
+    entrypointsResolved: string[];
+    deadExports: DeadExportOutput[];
+    deadClusters: DeadClusterOutput[];
+    warnings: string[];
+    /**
+     * Present (and always `"low"`) when the scan's reachability base is shaky, so
+     * the raw candidate count should not be trusted as-is. Two triggers, each
+     * with its own explanatory `warnings` entry:
+     *  - `entrypointsResolved` came entirely from the test-file heuristic (no
+     *    package.json main/exports/bin matched and no explicit `entrypoints`),
+     *    so every export in an otherwise-live file reads as "dead"; re-scope to
+     *    the real entrypoint-bearing package or pass `entrypoints` explicitly.
+     *  - one or more resolved entrypoints parsed to zero edges (a native
+     *    extractor parse failure on that file), so reachability can't leave them
+     *    and files they should reach show as false "unreachable-file".
+     */
+    confidence?: 'low';
+}
+export declare function scanForDeadCode(rootAbsolutePath: string, query: FindDeadCodeQuery): DeadCodeScanResult;
+export {};

package/dist/tools/local_dead_code/entrypoints.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Resolve entrypoint files: explicit paths win; otherwise auto-detect from
+ * package.json (main/exports/bin, plus file-looking tokens inside `scripts`
+ * such as `node build.mjs`) plus, when `includeTests`, every file that looks
+ * like a test. Tests count as roots because a symbol only exercised by a test
+ * is proven live, not dead — treating them as entrypoints is the conservative
+ * direction (never a false dead-code claim).
+ *
+ * Returns only entrypoints present in `knownFiles` — an explicit path that
+ * doesn't exist in the scanned set is dropped and reported via `warnings`.
+ */
+export declare function resolveEntrypoints(rootAbsolutePath: string, explicitEntrypoints: string[] | undefined, includeTests: boolean, knownFiles: ReadonlySet<string>): {
+    entrypoints: string[];
+    warnings: string[];
+    lowConfidence: boolean;
+};

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

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

package/dist/tools/local_dead_code/graphBuilder.d.ts

@@ -0,0 +1,43 @@
+import type { FileFacts, FileNode } from './types.js';
+export declare const DEFAULT_DEAD_CODE_EXCLUDE_DIRS: string[];
+export interface WalkResult {
+    facts: Map<string, FileFacts>;
+    fileGraph: Map<string, FileNode>;
+    filesScanned: number;
+    filesSkipped: number;
+    truncated: boolean;
+    /**
+     * Files that are the target of a `export * from '...'` somewhere in the
+     * scan. A star re-export re-publishes its target's entire surface, so once
+     * such a target is reachable its exports are the public API — same
+     * treatment as an entrypoint file, not individually retention-checked.
+     */
+    starReexportTargets: Set<string>;
+    /**
+     * Files that are the target of a string-literal dynamic `import('./x')`
+     * somewhere in the scan. A dynamic import resolves the whole module
+     * namespace, not a specific named binding, so — unlike a static
+     * `import { x } from './y'` — there is no reliable way to attribute which
+     * of the target's exports are actually used. Treated the same as
+     * `starReexportTargets`: reachable, and not individually retention-checked,
+     * rather than risk a false-positive "unreferenced export" on a name that's
+     * genuinely read off the dynamically-imported namespace object.
+     */
+    dynamicImportTargets: Set<string>;
+    /**
+     * Reverse star-re-export edges: target file → the files that
+     * `export * from` it. Needed for retention: a NAMED re-export whose barrel
+     * is itself star-re-exported (barrel → `export *` → entrypoint) is public
+     * API — `isBindingLive` must be able to hop the star edge, which carries no
+     * per-name entry in the named `reexportIndex`. Unfiltered (all scanned
+     * files); the scan filters to reachable re-exporters before use.
+     */
+    starReexporters: Map<string, string[]>;
+}
+/**
+ * Walk every graph-fact-capable file under `rootAbsolutePath`, extract native
+ * per-file facts, and resolve import specifiers into a file-level graph. One
+ * native call per file, zero LSP round-trips — this is what makes the scan
+ * scale with repo size instead of candidate count.
+ */
+export declare function buildFileGraph(rootAbsolutePath: string, excludeDir: string[], maxFiles: number): WalkResult;

package/dist/tools/local_dead_code/importResolver.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Resolve an import specifier to a relative path already present in
+ * `knownFiles`, or `null` when it's external/bare or doesn't resolve within
+ * the scanned set (dangling import, or a target outside the scan scope).
+ */
+export declare function resolveImportSpecifier(specifier: string, importingFileRelativePath: string, knownFiles: ReadonlySet<string>): string | null;

package/dist/tools/local_dead_code/local_dead_code.d.ts

@@ -0,0 +1,5 @@
+import type { WithOptionalMeta } from '../../types/execution.js';
+import type { FindDeadCodeOutput, FindDeadCodeQuery as CoreFindDeadCodeQuery } from './scheme.js';
+type FindDeadCodeQuery = WithOptionalMeta<CoreFindDeadCodeQuery>;
+export declare function findDeadCode(query: FindDeadCodeQuery): Promise<FindDeadCodeOutput>;
+export {};

package/dist/tools/local_dead_code/reachability.d.ts

@@ -0,0 +1,21 @@
+import type { FileNode } from './types.js';
+/** BFS from every entrypoint across the directed file-import graph. */
+export declare function computeReachableFiles(fileGraph: ReadonlyMap<string, FileNode>, entrypoints: readonly string[]): Set<string>;
+export interface StronglyConnectedComponent {
+    files: string[];
+}
+/**
+ * Iterative Tarjan's SCC over the file-import graph (iterative, not
+ * recursive, so a deep or cyclic graph in a large repo can't blow the call
+ * stack). Only components with more than one file — or a single file that
+ * imports itself — are real cycles; singleton components are dropped.
+ *
+ * This does NOT change what's reachable (BFS in `computeReachableFiles`
+ * already resolves cycles correctly — a 2-file cycle with no path from any
+ * entrypoint is simply never visited). What SCC adds is explanatory: instead
+ * of reporting N separately "unreachable" files, a cyclic cluster is grouped
+ * and named as one unit — the exact case a one-symbol-at-a-time reference
+ * check (ask "does A call B" in isolation) gets wrong, since each file in the
+ * cluster looks locally referenced by the other.
+ */
+export declare function findStronglyConnectedComponents(fileGraph: ReadonlyMap<string, FileNode>): StronglyConnectedComponent[];

package/dist/tools/local_dead_code/retention.d.ts

@@ -0,0 +1,22 @@
+import type { FileFacts } from './types.js';
+export declare function bindingKey(file: string, name: string): string;
+/**
+ * Symbol-level liveness for one file's exported declarations.
+ *
+ * Seed: exports proven live by cross-file evidence (real import, live
+ * re-export chain, star hop — `isBindingLive`). Then propagate same-file
+ * call edges to a fixpoint: a call only retains its callee when the CALLER is
+ * itself live — two dead exports calling each other must not retain each
+ * other. Non-exported callers are conservatively treated as live (their
+ * liveness is not tracked, and module-level calls carry no caller edge at
+ * all). The lexical whole-word fallback (value references — spreads,
+ * property access, arguments — that `calls` never sees) still applies, but
+ * call-site occurrences attributable to DEAD exported callers are subtracted
+ * first so a dead caller's call site no longer lexically retains its callee.
+ * Both propagation rules are monotone (live only grows, the subtraction only
+ * shrinks), so the fixpoint terminates.
+ */
+export declare function computeLiveExportedNames(file: string, facts: FileFacts, entrypointSet: ReadonlySet<string>, realImportIndex: ReadonlySet<string>, reexportIndex: ReadonlyMap<string, ReadonlyArray<{
+    file: string;
+    localName: string;
+}>>, starReexporters: ReadonlyMap<string, ReadonlyArray<string>>): Set<string>;

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

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { FindDeadCodeQuerySchema as CoreFindDeadCodeQuerySchema } from '@octocodeai/octocode-core/schemas';
+import type { LocalItemPagination, ToolContinuation } from '../../scheme/pagination.js';
+export type FindDeadCodeQuery = z.infer<typeof CoreFindDeadCodeQuerySchema>;
+export declare const LocalFindDeadCodeQuerySchema: z.ZodType<FindDeadCodeQuery>;
+export declare const LocalFindDeadCodeBulkQuerySchema: z.ZodObject<{
+    responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
+    responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
+    queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$strip>;
+export type DeadCodeReason = 'unreachable-file' | 'unreferenced-export' | 'dead-cluster';
+export interface DeadExportOutput {
+    file: string;
+    name: string;
+    kind: string;
+    line: number;
+    reason: DeadCodeReason;
+    clusterId?: number;
+    /**
+     * Only on `reason:"unreferenced-export"` — which negative-evidence path
+     * concluded "dead", so agents know which candidates to LSP-verify first:
+     * - `"reexport-chain"`: the binding IS re-exported somewhere, but every
+     *   chain terminated without a real consumer — the most fragile verdict.
+     * - `"lexical-count"`: no import and no unexplained same-file occurrence
+     *   beyond the declaration itself.
+     */
+    viaHeuristic?: 'lexical-count' | 'reexport-chain';
+}
+export interface DeadClusterOutput {
+    id: number;
+    files: string[];
+    reason: string;
+}
+export interface FindDeadCodeOutput {
+    status?: 'empty' | 'error';
+    error?: string;
+    errorCode?: string;
+    rawResponseChars?: number;
+    path?: string;
+    filesScanned?: number;
+    filesSkipped?: number;
+    entrypointsResolved?: string[];
+    deadExports?: DeadExportOutput[];
+    deadClusters?: DeadClusterOutput[];
+    pagination?: LocalItemPagination;
+    next?: Record<string, ToolContinuation>;
+    /** See `DeadCodeScanResult.confidence` — present (always `"low"`) only when
+     * `entrypointsResolved` came entirely from the test-file heuristic. */
+    confidence?: 'low';
+    [key: string]: unknown;
+}

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

@@ -0,0 +1,56 @@
+export interface DeclarationFact {
+    id: string;
+    name: string;
+    kind: string;
+    line: number;
+    exported: boolean;
+}
+export interface ImportFact {
+    specifier: string;
+    localName: string;
+    importedName: string;
+    line: number;
+}
+export interface CallEdgeFact {
+    caller: string;
+    callee: string;
+}
+export interface FileFacts {
+    relativePath: string;
+    declarations: DeclarationFact[];
+    imports: ImportFact[];
+    /**
+     * Named re-exports (`export { x } from './y.js'`) declared in this file.
+     * Kept separate from `imports`: a re-export is a pass-through, not a
+     * consuming usage — `x` is only actually live if *this file's own* export
+     * of it (`localName`) is itself consumed somewhere, directly or through a
+     * further re-export. Folding these into `imports` would make merely being
+     * re-exported look like proof of use, which false-negatives on exactly the
+     * "barrel re-exports more than anyone downstream imports" case.
+     */
+    namedReexports: ImportFact[];
+    calls: CallEdgeFact[];
+    /**
+     * Whole-word occurrence count of each declared name in the file's raw
+     * source. `calls` only covers function-invocation edges; a name used by
+     * value reference (spread, property access, passed as an argument) never
+     * appears there, so this is the fallback that catches same-file usage of
+     * exported constants/types. A count > 1 means the name appears somewhere
+     * besides its own declaration line.
+     */
+    referenceCounts: Map<string, number>;
+}
+export interface FileNode {
+    relativePath: string;
+    /** Resolved relative paths of files this file imports from — static and
+     * string-literal dynamic `import()` targets alike. */
+    importsFiles: Set<string>;
+    /**
+     * Subset of `importsFiles` reached only through a string-literal dynamic
+     * `import()`, not a static `import`/`export ... from`. Used to compute a
+     * static-only reachability pass so a file reachable exclusively through
+     * dynamic import can be flagged as lower-confidence rather than treated
+     * with the same certainty as a statically-proven path.
+     */
+    dynamicImportsFiles: Set<string>;
+}

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

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