pinata-security-cli 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1188 @@
+import { z } from 'zod';
+
+/**
+ * Risk domains representing different areas of test coverage
+ */
+declare const RiskDomainSchema: z.ZodEnum<["security", "data", "concurrency", "input", "resource", "reliability", "performance", "platform", "business", "compliance"]>;
+/**
+ * Test levels from unit to chaos engineering
+ */
+declare const TestLevelSchema: z.ZodEnum<["unit", "integration", "system", "chaos"]>;
+/**
+ * Priority levels for categorizing importance
+ */
+declare const PrioritySchema: z.ZodEnum<["P0", "P1", "P2"]>;
+/**
+ * Severity levels for gap findings
+ */
+declare const SeveritySchema: z.ZodEnum<["critical", "high", "medium", "low"]>;
+/**
+ * Confidence levels for pattern detection
+ */
+declare const ConfidenceSchema: z.ZodEnum<["high", "medium", "low"]>;
+/**
+ * Supported programming languages
+ */
+declare const LanguageSchema: z.ZodEnum<["python", "typescript", "javascript", "go", "java", "rust"]>;
+type RiskDomain = z.infer<typeof RiskDomainSchema>;
+type TestLevel = z.infer<typeof TestLevelSchema>;
+type Priority = z.infer<typeof PrioritySchema>;
+type Severity = z.infer<typeof SeveritySchema>;
+type Confidence = z.infer<typeof ConfidenceSchema>;
+type Language = z.infer<typeof LanguageSchema>;
+/**
+ * All available risk domains
+ */
+declare const RISK_DOMAINS: ["security", "data", "concurrency", "input", "resource", "reliability", "performance", "platform", "business", "compliance"];
+/**
+ * All available test levels
+ */
+declare const TEST_LEVELS: ["unit", "integration", "system", "chaos"];
+/**
+ * All available languages
+ */
+declare const LANGUAGES: ["python", "typescript", "javascript", "go", "java", "rust"];
+
+/**
+ * Schema for example vulnerable code and corresponding tests
+ */
+declare const ExampleSchema: z.ZodObject<{
+    /** Unique identifier for this example */
+    name: z.ZodString;
+    /** Explanation of the vulnerability/edge case concept */
+    concept: z.ZodString;
+    /** Example of vulnerable or problematic code */
+    vulnerableCode: z.ZodString;
+    /** Example test code that catches this vulnerability */
+    testCode: z.ZodString;
+    /** Programming language of the example */
+    language: z.ZodEnum<["python", "typescript", "javascript", "go", "java", "rust"]>;
+    /** Severity if this vulnerability is exploited */
+    severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+    /** Optional related CVE identifier */
+    cve: z.ZodOptional<z.ZodString>;
+    /** Optional link to more information */
+    reference: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    severity: "critical" | "high" | "medium" | "low";
+    concept: string;
+    vulnerableCode: string;
+    testCode: string;
+    language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+    cve?: string | undefined;
+    reference?: string | undefined;
+}, {
+    name: string;
+    severity: "critical" | "high" | "medium" | "low";
+    concept: string;
+    vulnerableCode: string;
+    testCode: string;
+    language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+    cve?: string | undefined;
+    reference?: string | undefined;
+}>;
+type Example = z.infer<typeof ExampleSchema>;
+
+/**
+ * Types of detection patterns
+ * - ast: Tree-sitter AST queries
+ * - regex: Regular expression patterns
+ * - semantic: LLM-assisted semantic analysis
+ */
+declare const PatternTypeSchema: z.ZodEnum<["ast", "regex", "semantic"]>;
+/**
+ * Schema for detection patterns that identify code susceptible to a category
+ */
+declare const DetectionPatternSchema: z.ZodObject<{
+    /** Unique identifier for this pattern */
+    id: z.ZodString;
+    /** Type of pattern matching to use */
+    type: z.ZodEnum<["ast", "regex", "semantic"]>;
+    /** Target programming language */
+    language: z.ZodEnum<["python", "typescript", "javascript", "go", "java", "rust"]>;
+    /** The pattern string (AST query, regex, or semantic description) */
+    pattern: z.ZodString;
+    /** How confident we are when this pattern matches */
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+    /** Human-readable description of what this pattern detects */
+    description: z.ZodString;
+    /** Optional pattern that indicates code is NOT vulnerable (false positive filter) */
+    negativePattern: z.ZodOptional<z.ZodString>;
+    /** Optional list of framework contexts where this pattern applies */
+    frameworks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    description: string;
+    type: "ast" | "regex" | "semantic";
+    language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+    pattern: string;
+    confidence: "high" | "medium" | "low";
+    negativePattern?: string | undefined;
+    frameworks?: string[] | undefined;
+}, {
+    id: string;
+    description: string;
+    type: "ast" | "regex" | "semantic";
+    language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+    pattern: string;
+    confidence: "high" | "medium" | "low";
+    negativePattern?: string | undefined;
+    frameworks?: string[] | undefined;
+}>;
+/**
+ * Schema for a detection result (pattern match in code)
+ */
+declare const DetectionResultSchema: z.ZodObject<{
+    /** ID of the pattern that matched */
+    patternId: z.ZodString;
+    /** Category this detection belongs to */
+    categoryId: z.ZodString;
+    /** File path where detection occurred */
+    filePath: z.ZodString;
+    /** Starting line number (1-indexed) */
+    lineStart: z.ZodNumber;
+    /** Ending line number (1-indexed) */
+    lineEnd: z.ZodNumber;
+    /** Code snippet that matched */
+    codeSnippet: z.ZodString;
+    /** Confidence of this specific match */
+    confidence: z.ZodEnum<["high", "medium", "low"]>;
+    /** Optional additional context */
+    context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    confidence: "high" | "medium" | "low";
+    patternId: string;
+    categoryId: string;
+    filePath: string;
+    lineStart: number;
+    lineEnd: number;
+    codeSnippet: string;
+    context?: Record<string, unknown> | undefined;
+}, {
+    confidence: "high" | "medium" | "low";
+    patternId: string;
+    categoryId: string;
+    filePath: string;
+    lineStart: number;
+    lineEnd: number;
+    codeSnippet: string;
+    context?: Record<string, unknown> | undefined;
+}>;
+type PatternType = z.infer<typeof PatternTypeSchema>;
+type DetectionPattern = z.infer<typeof DetectionPatternSchema>;
+type DetectionResult = z.infer<typeof DetectionResultSchema>;
+/**
+ * All available pattern types
+ */
+declare const PATTERN_TYPES: ["ast", "regex", "semantic"];
+
+/**
+ * Supported test frameworks
+ */
+declare const TestFrameworkSchema: z.ZodEnum<["pytest", "unittest", "jest", "vitest", "mocha", "go-test", "junit"]>;
+/**
+ * Schema for template variables that get substituted during generation
+ */
+declare const TemplateVariableSchema: z.ZodObject<{
+    /** Variable name (used in template as {{name}}) */
+    name: z.ZodString;
+    /** Type of the variable value */
+    type: z.ZodEnum<["string", "number", "boolean", "array", "object"]>;
+    /** Human-readable description */
+    description: z.ZodString;
+    /** Whether this variable must be provided */
+    required: z.ZodDefault<z.ZodBoolean>;
+    /** Default value if not provided */
+    defaultValue: z.ZodOptional<z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    type: "string" | "number" | "boolean" | "object" | "array";
+    required: boolean;
+    defaultValue?: unknown;
+}, {
+    name: string;
+    description: string;
+    type: "string" | "number" | "boolean" | "object" | "array";
+    required?: boolean | undefined;
+    defaultValue?: unknown;
+}>;
+/**
+ * Schema for test templates that generate runnable tests
+ */
+declare const TestTemplateSchema: z.ZodObject<{
+    /** Unique identifier for this template */
+    id: z.ZodString;
+    /** Target programming language */
+    language: z.ZodEnum<["python", "typescript", "javascript", "go", "java", "rust"]>;
+    /** Target test framework */
+    framework: z.ZodEnum<["pytest", "unittest", "jest", "vitest", "mocha", "go-test", "junit"]>;
+    /** Template content with {{variable}} placeholders */
+    template: z.ZodString;
+    /** Variables that can be substituted in the template */
+    variables: z.ZodArray<z.ZodObject<{
+        /** Variable name (used in template as {{name}}) */
+        name: z.ZodString;
+        /** Type of the variable value */
+        type: z.ZodEnum<["string", "number", "boolean", "array", "object"]>;
+        /** Human-readable description */
+        description: z.ZodString;
+        /** Whether this variable must be provided */
+        required: z.ZodDefault<z.ZodBoolean>;
+        /** Default value if not provided */
+        defaultValue: z.ZodOptional<z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        type: "string" | "number" | "boolean" | "object" | "array";
+        required: boolean;
+        defaultValue?: unknown;
+    }, {
+        name: string;
+        description: string;
+        type: "string" | "number" | "boolean" | "object" | "array";
+        required?: boolean | undefined;
+        defaultValue?: unknown;
+    }>, "many">;
+    /** Required imports for the generated test */
+    imports: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Required fixtures or setup code */
+    fixtures: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** Description of what this template tests */
+    description: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+    framework: "pytest" | "unittest" | "jest" | "vitest" | "mocha" | "go-test" | "junit";
+    template: string;
+    variables: {
+        name: string;
+        description: string;
+        type: "string" | "number" | "boolean" | "object" | "array";
+        required: boolean;
+        defaultValue?: unknown;
+    }[];
+    description?: string | undefined;
+    imports?: string[] | undefined;
+    fixtures?: string[] | undefined;
+}, {
+    id: string;
+    language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+    framework: "pytest" | "unittest" | "jest" | "vitest" | "mocha" | "go-test" | "junit";
+    template: string;
+    variables: {
+        name: string;
+        description: string;
+        type: "string" | "number" | "boolean" | "object" | "array";
+        required?: boolean | undefined;
+        defaultValue?: unknown;
+    }[];
+    description?: string | undefined;
+    imports?: string[] | undefined;
+    fixtures?: string[] | undefined;
+}>;
+type TestFramework = z.infer<typeof TestFrameworkSchema>;
+type TemplateVariable = z.infer<typeof TemplateVariableSchema>;
+type TestTemplate = z.infer<typeof TestTemplateSchema>;
+/**
+ * All available test frameworks
+ */
+declare const TEST_FRAMEWORKS: ["pytest", "unittest", "jest", "vitest", "mocha", "go-test", "junit"];
+
+/**
+ * Complete Category schema with all nested types
+ */
+declare const CategorySchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodNumber;
+    name: z.ZodString;
+    description: z.ZodString;
+    domain: z.ZodEnum<["security", "data", "concurrency", "input", "resource", "reliability", "performance", "platform", "business", "compliance"]>;
+    level: z.ZodEnum<["unit", "integration", "system", "chaos"]>;
+    priority: z.ZodEnum<["P0", "P1", "P2"]>;
+    severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+    applicableLanguages: z.ZodArray<z.ZodEnum<["python", "typescript", "javascript", "go", "java", "rust"]>, "many">;
+    cves: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    references: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+} & {
+    detectionPatterns: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        type: z.ZodEnum<["ast", "regex", "semantic"]>;
+        language: z.ZodEnum<["python", "typescript", "javascript", "go", "java", "rust"]>;
+        pattern: z.ZodString;
+        confidence: z.ZodEnum<["high", "medium", "low"]>;
+        description: z.ZodString;
+        negativePattern: z.ZodOptional<z.ZodString>;
+        frameworks: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        description: string;
+        type: "ast" | "regex" | "semantic";
+        language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+        pattern: string;
+        confidence: "high" | "medium" | "low";
+        negativePattern?: string | undefined;
+        frameworks?: string[] | undefined;
+    }, {
+        id: string;
+        description: string;
+        type: "ast" | "regex" | "semantic";
+        language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+        pattern: string;
+        confidence: "high" | "medium" | "low";
+        negativePattern?: string | undefined;
+        frameworks?: string[] | undefined;
+    }>, "many">;
+    testTemplates: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        language: z.ZodEnum<["python", "typescript", "javascript", "go", "java", "rust"]>;
+        framework: z.ZodEnum<["pytest", "unittest", "jest", "vitest", "mocha", "go-test", "junit"]>;
+        template: z.ZodString;
+        variables: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<["string", "number", "boolean", "array", "object"]>;
+            description: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+            defaultValue: z.ZodOptional<z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            name: string;
+            description: string;
+            type: "string" | "number" | "boolean" | "object" | "array";
+            required: boolean;
+            defaultValue?: unknown;
+        }, {
+            name: string;
+            description: string;
+            type: "string" | "number" | "boolean" | "object" | "array";
+            required?: boolean | undefined;
+            defaultValue?: unknown;
+        }>, "many">;
+        imports: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        fixtures: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        description: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        id: string;
+        language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+        framework: "pytest" | "unittest" | "jest" | "vitest" | "mocha" | "go-test" | "junit";
+        template: string;
+        variables: {
+            name: string;
+            description: string;
+            type: "string" | "number" | "boolean" | "object" | "array";
+            required: boolean;
+            defaultValue?: unknown;
+        }[];
+        description?: string | undefined;
+        imports?: string[] | undefined;
+        fixtures?: string[] | undefined;
+    }, {
+        id: string;
+        language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+        framework: "pytest" | "unittest" | "jest" | "vitest" | "mocha" | "go-test" | "junit";
+        template: string;
+        variables: {
+            name: string;
+            description: string;
+            type: "string" | "number" | "boolean" | "object" | "array";
+            required?: boolean | undefined;
+            defaultValue?: unknown;
+        }[];
+        description?: string | undefined;
+        imports?: string[] | undefined;
+        fixtures?: string[] | undefined;
+    }>, "many">;
+    examples: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        concept: z.ZodString;
+        vulnerableCode: z.ZodString;
+        testCode: z.ZodString;
+        language: z.ZodEnum<["python", "typescript", "javascript", "go", "java", "rust"]>;
+        severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+        cve: z.ZodOptional<z.ZodString>;
+        reference: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        severity: "critical" | "high" | "medium" | "low";
+        concept: string;
+        vulnerableCode: string;
+        testCode: string;
+        language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+        cve?: string | undefined;
+        reference?: string | undefined;
+    }, {
+        name: string;
+        severity: "critical" | "high" | "medium" | "low";
+        concept: string;
+        vulnerableCode: string;
+        testCode: string;
+        language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+        cve?: string | undefined;
+        reference?: string | undefined;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    version: number;
+    name: string;
+    description: string;
+    domain: "security" | "data" | "concurrency" | "input" | "resource" | "reliability" | "performance" | "platform" | "business" | "compliance";
+    level: "unit" | "integration" | "system" | "chaos";
+    priority: "P0" | "P1" | "P2";
+    severity: "critical" | "high" | "medium" | "low";
+    applicableLanguages: ("python" | "typescript" | "javascript" | "go" | "java" | "rust")[];
+    createdAt: Date;
+    updatedAt: Date;
+    detectionPatterns: {
+        id: string;
+        description: string;
+        type: "ast" | "regex" | "semantic";
+        language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+        pattern: string;
+        confidence: "high" | "medium" | "low";
+        negativePattern?: string | undefined;
+        frameworks?: string[] | undefined;
+    }[];
+    testTemplates: {
+        id: string;
+        language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+        framework: "pytest" | "unittest" | "jest" | "vitest" | "mocha" | "go-test" | "junit";
+        template: string;
+        variables: {
+            name: string;
+            description: string;
+            type: "string" | "number" | "boolean" | "object" | "array";
+            required: boolean;
+            defaultValue?: unknown;
+        }[];
+        description?: string | undefined;
+        imports?: string[] | undefined;
+        fixtures?: string[] | undefined;
+    }[];
+    examples: {
+        name: string;
+        severity: "critical" | "high" | "medium" | "low";
+        concept: string;
+        vulnerableCode: string;
+        testCode: string;
+        language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+        cve?: string | undefined;
+        reference?: string | undefined;
+    }[];
+    cves?: string[] | undefined;
+    references?: string[] | undefined;
+}, {
+    id: string;
+    version: number;
+    name: string;
+    description: string;
+    domain: "security" | "data" | "concurrency" | "input" | "resource" | "reliability" | "performance" | "platform" | "business" | "compliance";
+    level: "unit" | "integration" | "system" | "chaos";
+    priority: "P0" | "P1" | "P2";
+    severity: "critical" | "high" | "medium" | "low";
+    applicableLanguages: ("python" | "typescript" | "javascript" | "go" | "java" | "rust")[];
+    createdAt: Date;
+    updatedAt: Date;
+    detectionPatterns: {
+        id: string;
+        description: string;
+        type: "ast" | "regex" | "semantic";
+        language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+        pattern: string;
+        confidence: "high" | "medium" | "low";
+        negativePattern?: string | undefined;
+        frameworks?: string[] | undefined;
+    }[];
+    testTemplates: {
+        id: string;
+        language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+        framework: "pytest" | "unittest" | "jest" | "vitest" | "mocha" | "go-test" | "junit";
+        template: string;
+        variables: {
+            name: string;
+            description: string;
+            type: "string" | "number" | "boolean" | "object" | "array";
+            required?: boolean | undefined;
+            defaultValue?: unknown;
+        }[];
+        description?: string | undefined;
+        imports?: string[] | undefined;
+        fixtures?: string[] | undefined;
+    }[];
+    examples: {
+        name: string;
+        severity: "critical" | "high" | "medium" | "low";
+        concept: string;
+        vulnerableCode: string;
+        testCode: string;
+        language: "python" | "typescript" | "javascript" | "go" | "java" | "rust";
+        cve?: string | undefined;
+        reference?: string | undefined;
+    }[];
+    cves?: string[] | undefined;
+    references?: string[] | undefined;
+}>;
+/**
+ * Complete Category type
+ */
+type Category = z.infer<typeof CategorySchema>;
+/**
+ * Category without nested arrays (for partial loading)
+ */
+declare const CategorySummarySchema: z.ZodObject<Pick<{
+    id: z.ZodString;
+    version: z.ZodNumber;
+    name: z.ZodString;
+    description: z.ZodString;
+    domain: z.ZodEnum<["security", "data", "concurrency", "input", "resource", "reliability", "performance", "platform", "business", "compliance"]>;
+    level: z.ZodEnum<["unit", "integration", "system", "chaos"]>;
+    priority: z.ZodEnum<["P0", "P1", "P2"]>;
+    severity: z.ZodEnum<["critical", "high", "medium", "low"]>;
+    applicableLanguages: z.ZodArray<z.ZodEnum<["python", "typescript", "javascript", "go", "java", "rust"]>, "many">;
+    cves: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    references: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    createdAt: z.ZodDate;
+    updatedAt: z.ZodDate;
+}, "id" | "name" | "description" | "domain" | "level" | "priority" | "severity">, "strip", z.ZodTypeAny, {
+    id: string;
+    name: string;
+    description: string;
+    domain: "security" | "data" | "concurrency" | "input" | "resource" | "reliability" | "performance" | "platform" | "business" | "compliance";
+    level: "unit" | "integration" | "system" | "chaos";
+    priority: "P0" | "P1" | "P2";
+    severity: "critical" | "high" | "medium" | "low";
+}, {
+    id: string;
+    name: string;
+    description: string;
+    domain: "security" | "data" | "concurrency" | "input" | "resource" | "reliability" | "performance" | "platform" | "business" | "compliance";
+    level: "unit" | "integration" | "system" | "chaos";
+    priority: "P0" | "P1" | "P2";
+    severity: "critical" | "high" | "medium" | "low";
+}>;
+type CategorySummary = z.infer<typeof CategorySummarySchema>;
+
+/**
+ * Base error class for all Pinata errors
+ */
+declare class PinataError extends Error {
+    readonly code: string;
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, context?: Record<string, unknown> | undefined);
+    /**
+     * Serialize error for logging or API responses
+     */
+    toJSON(): Record<string, unknown>;
+}
+/**
+ * Error for schema validation failures
+ */
+declare class ValidationError extends PinataError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Error for file/code parsing failures
+ */
+declare class ParseError extends PinataError {
+    readonly filePath: string;
+    readonly line?: number | undefined;
+    constructor(message: string, filePath: string, line?: number | undefined, context?: Record<string, unknown>);
+}
+/**
+ * Error for configuration issues
+ */
+declare class ConfigError extends PinataError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Error during codebase analysis
+ */
+declare class AnalysisError extends PinataError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Error during test generation
+ */
+declare class GenerationError extends PinataError {
+    constructor(message: string, context?: Record<string, unknown>);
+}
+/**
+ * Error for category not found
+ */
+declare class CategoryNotFoundError extends PinataError {
+    constructor(categoryId: string);
+}
+/**
+ * Error for pattern not found
+ */
+declare class PatternNotFoundError extends PinataError {
+    constructor(patternId: string);
+}
+
+/**
+ * Result type for operations that can fail
+ * Prefer this over throwing exceptions for expected failures
+ */
+type Result<T, E = Error> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: E;
+};
+/**
+ * Create a successful result
+ */
+declare function ok<T>(data: T): Result<T, never>;
+/**
+ * Create a failed result
+ */
+declare function err<E>(error: E): Result<never, E>;
+/**
+ * Unwrap a result, throwing if it's an error
+ * Use sparingly - prefer pattern matching with if/else
+ */
+declare function unwrap<T, E>(result: Result<T, E>): T;
+/**
+ * Unwrap a result with a default value for errors
+ */
+declare function unwrapOr<T, E>(result: Result<T, E>, defaultValue: T): T;
+/**
+ * Map over a successful result
+ */
+declare function map<T, U, E>(result: Result<T, E>, fn: (value: T) => U): Result<U, E>;
+/**
+ * Map over a failed result
+ */
+declare function mapErr<T, E, F>(result: Result<T, E>, fn: (error: E) => F): Result<T, F>;
+/**
+ * Chain results together (flatMap)
+ */
+declare function andThen<T, U, E>(result: Result<T, E>, fn: (value: T) => Result<U, E>): Result<U, E>;
+/**
+ * Combine multiple results into one
+ * Returns first error if any fail, otherwise returns array of all values
+ */
+declare function all<T, E>(results: Result<T, E>[]): Result<T[], E>;
+/**
+ * Try to execute a function, returning a Result
+ */
+declare function tryCatch<T>(fn: () => T): Result<T, Error>;
+/**
+ * Try to execute an async function, returning a Result
+ */
+declare function tryCatchAsync<T>(fn: () => Promise<T>): Promise<Result<T, Error>>;
+
+/**
+ * Options for filtering categories
+ */
+interface CategoryFilter {
+    domain?: RiskDomain;
+    level?: TestLevel;
+    language?: Language;
+    priority?: Priority;
+    severity?: Severity;
+}
+/**
+ * Options for searching categories
+ */
+interface SearchOptions {
+    query: string;
+    filter?: CategoryFilter;
+    limit?: number;
+}
+/**
+ * Search result with relevance score
+ */
+interface SearchResult {
+    category: CategorySummary;
+    score: number;
+    matches: string[];
+}
+/**
+ * Store for managing test categories
+ *
+ * Provides:
+ * - CRUD operations for categories
+ * - Indexing by domain, level, language
+ * - Full-text search
+ * - Validation on load
+ */
+declare class CategoryStore {
+    /** All loaded categories by ID */
+    private categories;
+    /** Index by domain */
+    private domainIndex;
+    /** Index by level */
+    private levelIndex;
+    /** Index by language */
+    private languageIndex;
+    /** Index by priority */
+    private priorityIndex;
+    /** Search index: word -> category IDs */
+    private searchIndex;
+    /** Version tracking for loaded categories */
+    private versions;
+    /**
+     * Get total number of loaded categories
+     */
+    get size(): number;
+    /**
+     * Load a single category into the store
+     */
+    add(category: Category): Result<Category, ValidationError>;
+    /**
+     * Get a category by ID
+     */
+    get(id: string): Result<Category, CategoryNotFoundError>;
+    /**
+     * Check if a category exists
+     */
+    has(id: string): boolean;
+    /**
+     * Remove a category by ID
+     */
+    remove(id: string): Result<Category, CategoryNotFoundError>;
+    /**
+     * List all categories, optionally filtered
+     */
+    list(filter?: CategoryFilter): CategorySummary[];
+    /**
+     * Get all categories in a specific domain
+     */
+    byDomain(domain: RiskDomain): CategorySummary[];
+    /**
+     * Get all categories at a specific test level
+     */
+    byLevel(level: TestLevel): CategorySummary[];
+    /**
+     * Get all categories applicable to a language
+     */
+    byLanguage(language: Language): CategorySummary[];
+    /**
+     * Full-text search across categories
+     */
+    search(options: SearchOptions): SearchResult[];
+    /**
+     * Load categories from a directory of YAML files
+     */
+    loadFromDirectory(dirPath: string): Promise<Result<number, ValidationError>>;
+    /**
+     * Load a single category from a YAML file
+     */
+    loadFromFile(filePath: string): Promise<Result<Category, ValidationError>>;
+    /**
+     * Export all categories as an array
+     */
+    toArray(): Category[];
+    /**
+     * Clear all categories and indexes
+     */
+    clear(): void;
+    /**
+     * Get statistics about loaded categories
+     */
+    stats(): {
+        total: number;
+        byDomain: Record<string, number>;
+        byLevel: Record<string, number>;
+        byPriority: Record<string, number>;
+    };
+    /**
+     * Add category to all indexes
+     */
+    private addToIndexes;
+    /**
+     * Remove category from all indexes
+     */
+    private removeFromIndexes;
+    /**
+     * Add ID to an index map
+     */
+    private addToIndex;
+    /**
+     * Remove ID from an index map
+     */
+    private removeFromIndex;
+    /**
+     * Index category text for search
+     */
+    private indexForSearch;
+    /**
+     * Remove category from search index
+     */
+    private removeFromSearchIndex;
+    /**
+     * Tokenize text for search indexing
+     */
+    private tokenize;
+    /**
+     * Intersect two sets, handling undefined
+     * Returns empty set if either input is empty set (filter found no matches)
+     */
+    private intersect;
+    /**
+     * Convert full category to summary
+     */
+    private toSummary;
+    /**
+     * Recursively load YAML files from directory
+     */
+    private loadYamlFilesRecursive;
+}
+/**
+ * Create a new CategoryStore instance
+ */
+declare function createCategoryStore(): CategoryStore;
+
+/**
+ * Log levels from most to least verbose
+ */
+type LogLevel = "debug" | "info" | "warn" | "error" | "silent";
+/**
+ * Logger configuration
+ */
+interface LoggerConfig {
+    level: LogLevel;
+    prefix?: string;
+}
+/**
+ * Simple logger with colored output
+ */
+declare class Logger {
+    private level;
+    private prefix;
+    /**
+     * Configure the logger
+     */
+    configure(config: Partial<LoggerConfig>): void;
+    /**
+     * Check if a log level should be output
+     */
+    private shouldLog;
+    /**
+     * Format a message with optional prefix
+     */
+    private format;
+    /**
+     * Debug level logging (gray)
+     */
+    debug(message: string, ...args: unknown[]): void;
+    /**
+     * Info level logging (default color)
+     */
+    info(message: string, ...args: unknown[]): void;
+    /**
+     * Warning level logging (yellow)
+     */
+    warn(message: string, ...args: unknown[]): void;
+    /**
+     * Error level logging (red)
+     */
+    error(message: string, ...args: unknown[]): void;
+    /**
+     * Success message (green)
+     */
+    success(message: string, ...args: unknown[]): void;
+    /**
+     * Create a child logger with a prefix
+     */
+    child(prefix: string): Logger;
+}
+/**
+ * Global logger instance
+ */
+declare const logger: Logger;
+
+/**
+ * Scanner types and schemas
+ *
+ * Defines the data structures for codebase scanning results,
+ * gap detection, coverage metrics, and Pinata Score calculation.
+ */
+
+/**
+ * A detected gap (missing test coverage)
+ */
+interface Gap {
+    /** Category ID this gap relates to */
+    categoryId: string;
+    /** Category name for display */
+    categoryName: string;
+    /** Risk domain */
+    domain: RiskDomain;
+    /** Test level */
+    level: TestLevel;
+    /** Priority of addressing this gap */
+    priority: Priority;
+    /** Severity if exploited */
+    severity: Severity;
+    /** Detection confidence */
+    confidence: Confidence;
+    /** File where the gap was detected */
+    filePath: string;
+    /** Line number in file */
+    lineStart: number;
+    /** End line number */
+    lineEnd: number;
+    /** Column start */
+    columnStart: number;
+    /** Column end */
+    columnEnd: number;
+    /** Code snippet showing the gap */
+    codeSnippet: string;
+    /** Pattern ID that detected this */
+    patternId: string;
+    /** Detection type used */
+    patternType: "regex" | "ast" | "semantic";
+    /** Weighted score for prioritization (severity × confidence) */
+    priorityScore: number;
+}
+
+/**
+ * Core analysis engine
+ *
+ * This module contains:
+ * - detection/  - Pattern matching against categories
+ * - scanner/    - Codebase analysis orchestration
+ * - ingestion/  - Code parsing and AST extraction (coming soon)
+ * - generation/ - Test code generation (coming soon)
+ */
+declare const VERSION = "0.1.0";
+
+/**
+ * AI Service Types
+ */
+type AIProvider = "anthropic" | "openai" | "mock";
+interface AIConfig {
+    /** AI provider to use */
+    provider: AIProvider;
+    /** API key (reads from env if not provided) */
+    apiKey?: string;
+    /** Model to use (provider-specific) */
+    model?: string;
+    /** Maximum tokens in response */
+    maxTokens?: number;
+    /** Temperature (0-1) */
+    temperature?: number;
+    /** Timeout in milliseconds */
+    timeoutMs?: number;
+}
+interface AIResponse<T = string> {
+    /** Whether the request succeeded */
+    success: boolean;
+    /** Response data */
+    data?: T;
+    /** Error message if failed */
+    error?: string;
+    /** Usage statistics */
+    usage?: {
+        inputTokens: number;
+        outputTokens: number;
+    };
+    /** Response time in ms */
+    durationMs: number;
+}
+interface Message {
+    role: "user" | "assistant" | "system";
+    content: string;
+}
+interface CompletionRequest {
+    messages: Message[];
+    maxTokens?: number;
+    temperature?: number;
+    systemPrompt?: string;
+}
+/**
+ * Gap explanation result
+ */
+interface GapExplanation {
+    /** Short summary (1-2 sentences) */
+    summary: string;
+    /** Detailed explanation */
+    explanation: string;
+    /** Why this is a security/quality risk */
+    risk: string;
+    /** How to fix it */
+    remediation: string;
+    /** Example of safe code */
+    safeExample?: string;
+    /** Relevant CVEs or references */
+    references?: string[];
+}
+/**
+ * Template variable suggestion
+ */
+interface VariableSuggestion {
+    /** Variable name */
+    name: string;
+    /** Suggested value */
+    value: string | number | boolean | string[];
+    /** Reasoning for the suggestion */
+    reasoning: string;
+    /** Confidence in the suggestion (0-1) */
+    confidence: number;
+}
+/**
+ * Pattern suggestion result
+ */
+interface PatternSuggestion {
+    /** Suggested pattern ID */
+    id: string;
+    /** Regex pattern */
+    pattern: string;
+    /** Description of what it detects */
+    description: string;
+    /** Confidence level */
+    confidence: "high" | "medium" | "low";
+    /** Example code that would match */
+    matchExample: string;
+    /** Example code that should NOT match */
+    safeExample: string;
+    /** Reasoning for the pattern */
+    reasoning: string;
+}
+
+/**
+ * AI Service Implementation
+ *
+ * Provides a unified interface for AI completions across providers.
+ * Supports Anthropic Claude and OpenAI GPT models.
+ */
+
+/**
+ * AI Service for generating completions
+ */
+declare class AIService {
+    private readonly config;
+    constructor(config?: Partial<AIConfig>);
+    /**
+     * Get API key from environment variable
+     * For config file support, use the sync version below
+     */
+    private getApiKeyFromEnv;
+    /**
+     * Read API key from config file synchronously
+     * Uses require() for sync file access in constructor context
+     */
+    private getApiKeyFromConfig;
+    /**
+     * Check if the service is configured with an API key
+     */
+    isConfigured(): boolean;
+    /**
+     * Get the current provider
+     */
+    getProvider(): AIProvider;
+    /**
+     * Generate a completion
+     */
+    complete(request: CompletionRequest): Promise<AIResponse<string>>;
+    /**
+     * Generate a JSON completion (parses response as JSON)
+     */
+    completeJSON<T>(request: CompletionRequest): Promise<AIResponse<T>>;
+    /**
+     * Call the AI provider API
+     */
+    private callProvider;
+    /**
+     * Call Anthropic API
+     */
+    private callAnthropic;
+    /**
+     * Call OpenAI API
+     */
+    private callOpenAI;
+    /**
+     * Mock completion for testing
+     */
+    private mockComplete;
+}
+/**
+ * Create an AI service instance
+ */
+declare function createAIService(config?: Partial<AIConfig>): AIService;
+
+/**
+ * Gap Explainer
+ *
+ * Uses AI to generate natural language explanations of detected gaps.
+ */
+
+/**
+ * Explain a single gap
+ */
+declare function explainGap(gap: Gap, category?: Category, config?: Partial<AIConfig>): Promise<AIResponse<GapExplanation>>;
+/**
+ * Explain multiple gaps in batch
+ */
+declare function explainGaps(gaps: Gap[], categories?: Map<string, Category>, config?: Partial<AIConfig>): Promise<Map<string, AIResponse<GapExplanation>>>;
+
+/**
+ * AI Template Variable Filler
+ *
+ * Uses AI to intelligently fill template variables based on context.
+ */
+
+interface VariableFillRequest {
+    /** Code snippet for context */
+    codeSnippet: string;
+    /** File path for additional context */
+    filePath: string;
+    /** Template variables to fill */
+    variables: TemplateVariable[];
+    /** Optional gap information */
+    gap?: Gap;
+    /** Any pre-filled values to exclude */
+    existingValues?: Record<string, unknown>;
+}
+interface VariableFillResult {
+    /** Suggested values for each variable */
+    suggestions: Map<string, VariableSuggestion>;
+    /** Variables that couldn't be filled */
+    unfilled: string[];
+    /** Merged values (suggestions + existing) */
+    values: Record<string, unknown>;
+}
+/**
+ * Suggest variable values for a template
+ */
+declare function suggestVariables(request: VariableFillRequest, config?: Partial<AIConfig>): Promise<AIResponse<VariableFillResult>>;
+
+/**
+ * AI Pattern Suggester
+ *
+ * Uses AI to suggest new detection patterns based on code samples.
+ */
+
+interface PatternSuggestionRequest {
+    /** Category to suggest patterns for */
+    category: string;
+    /** Vulnerable code samples */
+    vulnerableCode: string[];
+    /** Safe code samples (to avoid matching) */
+    safeCode?: string[];
+    /** Language of the code */
+    language: string;
+    /** Existing patterns to avoid duplicating */
+    existingPatterns?: string[];
+    /** Maximum number of suggestions */
+    maxSuggestions?: number;
+}
+interface PatternSuggestionResult {
+    /** Suggested patterns */
+    suggestions: PatternSuggestion[];
+    /** Patterns that were tested but had issues */
+    rejected: Array<{
+        pattern: string;
+        reason: string;
+    }>;
+}
+/**
+ * Suggest patterns based on code samples
+ */
+declare function suggestPatterns(request: PatternSuggestionRequest, config?: Partial<AIConfig>): Promise<AIResponse<PatternSuggestionResult>>;
+
+export { type AIConfig, type AIProvider, type AIResponse, AIService, AnalysisError, type Category, type CategoryFilter, CategoryNotFoundError, CategorySchema, CategoryStore, type CategorySummary, CategorySummarySchema, type Confidence, ConfidenceSchema, ConfigError, type DetectionPattern, DetectionPatternSchema, type DetectionResult, type Example, ExampleSchema, type GapExplanation, GenerationError, LANGUAGES, type Language, LanguageSchema, type LogLevel, PATTERN_TYPES, ParseError, PatternNotFoundError, type PatternSuggestion, type PatternType, PatternTypeSchema, PinataError, type Priority, PrioritySchema, RISK_DOMAINS, type Result, type RiskDomain, RiskDomainSchema, type SearchOptions, type SearchResult, type Severity, SeveritySchema, TEST_FRAMEWORKS, TEST_LEVELS, type TestFramework, TestFrameworkSchema, type TestLevel, TestLevelSchema, type TestTemplate, TestTemplateSchema, VERSION, ValidationError, type VariableSuggestion, all, andThen, createAIService, createCategoryStore, err, explainGap, explainGaps, logger, map, mapErr, ok, suggestPatterns, suggestVariables, tryCatch, tryCatchAsync, unwrap, unwrapOr };