feat(ipuaro): add analysis tools (v0.8.0)

- GetDependenciesTool: get files a file imports - GetDependentsTool: get files that import a file - GetComplexityTool: get complexity metrics - GetTodosTool: find TODO/FIXME/HACK comments Tests: 853 (+120), Coverage: 97.91%
2025-12-28 15:26:53 +05:00 · 2025-12-01 02:23:36 +05:00
parent caf7aac116
commit 2ae1ac13f5
12 changed files with 2669 additions and 1 deletions
--- a/packages/ipuaro/src/infrastructure/tools/analysis/GetComplexityTool.ts
+++ b/packages/ipuaro/src/infrastructure/tools/analysis/GetComplexityTool.ts
@@ -0,0 +1,232 @@
+import * as path from "node:path"
+import type { ITool, ToolContext, ToolParameterSchema } from "../../../domain/services/ITool.js"
+import type { ComplexityMetrics, FileMeta } from "../../../domain/value-objects/FileMeta.js"
+import {
+    createErrorResult,
+    createSuccessResult,
+    type ToolResult,
+} from "../../../domain/value-objects/ToolResult.js"
+
+/**
+ * Complexity entry for a single file.
+ */
+export interface ComplexityEntry {
+    /** Relative path to the file */
+    path: string
+    /** Complexity metrics */
+    metrics: ComplexityMetrics
+    /** File type classification */
+    fileType: "source" | "test" | "config" | "types" | "unknown"
+    /** Whether the file is a hub */
+    isHub: boolean
+}
+
+/**
+ * Result data from get_complexity tool.
+ */
+export interface GetComplexityResult {
+    /** The path that was analyzed (file or directory) */
+    analyzedPath: string | null
+    /** Total files analyzed */
+    totalFiles: number
+    /** Average complexity score */
+    averageScore: number
+    /** Files sorted by complexity score (descending) */
+    files: ComplexityEntry[]
+    /** Summary statistics */
+    summary: {
+        highComplexity: number
+        mediumComplexity: number
+        lowComplexity: number
+    }
+}
+
+/**
+ * Complexity thresholds for classification.
+ */
+const COMPLEXITY_THRESHOLDS = {
+    high: 60,
+    medium: 30,
+}
+
+/**
+ * Tool for getting complexity metrics for files.
+ * Can analyze a single file or all files in the project.
+ */
+export class GetComplexityTool implements ITool {
+    readonly name = "get_complexity"
+    readonly description =
+        "Get complexity metrics for files. " +
+        "Returns LOC, nesting depth, cyclomatic complexity, and overall score. " +
+        "Without path, returns all files sorted by complexity."
+    readonly parameters: ToolParameterSchema[] = [
+        {
+            name: "path",
+            type: "string",
+            description: "File or directory path to analyze (optional, defaults to entire project)",
+            required: false,
+        },
+        {
+            name: "limit",
+            type: "number",
+            description: "Maximum number of files to return (default: 20)",
+            required: false,
+            default: 20,
+        },
+    ]
+    readonly requiresConfirmation = false
+    readonly category = "analysis" as const
+
+    validateParams(params: Record<string, unknown>): string | null {
+        if (params.path !== undefined && typeof params.path !== "string") {
+            return "Parameter 'path' must be a string"
+        }
+        if (params.limit !== undefined) {
+            if (typeof params.limit !== "number" || !Number.isInteger(params.limit)) {
+                return "Parameter 'limit' must be an integer"
+            }
+            if (params.limit < 1) {
+                return "Parameter 'limit' must be at least 1"
+            }
+        }
+        return null
+    }
+
+    async execute(params: Record<string, unknown>, ctx: ToolContext): Promise<ToolResult> {
+        const startTime = Date.now()
+        const callId = `${this.name}-${String(startTime)}`
+
+        const inputPath = params.path as string | undefined
+        const limit = (params.limit as number | undefined) ?? 20
+
+        try {
+            const allMetas = await ctx.storage.getAllMetas()
+
+            if (allMetas.size === 0) {
+                return createSuccessResult(
+                    callId,
+                    {
+                        analyzedPath: inputPath ?? null,
+                        totalFiles: 0,
+                        averageScore: 0,
+                        files: [],
+                        summary: { highComplexity: 0, mediumComplexity: 0, lowComplexity: 0 },
+                    } satisfies GetComplexityResult,
+                    Date.now() - startTime,
+                )
+            }
+
+            let filteredMetas = allMetas
+            let analyzedPath: string | null = null
+
+            if (inputPath) {
+                const relativePath = this.normalizePathToRelative(inputPath, ctx.projectRoot)
+                analyzedPath = relativePath
+                filteredMetas = this.filterByPath(allMetas, relativePath)
+
+                if (filteredMetas.size === 0) {
+                    return createErrorResult(
+                        callId,
+                        `No files found at path: ${relativePath}`,
+                        Date.now() - startTime,
+                    )
+                }
+            }
+
+            const entries: ComplexityEntry[] = []
+            for (const [filePath, meta] of filteredMetas) {
+                entries.push({
+                    path: filePath,
+                    metrics: meta.complexity,
+                    fileType: meta.fileType,
+                    isHub: meta.isHub,
+                })
+            }
+
+            entries.sort((a, b) => b.metrics.score - a.metrics.score)
+
+            const summary = this.calculateSummary(entries)
+            const averageScore = this.calculateAverageScore(entries)
+
+            const limitedEntries = entries.slice(0, limit)
+
+            const result: GetComplexityResult = {
+                analyzedPath,
+                totalFiles: entries.length,
+                averageScore,
+                files: limitedEntries,
+                summary,
+            }
+
+            return createSuccessResult(callId, result, Date.now() - startTime)
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error)
+            return createErrorResult(callId, message, Date.now() - startTime)
+        }
+    }
+
+    /**
+     * Normalize input path to relative path from project root.
+     */
+    private normalizePathToRelative(inputPath: string, projectRoot: string): string {
+        if (path.isAbsolute(inputPath)) {
+            return path.relative(projectRoot, inputPath)
+        }
+        return inputPath
+    }
+
+    /**
+     * Filter metas by path prefix (file or directory).
+     */
+    private filterByPath(
+        allMetas: Map<string, FileMeta>,
+        targetPath: string,
+    ): Map<string, FileMeta> {
+        const filtered = new Map<string, FileMeta>()
+
+        for (const [filePath, meta] of allMetas) {
+            if (filePath === targetPath || filePath.startsWith(`${targetPath}/`)) {
+                filtered.set(filePath, meta)
+            }
+        }
+
+        return filtered
+    }
+
+    /**
+     * Calculate summary statistics for complexity entries.
+     */
+    private calculateSummary(entries: ComplexityEntry[]): {
+        highComplexity: number
+        mediumComplexity: number
+        lowComplexity: number
+    } {
+        let high = 0
+        let medium = 0
+        let low = 0
+
+        for (const entry of entries) {
+            const score = entry.metrics.score
+            if (score >= COMPLEXITY_THRESHOLDS.high) {
+                high++
+            } else if (score >= COMPLEXITY_THRESHOLDS.medium) {
+                medium++
+            } else {
+                low++
+            }
+        }
+
+        return { highComplexity: high, mediumComplexity: medium, lowComplexity: low }
+    }
+
+    /**
+     * Calculate average complexity score.
+     */
+    private calculateAverageScore(entries: ComplexityEntry[]): number {
+        if (entries.length === 0) {
+            return 0
+        }
+        const total = entries.reduce((sum, entry) => sum + entry.metrics.score, 0)
+        return Math.round((total / entries.length) * 100) / 100
+    }
+}
--- a/packages/ipuaro/src/infrastructure/tools/analysis/GetDependenciesTool.ts
+++ b/packages/ipuaro/src/infrastructure/tools/analysis/GetDependenciesTool.ts
@@ -0,0 +1,121 @@
+import * as path from "node:path"
+import type { ITool, ToolContext, ToolParameterSchema } from "../../../domain/services/ITool.js"
+import {
+    createErrorResult,
+    createSuccessResult,
+    type ToolResult,
+} from "../../../domain/value-objects/ToolResult.js"
+
+/**
+ * Single dependency entry with metadata.
+ */
+export interface DependencyEntry {
+    /** Relative path to the dependency */
+    path: string
+    /** Whether the file exists in the project */
+    exists: boolean
+    /** Whether it's an entry point */
+    isEntryPoint: boolean
+    /** Whether it's a hub file */
+    isHub: boolean
+    /** File type classification */
+    fileType: "source" | "test" | "config" | "types" | "unknown"
+}
+
+/**
+ * Result data from get_dependencies tool.
+ */
+export interface GetDependenciesResult {
+    /** The file being analyzed */
+    file: string
+    /** Total number of dependencies */
+    totalDependencies: number
+    /** List of dependencies with metadata */
+    dependencies: DependencyEntry[]
+    /** File type of the source file */
+    fileType: "source" | "test" | "config" | "types" | "unknown"
+}
+
+/**
+ * Tool for getting files that a specific file imports.
+ * Returns the list of internal dependencies from FileMeta.
+ */
+export class GetDependenciesTool implements ITool {
+    readonly name = "get_dependencies"
+    readonly description =
+        "Get files that a specific file imports. " +
+        "Returns internal dependencies resolved to file paths."
+    readonly parameters: ToolParameterSchema[] = [
+        {
+            name: "path",
+            type: "string",
+            description: "File path to analyze (relative to project root or absolute)",
+            required: true,
+        },
+    ]
+    readonly requiresConfirmation = false
+    readonly category = "analysis" as const
+
+    validateParams(params: Record<string, unknown>): string | null {
+        if (typeof params.path !== "string" || params.path.trim() === "") {
+            return "Parameter 'path' is required and must be a non-empty string"
+        }
+        return null
+    }
+
+    async execute(params: Record<string, unknown>, ctx: ToolContext): Promise<ToolResult> {
+        const startTime = Date.now()
+        const callId = `${this.name}-${String(startTime)}`
+
+        const inputPath = (params.path as string).trim()
+
+        try {
+            const relativePath = this.normalizePathToRelative(inputPath, ctx.projectRoot)
+
+            const meta = await ctx.storage.getMeta(relativePath)
+            if (!meta) {
+                return createErrorResult(
+                    callId,
+                    `File not found or not indexed: ${relativePath}`,
+                    Date.now() - startTime,
+                )
+            }
+
+            const dependencies: DependencyEntry[] = []
+            for (const depPath of meta.dependencies) {
+                const depMeta = await ctx.storage.getMeta(depPath)
+                dependencies.push({
+                    path: depPath,
+                    exists: depMeta !== null,
+                    isEntryPoint: depMeta?.isEntryPoint ?? false,
+                    isHub: depMeta?.isHub ?? false,
+                    fileType: depMeta?.fileType ?? "unknown",
+                })
+            }
+
+            dependencies.sort((a, b) => a.path.localeCompare(b.path))
+
+            const result: GetDependenciesResult = {
+                file: relativePath,
+                totalDependencies: dependencies.length,
+                dependencies,
+                fileType: meta.fileType,
+            }
+
+            return createSuccessResult(callId, result, Date.now() - startTime)
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error)
+            return createErrorResult(callId, message, Date.now() - startTime)
+        }
+    }
+
+    /**
+     * Normalize input path to relative path from project root.
+     */
+    private normalizePathToRelative(inputPath: string, projectRoot: string): string {
+        if (path.isAbsolute(inputPath)) {
+            return path.relative(projectRoot, inputPath)
+        }
+        return inputPath
+    }
+}
--- a/packages/ipuaro/src/infrastructure/tools/analysis/GetDependentsTool.ts
+++ b/packages/ipuaro/src/infrastructure/tools/analysis/GetDependentsTool.ts
@@ -0,0 +1,124 @@
+import * as path from "node:path"
+import type { ITool, ToolContext, ToolParameterSchema } from "../../../domain/services/ITool.js"
+import {
+    createErrorResult,
+    createSuccessResult,
+    type ToolResult,
+} from "../../../domain/value-objects/ToolResult.js"
+
+/**
+ * Single dependent entry with metadata.
+ */
+export interface DependentEntry {
+    /** Relative path to the dependent file */
+    path: string
+    /** Whether the file is an entry point */
+    isEntryPoint: boolean
+    /** Whether the file is a hub */
+    isHub: boolean
+    /** File type classification */
+    fileType: "source" | "test" | "config" | "types" | "unknown"
+    /** Complexity score of the dependent */
+    complexityScore: number
+}
+
+/**
+ * Result data from get_dependents tool.
+ */
+export interface GetDependentsResult {
+    /** The file being analyzed */
+    file: string
+    /** Total number of dependents */
+    totalDependents: number
+    /** Whether this file is a hub (>5 dependents) */
+    isHub: boolean
+    /** List of files that import this file */
+    dependents: DependentEntry[]
+    /** File type of the source file */
+    fileType: "source" | "test" | "config" | "types" | "unknown"
+}
+
+/**
+ * Tool for getting files that import a specific file.
+ * Returns the list of files that depend on the target file.
+ */
+export class GetDependentsTool implements ITool {
+    readonly name = "get_dependents"
+    readonly description =
+        "Get files that import a specific file. " +
+        "Returns list of files that depend on the target."
+    readonly parameters: ToolParameterSchema[] = [
+        {
+            name: "path",
+            type: "string",
+            description: "File path to analyze (relative to project root or absolute)",
+            required: true,
+        },
+    ]
+    readonly requiresConfirmation = false
+    readonly category = "analysis" as const
+
+    validateParams(params: Record<string, unknown>): string | null {
+        if (typeof params.path !== "string" || params.path.trim() === "") {
+            return "Parameter 'path' is required and must be a non-empty string"
+        }
+        return null
+    }
+
+    async execute(params: Record<string, unknown>, ctx: ToolContext): Promise<ToolResult> {
+        const startTime = Date.now()
+        const callId = `${this.name}-${String(startTime)}`
+
+        const inputPath = (params.path as string).trim()
+
+        try {
+            const relativePath = this.normalizePathToRelative(inputPath, ctx.projectRoot)
+
+            const meta = await ctx.storage.getMeta(relativePath)
+            if (!meta) {
+                return createErrorResult(
+                    callId,
+                    `File not found or not indexed: ${relativePath}`,
+                    Date.now() - startTime,
+                )
+            }
+
+            const dependents: DependentEntry[] = []
+            for (const depPath of meta.dependents) {
+                const depMeta = await ctx.storage.getMeta(depPath)
+                dependents.push({
+                    path: depPath,
+                    isEntryPoint: depMeta?.isEntryPoint ?? false,
+                    isHub: depMeta?.isHub ?? false,
+                    fileType: depMeta?.fileType ?? "unknown",
+                    complexityScore: depMeta?.complexity.score ?? 0,
+                })
+            }
+
+            dependents.sort((a, b) => a.path.localeCompare(b.path))
+
+            const result: GetDependentsResult = {
+                file: relativePath,
+                totalDependents: dependents.length,
+                isHub: meta.isHub,
+                dependents,
+                fileType: meta.fileType,
+            }
+
+            return createSuccessResult(callId, result, Date.now() - startTime)
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error)
+            return createErrorResult(callId, message, Date.now() - startTime)
+        }
+    }
+
+    /**
+     * Normalize input path to relative path from project root.
+     */
+    private normalizePathToRelative(inputPath: string, projectRoot: string): string {
+        if (path.isAbsolute(inputPath)) {
+            return path.relative(projectRoot, inputPath)
+        }
+        return inputPath
+    }
+}
--- a/packages/ipuaro/src/infrastructure/tools/analysis/GetTodosTool.ts
+++ b/packages/ipuaro/src/infrastructure/tools/analysis/GetTodosTool.ts
@@ -0,0 +1,276 @@
+import * as path from "node:path"
+import type { ITool, ToolContext, ToolParameterSchema } from "../../../domain/services/ITool.js"
+import type { FileData } from "../../../domain/value-objects/FileData.js"
+import {
+    createErrorResult,
+    createSuccessResult,
+    type ToolResult,
+} from "../../../domain/value-objects/ToolResult.js"
+
+/**
+ * Types of TODO markers to search for.
+ */
+export type TodoType = "TODO" | "FIXME" | "HACK" | "XXX" | "BUG" | "NOTE"
+
+/**
+ * A single TODO entry found in the codebase.
+ */
+export interface TodoEntry {
+    /** Relative path to the file */
+    path: string
+    /** Line number where the TODO is found */
+    line: number
+    /** Type of TODO marker (TODO, FIXME, etc.) */
+    type: TodoType
+    /** The TODO text content */
+    text: string
+    /** Full line content for context */
+    context: string
+}
+
+/**
+ * Result data from get_todos tool.
+ */
+export interface GetTodosResult {
+    /** The path that was searched (file or directory) */
+    searchedPath: string | null
+    /** Total number of TODOs found */
+    totalTodos: number
+    /** Number of files with TODOs */
+    filesWithTodos: number
+    /** TODOs grouped by type */
+    byType: Record<TodoType, number>
+    /** List of TODO entries */
+    todos: TodoEntry[]
+}
+
+/**
+ * Supported TODO marker patterns.
+ */
+const TODO_MARKERS: TodoType[] = ["TODO", "FIXME", "HACK", "XXX", "BUG", "NOTE"]
+
+/**
+ * Regex pattern for matching TODO markers in comments.
+ */
+const TODO_PATTERN = new RegExp(
+    `(?://|/\\*|\\*|#)\\s*(${TODO_MARKERS.join("|")})(?:\\([^)]*\\))?:?\\s*(.*)`,
+    "i",
+)
+
+/**
+ * Tool for finding TODO/FIXME/HACK comments in the codebase.
+ * Searches through indexed files for common task markers.
+ */
+export class GetTodosTool implements ITool {
+    readonly name = "get_todos"
+    readonly description =
+        "Find TODO, FIXME, HACK, XXX, BUG, and NOTE comments in the codebase. " +
+        "Returns list of locations with context."
+    readonly parameters: ToolParameterSchema[] = [
+        {
+            name: "path",
+            type: "string",
+            description: "File or directory to search (optional, defaults to entire project)",
+            required: false,
+        },
+        {
+            name: "type",
+            type: "string",
+            description:
+                "Filter by TODO type: TODO, FIXME, HACK, XXX, BUG, NOTE (optional, defaults to all)",
+            required: false,
+        },
+    ]
+    readonly requiresConfirmation = false
+    readonly category = "analysis" as const
+
+    validateParams(params: Record<string, unknown>): string | null {
+        if (params.path !== undefined && typeof params.path !== "string") {
+            return "Parameter 'path' must be a string"
+        }
+        if (params.type !== undefined) {
+            if (typeof params.type !== "string") {
+                return "Parameter 'type' must be a string"
+            }
+            const upperType = params.type.toUpperCase()
+            if (!TODO_MARKERS.includes(upperType as TodoType)) {
+                return `Parameter 'type' must be one of: ${TODO_MARKERS.join(", ")}`
+            }
+        }
+        return null
+    }
+
+    async execute(params: Record<string, unknown>, ctx: ToolContext): Promise<ToolResult> {
+        const startTime = Date.now()
+        const callId = `${this.name}-${String(startTime)}`
+
+        const inputPath = params.path as string | undefined
+        const filterType = params.type ? ((params.type as string).toUpperCase() as TodoType) : null
+
+        try {
+            const allFiles = await ctx.storage.getAllFiles()
+
+            if (allFiles.size === 0) {
+                return createSuccessResult(
+                    callId,
+                    this.createEmptyResult(inputPath ?? null),
+                    Date.now() - startTime,
+                )
+            }
+
+            let filesToSearch = allFiles
+            let searchedPath: string | null = null
+
+            if (inputPath) {
+                const relativePath = this.normalizePathToRelative(inputPath, ctx.projectRoot)
+                searchedPath = relativePath
+                filesToSearch = this.filterByPath(allFiles, relativePath)
+
+                if (filesToSearch.size === 0) {
+                    return createErrorResult(
+                        callId,
+                        `No files found at path: ${relativePath}`,
+                        Date.now() - startTime,
+                    )
+                }
+            }
+
+            const todos: TodoEntry[] = []
+            const filesWithTodos = new Set<string>()
+
+            for (const [filePath, fileData] of filesToSearch) {
+                const fileTodos = this.findTodosInFile(filePath, fileData.lines, filterType)
+                if (fileTodos.length > 0) {
+                    filesWithTodos.add(filePath)
+                    todos.push(...fileTodos)
+                }
+            }
+
+            todos.sort((a, b) => {
+                const pathCompare = a.path.localeCompare(b.path)
+                if (pathCompare !== 0) {
+                    return pathCompare
+                }
+                return a.line - b.line
+            })
+
+            const byType = this.countByType(todos)
+
+            const result: GetTodosResult = {
+                searchedPath,
+                totalTodos: todos.length,
+                filesWithTodos: filesWithTodos.size,
+                byType,
+                todos,
+            }
+
+            return createSuccessResult(callId, result, Date.now() - startTime)
+        } catch (error) {
+            const message = error instanceof Error ? error.message : String(error)
+            return createErrorResult(callId, message, Date.now() - startTime)
+        }
+    }
+
+    /**
+     * Normalize input path to relative path from project root.
+     */
+    private normalizePathToRelative(inputPath: string, projectRoot: string): string {
+        if (path.isAbsolute(inputPath)) {
+            return path.relative(projectRoot, inputPath)
+        }
+        return inputPath
+    }
+
+    /**
+     * Filter files by path prefix.
+     */
+    private filterByPath(
+        allFiles: Map<string, FileData>,
+        targetPath: string,
+    ): Map<string, FileData> {
+        const filtered = new Map<string, FileData>()
+
+        for (const [filePath, fileData] of allFiles) {
+            if (filePath === targetPath || filePath.startsWith(`${targetPath}/`)) {
+                filtered.set(filePath, fileData)
+            }
+        }
+
+        return filtered
+    }
+
+    /**
+     * Find all TODOs in a file.
+     */
+    private findTodosInFile(
+        filePath: string,
+        lines: string[],
+        filterType: TodoType | null,
+    ): TodoEntry[] {
+        const todos: TodoEntry[] = []
+
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i]
+            const match = TODO_PATTERN.exec(line)
+
+            if (match) {
+                const type = match[1].toUpperCase() as TodoType
+                const text = match[2].trim()
+
+                if (filterType && type !== filterType) {
+                    continue
+                }
+
+                todos.push({
+                    path: filePath,
+                    line: i + 1,
+                    type,
+                    text: text || "(no description)",
+                    context: line.trim(),
+                })
+            }
+        }
+
+        return todos
+    }
+
+    /**
+     * Count TODOs by type.
+     */
+    private countByType(todos: TodoEntry[]): Record<TodoType, number> {
+        const counts: Record<TodoType, number> = {
+            TODO: 0,
+            FIXME: 0,
+            HACK: 0,
+            XXX: 0,
+            BUG: 0,
+            NOTE: 0,
+        }
+
+        for (const todo of todos) {
+            counts[todo.type]++
+        }
+
+        return counts
+    }
+
+    /**
+     * Create empty result structure.
+     */
+    private createEmptyResult(searchedPath: string | null): GetTodosResult {
+        return {
+            searchedPath,
+            totalTodos: 0,
+            filesWithTodos: 0,
+            byType: {
+                TODO: 0,
+                FIXME: 0,
+                HACK: 0,
+                XXX: 0,
+                BUG: 0,
+                NOTE: 0,
+            },
+            todos: [],
+        }
+    }
+}
--- a/packages/ipuaro/src/infrastructure/tools/analysis/index.ts
+++ b/packages/ipuaro/src/infrastructure/tools/analysis/index.ts
@@ -0,0 +1,20 @@
+// Analysis tools module exports
+export {
+    GetDependenciesTool,
+    type GetDependenciesResult,
+    type DependencyEntry,
+} from "./GetDependenciesTool.js"
+
+export {
+    GetDependentsTool,
+    type GetDependentsResult,
+    type DependentEntry,
+} from "./GetDependentsTool.js"
+
+export {
+    GetComplexityTool,
+    type GetComplexityResult,
+    type ComplexityEntry,
+} from "./GetComplexityTool.js"
+
+export { GetTodosTool, type GetTodosResult, type TodoEntry, type TodoType } from "./GetTodosTool.js"
--- a/packages/ipuaro/src/infrastructure/tools/index.ts
+++ b/packages/ipuaro/src/infrastructure/tools/index.ts
@@ -27,3 +27,29 @@ export {
    type FindDefinitionResult,
    type DefinitionLocation,
 } from "./search/FindDefinitionTool.js"
+
+// Analysis tools
+export {
+    GetDependenciesTool,
+    type GetDependenciesResult,
+    type DependencyEntry,
+} from "./analysis/GetDependenciesTool.js"
+
+export {
+    GetDependentsTool,
+    type GetDependentsResult,
+    type DependentEntry,
+} from "./analysis/GetDependentsTool.js"
+
+export {
+    GetComplexityTool,
+    type GetComplexityResult,
+    type ComplexityEntry,
+} from "./analysis/GetComplexityTool.js"
+
+export {
+    GetTodosTool,
+    type GetTodosResult,
+    type TodoEntry,
+    type TodoType,
+} from "./analysis/GetTodosTool.js"