codedev-mcp 3.2.0

package/dist/schemas/output-schemas.d.ts

@@ -0,0 +1,517 @@
+/**
+ * Output Schemas for all 33 tools.
+ * Used with server.registerTool() to provide typed JSON outputs (structuredContent)
+ * alongside human-readable text (content).
+ *
+ * Agents get typed, parseable JSON; humans get formatted text.
+ */
+import { z } from 'zod';
+export declare const outputSchemas: {
+    readonly search_code: {
+        readonly matches: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodNumber;
+            column: z.ZodOptional<z.ZodNumber>;
+            text: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            text: string;
+            line: number;
+            column?: number | undefined;
+        }, {
+            file: string;
+            text: string;
+            line: number;
+            column?: number | undefined;
+        }>, "many">;
+        readonly total: z.ZodNumber;
+    };
+    readonly search_symbols: {
+        readonly symbols: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            file: z.ZodString;
+            line: z.ZodNumber;
+            exported: z.ZodOptional<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            type: string;
+            name: string;
+            line: number;
+            exported?: boolean | undefined;
+        }, {
+            file: string;
+            type: string;
+            name: string;
+            line: number;
+            exported?: boolean | undefined;
+        }>, "many">;
+        readonly total: z.ZodNumber;
+    };
+    readonly codebase_map: {
+        readonly summary: z.ZodString;
+        readonly tree: z.ZodString;
+        readonly roots: z.ZodOptional<z.ZodNumber>;
+    };
+    readonly analyze_file: {
+        readonly file: z.ZodString;
+        readonly language: z.ZodString;
+        readonly lines: z.ZodNumber;
+        readonly outline: z.ZodString;
+    };
+    readonly read_files: {
+        readonly files: z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            content: z.ZodString;
+            lines: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            content: string;
+            path: string;
+            lines: number;
+        }, {
+            content: string;
+            path: string;
+            lines: number;
+        }>, "many">;
+    };
+    readonly find_references: {
+        readonly symbol: z.ZodString;
+        readonly references: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodNumber;
+            context: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            line: number;
+            context: string;
+        }, {
+            file: string;
+            line: number;
+            context: string;
+        }>, "many">;
+        readonly total: z.ZodNumber;
+    };
+    readonly dependency_graph: {
+        readonly file: z.ZodString;
+        readonly imports: z.ZodArray<z.ZodString, "many">;
+        readonly importers: z.ZodArray<z.ZodString, "many">;
+    };
+    readonly code_metrics: {
+        readonly totalFiles: z.ZodNumber;
+        readonly totalLines: z.ZodNumber;
+        readonly languages: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        readonly blankLines: z.ZodNumber;
+        readonly commentLines: z.ZodNumber;
+    };
+    readonly git_history: {
+        readonly action: z.ZodString;
+        readonly entries: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>, "many">>;
+        readonly data: z.ZodOptional<z.ZodString>;
+    };
+    readonly file_tree: {
+        readonly tree: z.ZodString;
+        readonly fileCount: z.ZodOptional<z.ZodNumber>;
+        readonly files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            path: z.ZodString;
+            size: z.ZodOptional<z.ZodNumber>;
+            modified: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            size?: number | undefined;
+            modified?: string | undefined;
+        }, {
+            path: string;
+            size?: number | undefined;
+            modified?: string | undefined;
+        }>, "many">>;
+    };
+    readonly find_pattern: {
+        readonly check: z.ZodString;
+        readonly matches: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodOptional<z.ZodNumber>;
+            match: z.ZodString;
+            severity: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            match: string;
+            file: string;
+            line?: number | undefined;
+            severity?: string | undefined;
+        }, {
+            match: string;
+            file: string;
+            line?: number | undefined;
+            severity?: string | undefined;
+        }>, "many">;
+        readonly total: z.ZodNumber;
+    };
+    readonly semantic_search: {
+        readonly matches: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            score: z.ZodNumber;
+            snippet: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            score: number;
+            snippet?: string | undefined;
+        }, {
+            file: string;
+            score: number;
+            snippet?: string | undefined;
+        }>, "many">;
+        readonly total: z.ZodNumber;
+    };
+    readonly call_graph: {
+        readonly file: z.ZodString;
+        readonly functions: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            calls: z.ZodArray<z.ZodString, "many">;
+            calledBy: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            calls: string[];
+            calledBy?: string[] | undefined;
+        }, {
+            name: string;
+            calls: string[];
+            calledBy?: string[] | undefined;
+        }>, "many">;
+    };
+    readonly test_coverage: {
+        readonly action: z.ZodString;
+        readonly data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    readonly code_docs: {
+        readonly action: z.ZodString;
+        readonly data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    readonly security_scan: {
+        readonly issues: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            line: z.ZodNumber;
+            type: z.ZodString;
+            severity: z.ZodString;
+            message: z.ZodString;
+            recommendation: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            type: string;
+            line: number;
+            message: string;
+            severity: string;
+            recommendation?: string | undefined;
+        }, {
+            file: string;
+            type: string;
+            line: number;
+            message: string;
+            severity: string;
+            recommendation?: string | undefined;
+        }>, "many">;
+        readonly total: z.ZodNumber;
+        readonly severity: z.ZodOptional<z.ZodObject<{
+            critical: z.ZodNumber;
+            high: z.ZodNumber;
+            medium: z.ZodNumber;
+            low: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            medium: number;
+            critical: number;
+            high: number;
+            low: number;
+        }, {
+            medium: number;
+            critical: number;
+            high: number;
+            low: number;
+        }>>;
+    };
+    readonly change_impact: {
+        readonly risk: z.ZodString;
+        readonly affected: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            type: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            type: string;
+        }, {
+            file: string;
+            type: string;
+        }>, "many">;
+        readonly summary: z.ZodString;
+    };
+    readonly notebook_analyze: {
+        readonly action: z.ZodString;
+        readonly data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    readonly dead_code: {
+        readonly unusedExports: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            name: string;
+        }, {
+            file: string;
+            name: string;
+        }>, "many">;
+        readonly orphanFiles: z.ZodArray<z.ZodString, "many">;
+        readonly summary: z.ZodObject<{
+            totalUnusedExports: z.ZodNumber;
+            totalOrphanFiles: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            totalUnusedExports: number;
+            totalOrphanFiles: number;
+        }, {
+            totalUnusedExports: number;
+            totalOrphanFiles: number;
+        }>;
+    };
+    readonly branch_compare: {
+        readonly base: z.ZodString;
+        readonly compare: z.ZodString;
+        readonly stats: z.ZodObject<{
+            filesAdded: z.ZodNumber;
+            filesModified: z.ZodNumber;
+            filesDeleted: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            filesAdded: number;
+            filesModified: number;
+            filesDeleted: number;
+        }, {
+            filesAdded: number;
+            filesModified: number;
+            filesDeleted: number;
+        }>;
+        readonly commitsBehind: z.ZodOptional<z.ZodNumber>;
+        readonly commitsAhead: z.ZodOptional<z.ZodNumber>;
+    };
+    readonly complexity_heatmap: {
+        readonly hotspots: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            score: z.ZodNumber;
+            grade: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            score: number;
+            grade: string;
+        }, {
+            file: string;
+            score: number;
+            grade: string;
+        }>, "many">;
+        readonly summary: z.ZodObject<{
+            totalFiles: z.ZodNumber;
+            criticalCount: z.ZodNumber;
+            averageScore: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            totalFiles: number;
+            criticalCount: number;
+            averageScore: number;
+        }, {
+            totalFiles: number;
+            criticalCount: number;
+            averageScore: number;
+        }>;
+    };
+    readonly context_pack: {
+        readonly items: z.ZodArray<z.ZodObject<{
+            file: z.ZodString;
+            relevance: z.ZodNumber;
+            estimatedTokens: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            relevance: number;
+            estimatedTokens: number;
+        }, {
+            file: string;
+            relevance: number;
+            estimatedTokens: number;
+        }>, "many">;
+        readonly totalTokens: z.ZodNumber;
+        readonly budget: z.ZodNumber;
+        readonly filesIncluded: z.ZodNumber;
+    };
+    readonly type_flow: {
+        readonly typeName: z.ZodString;
+        readonly definedIn: z.ZodString;
+        readonly totalUsages: z.ZodNumber;
+        readonly importedBy: z.ZodArray<z.ZodString, "many">;
+    };
+    readonly architecture_check: {
+        readonly violations: z.ZodArray<z.ZodObject<{
+            rule: z.ZodString;
+            file: z.ZodString;
+            message: z.ZodString;
+            severity: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            rule: string;
+            message: string;
+            severity: string;
+        }, {
+            file: string;
+            rule: string;
+            message: string;
+            severity: string;
+        }>, "many">;
+        readonly rulesChecked: z.ZodNumber;
+        readonly passed: z.ZodBoolean;
+    };
+    readonly db_schema: {
+        readonly tables: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            columns: z.ZodOptional<z.ZodNumber>;
+            source: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            columns?: number | undefined;
+            source?: string | undefined;
+        }, {
+            name: string;
+            columns?: number | undefined;
+            source?: string | undefined;
+        }>, "many">;
+        readonly relationships: z.ZodArray<z.ZodObject<{
+            from: z.ZodString;
+            to: z.ZodString;
+            type: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            from: string;
+            to: string;
+        }, {
+            type: string;
+            from: string;
+            to: string;
+        }>, "many">;
+        readonly summary: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        readonly scannedPatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    };
+    readonly api_contracts: {
+        readonly endpoints: z.ZodArray<z.ZodObject<{
+            method: z.ZodString;
+            path: z.ZodString;
+            source: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            path: string;
+            method: string;
+            source?: string | undefined;
+        }, {
+            path: string;
+            method: string;
+            source?: string | undefined;
+        }>, "many">;
+        readonly totalEndpoints: z.ZodNumber;
+        readonly sources: z.ZodArray<z.ZodString, "many">;
+        readonly scannedPatterns: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    };
+    readonly iac_analyze: {
+        readonly platform: z.ZodString;
+        readonly resources: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            name: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            name: string;
+        }, {
+            type: string;
+            name: string;
+        }>, "many">;
+        readonly issues: z.ZodArray<z.ZodObject<{
+            type: z.ZodString;
+            message: z.ZodString;
+            severity: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            message: string;
+            severity: string;
+        }, {
+            type: string;
+            message: string;
+            severity: string;
+        }>, "many">;
+        readonly summary: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    readonly cicd_analyze: {
+        readonly pipelines: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            platform: z.ZodString;
+            file: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            file: string;
+            name: string;
+            platform: string;
+        }, {
+            file: string;
+            name: string;
+            platform: string;
+        }>, "many">;
+        readonly summary: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    readonly monorepo_analyze: {
+        readonly type: z.ZodString;
+        readonly packages: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            path: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            path: string;
+            version?: string | undefined;
+        }, {
+            name: string;
+            path: string;
+            version?: string | undefined;
+        }>, "many">;
+        readonly summary: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    readonly dep_vuln_scan: {
+        readonly vulnerabilities: z.ZodArray<z.ZodObject<{
+            package: z.ZodString;
+            severity: z.ZodString;
+            description: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            severity: string;
+            package: string;
+            description: string;
+        }, {
+            severity: string;
+            package: string;
+            description: string;
+        }>, "many">;
+        readonly totalDeps: z.ZodNumber;
+        readonly outdatedCount: z.ZodNumber;
+        readonly summary: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    readonly perf_profile: {
+        readonly entries: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            value: z.ZodNumber;
+            unit: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            value: number;
+            unit?: string | undefined;
+        }, {
+            name: string;
+            value: number;
+            unit?: string | undefined;
+        }>, "many">;
+        readonly summary: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    };
+    readonly scaffold: {
+        readonly template: z.ZodString;
+        readonly fileName: z.ZodString;
+        readonly language: z.ZodString;
+        readonly generatedCode: z.ZodString;
+    };
+    readonly git_hooks: {
+        readonly action: z.ZodString;
+        readonly hookPath: z.ZodOptional<z.ZodString>;
+        readonly installed: z.ZodOptional<z.ZodBoolean>;
+        readonly data: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    };
+};
+export type ToolOutputSchema<T extends keyof typeof outputSchemas> = (typeof outputSchemas)[T];
+//# sourceMappingURL=output-schemas.d.ts.map

package/dist/schemas/output-schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output-schemas.d.ts","sourceRoot":"","sources":["../../src/schemas/output-schemas.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA8BxB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6ShB,CAAC;AAGX,MAAM,MAAM,gBAAgB,CAAC,CAAC,SAAS,MAAM,OAAO,aAAa,IAAI,CAAC,OAAO,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC"}