monomind 1.17.2 → 1.18.0

package/packages/@monomind/cli/dist/src/mcp-tools/quality/security-compliance/detect-secrets.d.ts

@@ -7,25 +7,29 @@
 import { z } from 'zod';
 export declare const DetectSecretsInputSchema: z.ZodObject<{
     targetPath: z.ZodString;
-    secretTypes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        password: "password";
-        "api-key": "api-key";
-        "private-key": "private-key";
-        token: "token";
-        "connection-string": "connection-string";
-        certificate: "certificate";
-        "aws-key": "aws-key";
-        "aws-secret": "aws-secret";
-        "gcp-key": "gcp-key";
-        "azure-key": "azure-key";
-        generic: "generic";
-    }>>>;
-    excludePatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    secretTypes: z.ZodDefault<z.ZodArray<z.ZodEnum<["api-key", "password", "private-key", "token", "connection-string", "certificate", "aws-key", "aws-secret", "gcp-key", "azure-key", "generic"]>, "many">>;
+    excludePatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     includeEntropy: z.ZodDefault<z.ZodBoolean>;
     entropyThreshold: z.ZodDefault<z.ZodNumber>;
     verifySecrets: z.ZodDefault<z.ZodBoolean>;
     scanHistory: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    targetPath: string;
+    excludePatterns: string[];
+    secretTypes: ("password" | "api-key" | "private-key" | "token" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[];
+    includeEntropy: boolean;
+    entropyThreshold: number;
+    verifySecrets: boolean;
+    scanHistory: boolean;
+}, {
+    targetPath: string;
+    excludePatterns?: string[] | undefined;
+    secretTypes?: ("password" | "api-key" | "private-key" | "token" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[] | undefined;
+    includeEntropy?: boolean | undefined;
+    entropyThreshold?: number | undefined;
+    verifySecrets?: boolean | undefined;
+    scanHistory?: boolean | undefined;
+}>;
 export type DetectSecretsInput = z.infer<typeof DetectSecretsInputSchema>;
 export interface DetectSecretsOutput {
     success: boolean;
@@ -104,25 +108,29 @@ export declare const toolDefinition: {
     version: string;
     inputSchema: z.ZodObject<{
         targetPath: z.ZodString;
-        secretTypes: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            password: "password";
-            "api-key": "api-key";
-            "private-key": "private-key";
-            token: "token";
-            "connection-string": "connection-string";
-            certificate: "certificate";
-            "aws-key": "aws-key";
-            "aws-secret": "aws-secret";
-            "gcp-key": "gcp-key";
-            "azure-key": "azure-key";
-            generic: "generic";
-        }>>>;
-        excludePatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        secretTypes: z.ZodDefault<z.ZodArray<z.ZodEnum<["api-key", "password", "private-key", "token", "connection-string", "certificate", "aws-key", "aws-secret", "gcp-key", "azure-key", "generic"]>, "many">>;
+        excludePatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         includeEntropy: z.ZodDefault<z.ZodBoolean>;
         entropyThreshold: z.ZodDefault<z.ZodNumber>;
         verifySecrets: z.ZodDefault<z.ZodBoolean>;
         scanHistory: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        targetPath: string;
+        excludePatterns: string[];
+        secretTypes: ("password" | "api-key" | "private-key" | "token" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[];
+        includeEntropy: boolean;
+        entropyThreshold: number;
+        verifySecrets: boolean;
+        scanHistory: boolean;
+    }, {
+        targetPath: string;
+        excludePatterns?: string[] | undefined;
+        secretTypes?: ("password" | "api-key" | "private-key" | "token" | "connection-string" | "certificate" | "aws-key" | "aws-secret" | "gcp-key" | "azure-key" | "generic")[] | undefined;
+        includeEntropy?: boolean | undefined;
+        entropyThreshold?: number | undefined;
+        verifySecrets?: boolean | undefined;
+        scanHistory?: boolean | undefined;
+    }>;
     handler: typeof handler;
 };
 export default toolDefinition;

package/packages/@monomind/cli/dist/src/mcp-tools/quality/security-compliance/security-scan.d.ts

@@ -7,34 +7,32 @@
 import { z } from 'zod';
 export declare const SecurityScanInputSchema: z.ZodObject<{
     targetPath: z.ZodString;
-    scanType: z.ZodDefault<z.ZodEnum<{
-        both: "both";
-        sast: "sast";
-        dast: "dast";
-    }>>;
-    compliance: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        "owasp-top-10": "owasp-top-10";
-        "sans-25": "sans-25";
-        "pci-dss": "pci-dss";
-        hipaa: "hipaa";
-        gdpr: "gdpr";
-        soc2: "soc2";
-    }>>>;
-    severity: z.ZodDefault<z.ZodEnum<{
-        critical: "critical";
-        high: "high";
-        all: "all";
-        medium: "medium";
-    }>>;
+    scanType: z.ZodDefault<z.ZodEnum<["sast", "dast", "both"]>>;
+    compliance: z.ZodDefault<z.ZodArray<z.ZodEnum<["owasp-top-10", "sans-25", "pci-dss", "hipaa", "gdpr", "soc2"]>, "many">>;
+    severity: z.ZodDefault<z.ZodEnum<["all", "critical", "high", "medium"]>>;
     includeRemediation: z.ZodDefault<z.ZodBoolean>;
-    scanDepth: z.ZodDefault<z.ZodEnum<{
-        standard: "standard";
-        deep: "deep";
-        quick: "quick";
-    }>>;
-    excludePatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    scanDepth: z.ZodDefault<z.ZodEnum<["quick", "standard", "deep"]>>;
+    excludePatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
     targetUrl: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    targetPath: string;
+    compliance: ("owasp-top-10" | "sans-25" | "pci-dss" | "hipaa" | "gdpr" | "soc2")[];
+    includeRemediation: boolean;
+    scanType: "both" | "sast" | "dast";
+    severity: "critical" | "high" | "all" | "medium";
+    scanDepth: "standard" | "deep" | "quick";
+    excludePatterns: string[];
+    targetUrl?: string | undefined;
+}, {
+    targetPath: string;
+    compliance?: ("owasp-top-10" | "sans-25" | "pci-dss" | "hipaa" | "gdpr" | "soc2")[] | undefined;
+    includeRemediation?: boolean | undefined;
+    scanType?: "both" | "sast" | "dast" | undefined;
+    severity?: "critical" | "high" | "all" | "medium" | undefined;
+    scanDepth?: "standard" | "deep" | "quick" | undefined;
+    excludePatterns?: string[] | undefined;
+    targetUrl?: string | undefined;
+}>;
 export type SecurityScanInput = z.infer<typeof SecurityScanInputSchema>;
 export interface SecurityScanOutput {
     success: boolean;
@@ -137,34 +135,32 @@ export declare const toolDefinition: {
     version: string;
     inputSchema: z.ZodObject<{
         targetPath: z.ZodString;
-        scanType: z.ZodDefault<z.ZodEnum<{
-            both: "both";
-            sast: "sast";
-            dast: "dast";
-        }>>;
-        compliance: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            "owasp-top-10": "owasp-top-10";
-            "sans-25": "sans-25";
-            "pci-dss": "pci-dss";
-            hipaa: "hipaa";
-            gdpr: "gdpr";
-            soc2: "soc2";
-        }>>>;
-        severity: z.ZodDefault<z.ZodEnum<{
-            critical: "critical";
-            high: "high";
-            all: "all";
-            medium: "medium";
-        }>>;
+        scanType: z.ZodDefault<z.ZodEnum<["sast", "dast", "both"]>>;
+        compliance: z.ZodDefault<z.ZodArray<z.ZodEnum<["owasp-top-10", "sans-25", "pci-dss", "hipaa", "gdpr", "soc2"]>, "many">>;
+        severity: z.ZodDefault<z.ZodEnum<["all", "critical", "high", "medium"]>>;
         includeRemediation: z.ZodDefault<z.ZodBoolean>;
-        scanDepth: z.ZodDefault<z.ZodEnum<{
-            standard: "standard";
-            deep: "deep";
-            quick: "quick";
-        }>>;
-        excludePatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        scanDepth: z.ZodDefault<z.ZodEnum<["quick", "standard", "deep"]>>;
+        excludePatterns: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
         targetUrl: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        targetPath: string;
+        compliance: ("owasp-top-10" | "sans-25" | "pci-dss" | "hipaa" | "gdpr" | "soc2")[];
+        includeRemediation: boolean;
+        scanType: "both" | "sast" | "dast";
+        severity: "critical" | "high" | "all" | "medium";
+        scanDepth: "standard" | "deep" | "quick";
+        excludePatterns: string[];
+        targetUrl?: string | undefined;
+    }, {
+        targetPath: string;
+        compliance?: ("owasp-top-10" | "sans-25" | "pci-dss" | "hipaa" | "gdpr" | "soc2")[] | undefined;
+        includeRemediation?: boolean | undefined;
+        scanType?: "both" | "sast" | "dast" | undefined;
+        severity?: "critical" | "high" | "all" | "medium" | undefined;
+        scanDepth?: "standard" | "deep" | "quick" | undefined;
+        excludePatterns?: string[] | undefined;
+        targetUrl?: string | undefined;
+    }>;
     handler: typeof handler;
 };
 export default toolDefinition;

package/packages/@monomind/cli/dist/src/mcp-tools/quality/test-generation/generate-tests.d.ts

@@ -8,43 +8,50 @@
 import { z } from 'zod';
 export declare const GenerateTestsInputSchema: z.ZodObject<{
     targetPath: z.ZodString;
-    testType: z.ZodDefault<z.ZodEnum<{
-        unit: "unit";
-        integration: "integration";
-        e2e: "e2e";
-        property: "property";
-        mutation: "mutation";
-        fuzz: "fuzz";
-    }>>;
-    framework: z.ZodOptional<z.ZodEnum<{
-        vitest: "vitest";
-        jest: "jest";
-        mocha: "mocha";
-        pytest: "pytest";
-        junit: "junit";
-    }>>;
+    testType: z.ZodDefault<z.ZodEnum<["unit", "integration", "e2e", "property", "mutation", "fuzz"]>>;
+    framework: z.ZodOptional<z.ZodEnum<["vitest", "jest", "mocha", "pytest", "junit"]>>;
     coverage: z.ZodOptional<z.ZodObject<{
         target: z.ZodDefault<z.ZodNumber>;
         focusGaps: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    style: z.ZodDefault<z.ZodEnum<{
-        "tdd-london": "tdd-london";
-        "tdd-chicago": "tdd-chicago";
-        bdd: "bdd";
-        "example-based": "example-based";
-    }>>;
-    language: z.ZodOptional<z.ZodEnum<{
-        typescript: "typescript";
-        javascript: "javascript";
-        python: "python";
-        go: "go";
-        rust: "rust";
-        java: "java";
+    }, "strip", z.ZodTypeAny, {
+        target: number;
+        focusGaps: boolean;
+    }, {
+        target?: number | undefined;
+        focusGaps?: boolean | undefined;
     }>>;
+    style: z.ZodDefault<z.ZodEnum<["tdd-london", "tdd-chicago", "bdd", "example-based"]>>;
+    language: z.ZodOptional<z.ZodEnum<["typescript", "javascript", "python", "java", "go", "rust"]>>;
     includeEdgeCases: z.ZodDefault<z.ZodBoolean>;
     includeMocks: z.ZodDefault<z.ZodBoolean>;
     maxTests: z.ZodDefault<z.ZodNumber>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    style: "tdd-london" | "tdd-chicago" | "bdd" | "example-based";
+    targetPath: string;
+    testType: "unit" | "integration" | "e2e" | "property" | "mutation" | "fuzz";
+    includeEdgeCases: boolean;
+    includeMocks: boolean;
+    maxTests: number;
+    language?: "typescript" | "javascript" | "python" | "go" | "rust" | "java" | undefined;
+    framework?: "vitest" | "jest" | "mocha" | "pytest" | "junit" | undefined;
+    coverage?: {
+        target: number;
+        focusGaps: boolean;
+    } | undefined;
+}, {
+    targetPath: string;
+    language?: "typescript" | "javascript" | "python" | "go" | "rust" | "java" | undefined;
+    framework?: "vitest" | "jest" | "mocha" | "pytest" | "junit" | undefined;
+    coverage?: {
+        target?: number | undefined;
+        focusGaps?: boolean | undefined;
+    } | undefined;
+    style?: "tdd-london" | "tdd-chicago" | "bdd" | "example-based" | undefined;
+    testType?: "unit" | "integration" | "e2e" | "property" | "mutation" | "fuzz" | undefined;
+    includeEdgeCases?: boolean | undefined;
+    includeMocks?: boolean | undefined;
+    maxTests?: number | undefined;
+}>;
 export type GenerateTestsInput = z.infer<typeof GenerateTestsInputSchema>;
 export interface GenerateTestsOutput {
     success: boolean;
@@ -104,43 +111,50 @@ export declare const toolDefinition: {
     version: string;
     inputSchema: z.ZodObject<{
         targetPath: z.ZodString;
-        testType: z.ZodDefault<z.ZodEnum<{
-            unit: "unit";
-            integration: "integration";
-            e2e: "e2e";
-            property: "property";
-            mutation: "mutation";
-            fuzz: "fuzz";
-        }>>;
-        framework: z.ZodOptional<z.ZodEnum<{
-            vitest: "vitest";
-            jest: "jest";
-            mocha: "mocha";
-            pytest: "pytest";
-            junit: "junit";
-        }>>;
+        testType: z.ZodDefault<z.ZodEnum<["unit", "integration", "e2e", "property", "mutation", "fuzz"]>>;
+        framework: z.ZodOptional<z.ZodEnum<["vitest", "jest", "mocha", "pytest", "junit"]>>;
         coverage: z.ZodOptional<z.ZodObject<{
             target: z.ZodDefault<z.ZodNumber>;
             focusGaps: z.ZodDefault<z.ZodBoolean>;
-        }, z.core.$strip>>;
-        style: z.ZodDefault<z.ZodEnum<{
-            "tdd-london": "tdd-london";
-            "tdd-chicago": "tdd-chicago";
-            bdd: "bdd";
-            "example-based": "example-based";
-        }>>;
-        language: z.ZodOptional<z.ZodEnum<{
-            typescript: "typescript";
-            javascript: "javascript";
-            python: "python";
-            go: "go";
-            rust: "rust";
-            java: "java";
+        }, "strip", z.ZodTypeAny, {
+            target: number;
+            focusGaps: boolean;
+        }, {
+            target?: number | undefined;
+            focusGaps?: boolean | undefined;
         }>>;
+        style: z.ZodDefault<z.ZodEnum<["tdd-london", "tdd-chicago", "bdd", "example-based"]>>;
+        language: z.ZodOptional<z.ZodEnum<["typescript", "javascript", "python", "java", "go", "rust"]>>;
         includeEdgeCases: z.ZodDefault<z.ZodBoolean>;
         includeMocks: z.ZodDefault<z.ZodBoolean>;
         maxTests: z.ZodDefault<z.ZodNumber>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        style: "tdd-london" | "tdd-chicago" | "bdd" | "example-based";
+        targetPath: string;
+        testType: "unit" | "integration" | "e2e" | "property" | "mutation" | "fuzz";
+        includeEdgeCases: boolean;
+        includeMocks: boolean;
+        maxTests: number;
+        language?: "typescript" | "javascript" | "python" | "go" | "rust" | "java" | undefined;
+        framework?: "vitest" | "jest" | "mocha" | "pytest" | "junit" | undefined;
+        coverage?: {
+            target: number;
+            focusGaps: boolean;
+        } | undefined;
+    }, {
+        targetPath: string;
+        language?: "typescript" | "javascript" | "python" | "go" | "rust" | "java" | undefined;
+        framework?: "vitest" | "jest" | "mocha" | "pytest" | "junit" | undefined;
+        coverage?: {
+            target?: number | undefined;
+            focusGaps?: boolean | undefined;
+        } | undefined;
+        style?: "tdd-london" | "tdd-chicago" | "bdd" | "example-based" | undefined;
+        testType?: "unit" | "integration" | "e2e" | "property" | "mutation" | "fuzz" | undefined;
+        includeEdgeCases?: boolean | undefined;
+        includeMocks?: boolean | undefined;
+        maxTests?: number | undefined;
+    }>;
     handler: typeof handler;
 };
 export default toolDefinition;

package/packages/@monomind/cli/dist/src/mcp-tools/quality/test-generation/suggest-tests.d.ts

@@ -8,30 +8,28 @@ import { z } from 'zod';
 export declare const SuggestTestsInputSchema: z.ZodObject<{
     targetPath: z.ZodString;
     coverageReport: z.ZodOptional<z.ZodString>;
-    focusAreas: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-        lines: "lines";
-        branches: "branches";
-        functions: "functions";
-        "edge-cases": "edge-cases";
-        "error-handling": "error-handling";
-        boundaries: "boundaries";
-    }>>>;
+    focusAreas: z.ZodDefault<z.ZodArray<z.ZodEnum<["branches", "functions", "lines", "edge-cases", "error-handling", "boundaries"]>, "many">>;
     maxSuggestions: z.ZodDefault<z.ZodNumber>;
-    priorityBy: z.ZodDefault<z.ZodEnum<{
-        risk: "risk";
-        complexity: "complexity";
-        "coverage-impact": "coverage-impact";
-        "change-frequency": "change-frequency";
-    }>>;
+    priorityBy: z.ZodDefault<z.ZodEnum<["risk", "complexity", "coverage-impact", "change-frequency"]>>;
     includeCode: z.ZodDefault<z.ZodBoolean>;
-    framework: z.ZodDefault<z.ZodEnum<{
-        vitest: "vitest";
-        jest: "jest";
-        mocha: "mocha";
-        pytest: "pytest";
-        junit: "junit";
-    }>>;
-}, z.core.$strip>;
+    framework: z.ZodDefault<z.ZodEnum<["vitest", "jest", "mocha", "pytest", "junit"]>>;
+}, "strip", z.ZodTypeAny, {
+    framework: "vitest" | "jest" | "mocha" | "pytest" | "junit";
+    targetPath: string;
+    focusAreas: ("lines" | "branches" | "functions" | "edge-cases" | "error-handling" | "boundaries")[];
+    maxSuggestions: number;
+    priorityBy: "risk" | "complexity" | "coverage-impact" | "change-frequency";
+    includeCode: boolean;
+    coverageReport?: string | undefined;
+}, {
+    targetPath: string;
+    framework?: "vitest" | "jest" | "mocha" | "pytest" | "junit" | undefined;
+    coverageReport?: string | undefined;
+    focusAreas?: ("lines" | "branches" | "functions" | "edge-cases" | "error-handling" | "boundaries")[] | undefined;
+    maxSuggestions?: number | undefined;
+    priorityBy?: "risk" | "complexity" | "coverage-impact" | "change-frequency" | undefined;
+    includeCode?: boolean | undefined;
+}>;
 export type SuggestTestsInput = z.infer<typeof SuggestTestsInputSchema>;
 export interface SuggestTestsOutput {
     success: boolean;
@@ -115,30 +113,28 @@ export declare const toolDefinition: {
     inputSchema: z.ZodObject<{
         targetPath: z.ZodString;
         coverageReport: z.ZodOptional<z.ZodString>;
-        focusAreas: z.ZodDefault<z.ZodArray<z.ZodEnum<{
-            lines: "lines";
-            branches: "branches";
-            functions: "functions";
-            "edge-cases": "edge-cases";
-            "error-handling": "error-handling";
-            boundaries: "boundaries";
-        }>>>;
+        focusAreas: z.ZodDefault<z.ZodArray<z.ZodEnum<["branches", "functions", "lines", "edge-cases", "error-handling", "boundaries"]>, "many">>;
         maxSuggestions: z.ZodDefault<z.ZodNumber>;
-        priorityBy: z.ZodDefault<z.ZodEnum<{
-            risk: "risk";
-            complexity: "complexity";
-            "coverage-impact": "coverage-impact";
-            "change-frequency": "change-frequency";
-        }>>;
+        priorityBy: z.ZodDefault<z.ZodEnum<["risk", "complexity", "coverage-impact", "change-frequency"]>>;
         includeCode: z.ZodDefault<z.ZodBoolean>;
-        framework: z.ZodDefault<z.ZodEnum<{
-            vitest: "vitest";
-            jest: "jest";
-            mocha: "mocha";
-            pytest: "pytest";
-            junit: "junit";
-        }>>;
-    }, z.core.$strip>;
+        framework: z.ZodDefault<z.ZodEnum<["vitest", "jest", "mocha", "pytest", "junit"]>>;
+    }, "strip", z.ZodTypeAny, {
+        framework: "vitest" | "jest" | "mocha" | "pytest" | "junit";
+        targetPath: string;
+        focusAreas: ("lines" | "branches" | "functions" | "edge-cases" | "error-handling" | "boundaries")[];
+        maxSuggestions: number;
+        priorityBy: "risk" | "complexity" | "coverage-impact" | "change-frequency";
+        includeCode: boolean;
+        coverageReport?: string | undefined;
+    }, {
+        targetPath: string;
+        framework?: "vitest" | "jest" | "mocha" | "pytest" | "junit" | undefined;
+        coverageReport?: string | undefined;
+        focusAreas?: ("lines" | "branches" | "functions" | "edge-cases" | "error-handling" | "boundaries")[] | undefined;
+        maxSuggestions?: number | undefined;
+        priorityBy?: "risk" | "complexity" | "coverage-impact" | "change-frequency" | undefined;
+        includeCode?: boolean | undefined;
+    }>;
     handler: typeof handler;
 };
 export default toolDefinition;

package/packages/@monomind/cli/dist/src/mcp-tools/quality/test-generation/tdd-cycle.d.ts

@@ -14,22 +14,31 @@ import { z } from 'zod';
 export declare const TDDCycleInputSchema: z.ZodObject<{
     requirement: z.ZodString;
     targetPath: z.ZodString;
-    style: z.ZodDefault<z.ZodEnum<{
-        london: "london";
-        chicago: "chicago";
-    }>>;
+    style: z.ZodDefault<z.ZodEnum<["london", "chicago"]>>;
     maxCycles: z.ZodDefault<z.ZodNumber>;
-    framework: z.ZodDefault<z.ZodEnum<{
-        vitest: "vitest";
-        jest: "jest";
-        mocha: "mocha";
-        pytest: "pytest";
-        junit: "junit";
-    }>>;
+    framework: z.ZodDefault<z.ZodEnum<["vitest", "jest", "mocha", "pytest", "junit"]>>;
     coverageTarget: z.ZodDefault<z.ZodNumber>;
     autoRefactor: z.ZodDefault<z.ZodBoolean>;
     stopOnGreen: z.ZodDefault<z.ZodBoolean>;
-}, z.core.$strip>;
+}, "strip", z.ZodTypeAny, {
+    framework: "vitest" | "jest" | "mocha" | "pytest" | "junit";
+    style: "london" | "chicago";
+    targetPath: string;
+    requirement: string;
+    maxCycles: number;
+    coverageTarget: number;
+    autoRefactor: boolean;
+    stopOnGreen: boolean;
+}, {
+    targetPath: string;
+    requirement: string;
+    framework?: "vitest" | "jest" | "mocha" | "pytest" | "junit" | undefined;
+    style?: "london" | "chicago" | undefined;
+    maxCycles?: number | undefined;
+    coverageTarget?: number | undefined;
+    autoRefactor?: boolean | undefined;
+    stopOnGreen?: boolean | undefined;
+}>;
 export type TDDCycleInput = z.infer<typeof TDDCycleInputSchema>;
 export type TDDPhase = 'red' | 'green' | 'refactor' | 'complete';
 export interface TDDCycleOutput {
@@ -104,22 +113,31 @@ export declare const toolDefinition: {
     inputSchema: z.ZodObject<{
         requirement: z.ZodString;
         targetPath: z.ZodString;
-        style: z.ZodDefault<z.ZodEnum<{
-            london: "london";
-            chicago: "chicago";
-        }>>;
+        style: z.ZodDefault<z.ZodEnum<["london", "chicago"]>>;
         maxCycles: z.ZodDefault<z.ZodNumber>;
-        framework: z.ZodDefault<z.ZodEnum<{
-            vitest: "vitest";
-            jest: "jest";
-            mocha: "mocha";
-            pytest: "pytest";
-            junit: "junit";
-        }>>;
+        framework: z.ZodDefault<z.ZodEnum<["vitest", "jest", "mocha", "pytest", "junit"]>>;
         coverageTarget: z.ZodDefault<z.ZodNumber>;
         autoRefactor: z.ZodDefault<z.ZodBoolean>;
         stopOnGreen: z.ZodDefault<z.ZodBoolean>;
-    }, z.core.$strip>;
+    }, "strip", z.ZodTypeAny, {
+        framework: "vitest" | "jest" | "mocha" | "pytest" | "junit";
+        style: "london" | "chicago";
+        targetPath: string;
+        requirement: string;
+        maxCycles: number;
+        coverageTarget: number;
+        autoRefactor: boolean;
+        stopOnGreen: boolean;
+    }, {
+        targetPath: string;
+        requirement: string;
+        framework?: "vitest" | "jest" | "mocha" | "pytest" | "junit" | undefined;
+        style?: "london" | "chicago" | undefined;
+        maxCycles?: number | undefined;
+        coverageTarget?: number | undefined;
+        autoRefactor?: boolean | undefined;
+        stopOnGreen?: boolean | undefined;
+    }>;
     handler: typeof handler;
 };
 export default toolDefinition;