@vibe-validate/extractors 0.14.2 → 0.15.0-rc.1

package/dist/result-schema.d.ts

@@ -0,0 +1,349 @@
+/**
+ * Zod Schema for Error Extractor Results
+ *
+ * This schema defines the structure of extractor output and enables
+ * runtime validation and JSON Schema generation for documentation.
+ *
+ * @packageDocumentation
+ */
+import { z } from 'zod';
+/**
+ * Maximum number of errors to include in errors array
+ *
+ * Limits token usage in LLM context window. Full count available in totalErrors field.
+ */
+export declare const MAX_ERRORS_IN_ARRAY = 10;
+/**
+ * Formatted Error Schema
+ *
+ * Structured error information extracted from validation output
+ */
+export declare const FormattedErrorSchema: z.ZodObject<{
+    /** File path where the error occurred */
+    file: z.ZodOptional<z.ZodString>;
+    /** Line number (1-indexed) */
+    line: z.ZodOptional<z.ZodNumber>;
+    /** Column number (1-indexed) */
+    column: z.ZodOptional<z.ZodNumber>;
+    /** Error message */
+    message: z.ZodString;
+    /** Error code (e.g., TS2322, ESLint rule name) */
+    code: z.ZodOptional<z.ZodString>;
+    /** Severity level */
+    severity: z.ZodOptional<z.ZodEnum<["error", "warning"]>>;
+    /** Additional context (surrounding code, stack trace excerpt) */
+    context: z.ZodOptional<z.ZodString>;
+    /** Guidance for fixing the error */
+    guidance: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    message: string;
+    file?: string | undefined;
+    line?: number | undefined;
+    column?: number | undefined;
+    code?: string | undefined;
+    severity?: "error" | "warning" | undefined;
+    context?: string | undefined;
+    guidance?: string | undefined;
+}, {
+    message: string;
+    file?: string | undefined;
+    line?: number | undefined;
+    column?: number | undefined;
+    code?: string | undefined;
+    severity?: "error" | "warning" | undefined;
+    context?: string | undefined;
+    guidance?: string | undefined;
+}>;
+/**
+ * Detection Metadata Schema
+ *
+ * Information about which extractor was selected and why
+ */
+export declare const DetectionMetadataSchema: z.ZodObject<{
+    /** Which extractor was used */
+    extractor: z.ZodString;
+    /** Confidence in detection (0-100) */
+    confidence: z.ZodNumber;
+    /** Patterns that matched */
+    patterns: z.ZodArray<z.ZodString, "many">;
+    /** Why this extractor was chosen */
+    reason: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    extractor: string;
+    confidence: number;
+    patterns: string[];
+    reason: string;
+}, {
+    extractor: string;
+    confidence: number;
+    patterns: string[];
+    reason: string;
+}>;
+/**
+ * Extraction Metadata Schema
+ *
+ * Quality information about the extraction process
+ */
+export declare const ExtractionMetadataSchema: z.ZodObject<{
+    /** Detection information (only included when developerFeedback: true) */
+    detection: z.ZodOptional<z.ZodObject<{
+        /** Which extractor was used */
+        extractor: z.ZodString;
+        /** Confidence in detection (0-100) */
+        confidence: z.ZodNumber;
+        /** Patterns that matched */
+        patterns: z.ZodArray<z.ZodString, "many">;
+        /** Why this extractor was chosen */
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        extractor: string;
+        confidence: number;
+        patterns: string[];
+        reason: string;
+    }, {
+        extractor: string;
+        confidence: number;
+        patterns: string[];
+        reason: string;
+    }>>;
+    /** Extraction confidence (0-100) */
+    confidence: z.ZodNumber;
+    /** Percentage of extracted errors with complete data (0-100) */
+    completeness: z.ZodNumber;
+    /** Issues encountered during extraction */
+    issues: z.ZodArray<z.ZodString, "many">;
+    /** Suggestions for improvement (only included when developerFeedback: true) */
+    suggestions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    issues: string[];
+    confidence: number;
+    completeness: number;
+    detection?: {
+        extractor: string;
+        confidence: number;
+        patterns: string[];
+        reason: string;
+    } | undefined;
+    suggestions?: string[] | undefined;
+}, {
+    issues: string[];
+    confidence: number;
+    completeness: number;
+    detection?: {
+        extractor: string;
+        confidence: number;
+        patterns: string[];
+        reason: string;
+    } | undefined;
+    suggestions?: string[] | undefined;
+}>;
+/**
+ * Error Extractor Result Schema
+ *
+ * Complete result structure from error extraction operation
+ *
+ * Field ordering optimized for LLM consumption:
+ * - Summary and count first (high-level overview)
+ * - Structured errors (detailed breakdown)
+ * - Guidance and errorSummary (actionable context)
+ * - Metadata last (quality metrics)
+ */
+export declare const ErrorExtractorResultSchema: z.ZodObject<{
+    /** Human-readable summary (e.g., "2 test failures", "5 type errors") */
+    summary: z.ZodString;
+    /** Total error count (may exceed errors.length if truncated to MAX_ERRORS_IN_ARRAY) */
+    totalErrors: z.ZodNumber;
+    /** Parsed and structured errors (limited to MAX_ERRORS_IN_ARRAY for token efficiency) */
+    errors: z.ZodArray<z.ZodObject<{
+        /** File path where the error occurred */
+        file: z.ZodOptional<z.ZodString>;
+        /** Line number (1-indexed) */
+        line: z.ZodOptional<z.ZodNumber>;
+        /** Column number (1-indexed) */
+        column: z.ZodOptional<z.ZodNumber>;
+        /** Error message */
+        message: z.ZodString;
+        /** Error code (e.g., TS2322, ESLint rule name) */
+        code: z.ZodOptional<z.ZodString>;
+        /** Severity level */
+        severity: z.ZodOptional<z.ZodEnum<["error", "warning"]>>;
+        /** Additional context (surrounding code, stack trace excerpt) */
+        context: z.ZodOptional<z.ZodString>;
+        /** Guidance for fixing the error */
+        guidance: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        message: string;
+        file?: string | undefined;
+        line?: number | undefined;
+        column?: number | undefined;
+        code?: string | undefined;
+        severity?: "error" | "warning" | undefined;
+        context?: string | undefined;
+        guidance?: string | undefined;
+    }, {
+        message: string;
+        file?: string | undefined;
+        line?: number | undefined;
+        column?: number | undefined;
+        code?: string | undefined;
+        severity?: "error" | "warning" | undefined;
+        context?: string | undefined;
+        guidance?: string | undefined;
+    }>, "many">;
+    /** Step-specific actionable guidance for fixing errors */
+    guidance: z.ZodOptional<z.ZodString>;
+    /**
+     * Formatted error summary - LLM-optimized text view of errors
+     *
+     * When errors exist: Concise file:line:column - message format
+     * When no errors: Keyword extraction from output (FAILED, Error, etc.)
+     * ANSI codes stripped, limited to first 10-20 relevant lines
+     * Provides 40x context window savings vs raw output
+     *
+     * Optional - only included when it provides value beyond structured errors array
+     */
+    errorSummary: z.ZodOptional<z.ZodString>;
+    /** Extraction quality metadata (only included when developerFeedback: true) */
+    metadata: z.ZodOptional<z.ZodObject<{
+        /** Detection information (only included when developerFeedback: true) */
+        detection: z.ZodOptional<z.ZodObject<{
+            /** Which extractor was used */
+            extractor: z.ZodString;
+            /** Confidence in detection (0-100) */
+            confidence: z.ZodNumber;
+            /** Patterns that matched */
+            patterns: z.ZodArray<z.ZodString, "many">;
+            /** Why this extractor was chosen */
+            reason: z.ZodString;
+        }, "strip", z.ZodTypeAny, {
+            extractor: string;
+            confidence: number;
+            patterns: string[];
+            reason: string;
+        }, {
+            extractor: string;
+            confidence: number;
+            patterns: string[];
+            reason: string;
+        }>>;
+        /** Extraction confidence (0-100) */
+        confidence: z.ZodNumber;
+        /** Percentage of extracted errors with complete data (0-100) */
+        completeness: z.ZodNumber;
+        /** Issues encountered during extraction */
+        issues: z.ZodArray<z.ZodString, "many">;
+        /** Suggestions for improvement (only included when developerFeedback: true) */
+        suggestions: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        issues: string[];
+        confidence: number;
+        completeness: number;
+        detection?: {
+            extractor: string;
+            confidence: number;
+            patterns: string[];
+            reason: string;
+        } | undefined;
+        suggestions?: string[] | undefined;
+    }, {
+        issues: string[];
+        confidence: number;
+        completeness: number;
+        detection?: {
+            extractor: string;
+            confidence: number;
+            patterns: string[];
+            reason: string;
+        } | undefined;
+        suggestions?: string[] | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    summary: string;
+    totalErrors: number;
+    errors: {
+        message: string;
+        file?: string | undefined;
+        line?: number | undefined;
+        column?: number | undefined;
+        code?: string | undefined;
+        severity?: "error" | "warning" | undefined;
+        context?: string | undefined;
+        guidance?: string | undefined;
+    }[];
+    guidance?: string | undefined;
+    errorSummary?: string | undefined;
+    metadata?: {
+        issues: string[];
+        confidence: number;
+        completeness: number;
+        detection?: {
+            extractor: string;
+            confidence: number;
+            patterns: string[];
+            reason: string;
+        } | undefined;
+        suggestions?: string[] | undefined;
+    } | undefined;
+}, {
+    summary: string;
+    totalErrors: number;
+    errors: {
+        message: string;
+        file?: string | undefined;
+        line?: number | undefined;
+        column?: number | undefined;
+        code?: string | undefined;
+        severity?: "error" | "warning" | undefined;
+        context?: string | undefined;
+        guidance?: string | undefined;
+    }[];
+    guidance?: string | undefined;
+    errorSummary?: string | undefined;
+    metadata?: {
+        issues: string[];
+        confidence: number;
+        completeness: number;
+        detection?: {
+            extractor: string;
+            confidence: number;
+            patterns: string[];
+            reason: string;
+        } | undefined;
+        suggestions?: string[] | undefined;
+    } | undefined;
+}>;
+/**
+ * Inferred TypeScript types from Zod schemas
+ */
+export type FormattedError = z.infer<typeof FormattedErrorSchema>;
+export type DetectionMetadata = z.infer<typeof DetectionMetadataSchema>;
+export type ExtractionMetadata = z.infer<typeof ExtractionMetadataSchema>;
+export type ErrorExtractorResult = z.infer<typeof ErrorExtractorResultSchema>;
+/**
+ * Safe validation function for ErrorExtractorResult
+ *
+ * NOTE: This duplicates the pattern from @vibe-validate/core's createSafeValidator.
+ * We can't import from core here due to circular dependency (core → extractors).
+ * This is an acceptable trade-off for a foundational package.
+ *
+ * @param data - Data to validate
+ * @returns Validation result with success/error information
+ */
+export declare function safeValidateExtractorResult(data: unknown): {
+    success: true;
+    data: ErrorExtractorResult;
+} | {
+    success: false;
+    errors: string[];
+};
+/**
+ * Strict validation function for ErrorExtractorResult
+ *
+ * Validates and throws on error.
+ *
+ * @param data - Data to validate
+ * @returns Validated result
+ * @throws {Error} If validation fails
+ */
+export declare function validateExtractorResult(data: unknown): ErrorExtractorResult;
+//# sourceMappingURL=result-schema.d.ts.map

package/dist/result-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-schema.d.ts","sourceRoot":"","sources":["../src/result-schema.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,KAAK,CAAC;AAEtC;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;IAC/B,yCAAyC;;IAGzC,8BAA8B;;IAG9B,gCAAgC;;IAGhC,oBAAoB;;IAGpB,kDAAkD;;IAGlD,qBAAqB;;IAGrB,iEAAiE;;IAGjE,oCAAoC;;;;;;;;;;;;;;;;;;;;EAEpC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;IAClC,+BAA+B;;IAG/B,sCAAsC;;IAGtC,4BAA4B;;IAG5B,oCAAoC;;;;;;;;;;;;EAEpC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;IACnC,yEAAyE;;QAnBzE,+BAA+B;;QAG/B,sCAAsC;;QAGtC,4BAA4B;;QAG5B,oCAAoC;;;;;;;;;;;;;IAapC,oCAAoC;;IAGpC,gEAAgE;;IAGhE,2CAA2C;;IAG3C,+EAA+E;;;;;;;;;;;;;;;;;;;;;;;;EAE/E,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,0BAA0B;IACrC,wEAAwE;;IAGxE,uFAAuF;;IAGvF,yFAAyF;;QApFzF,yCAAyC;;QAGzC,8BAA8B;;QAG9B,gCAAgC;;QAGhC,oBAAoB;;QAGpB,kDAAkD;;QAGlD,qBAAqB;;QAGrB,iEAAiE;;QAGjE,oCAAoC;;;;;;;;;;;;;;;;;;;;;IAkEpC,0DAA0D;;IAG1D;;;;;;;;;OASG;;IAGH,+EAA+E;;QApD/E,yEAAyE;;YAnBzE,+BAA+B;;YAG/B,sCAAsC;;YAGtC,4BAA4B;;YAG5B,oCAAoC;;;;;;;;;;;;;QAapC,oCAAoC;;QAGpC,gEAAgE;;QAGhE,2CAA2C;;QAG3C,+EAA+E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0C/E,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AACxE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E;;;;;;;;;GASG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,OAAO,GACrD;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,oBAAoB,CAAA;CAAE,GAC7C;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAcvC;AAED;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,OAAO,GAAG,oBAAoB,CAE3E"}

package/dist/result-schema.js

@@ -0,0 +1,139 @@
+/**
+ * Zod Schema for Error Extractor Results
+ *
+ * This schema defines the structure of extractor output and enables
+ * runtime validation and JSON Schema generation for documentation.
+ *
+ * @packageDocumentation
+ */
+import { z } from 'zod';
+/**
+ * Maximum number of errors to include in errors array
+ *
+ * Limits token usage in LLM context window. Full count available in totalErrors field.
+ */
+export const MAX_ERRORS_IN_ARRAY = 10;
+/**
+ * Formatted Error Schema
+ *
+ * Structured error information extracted from validation output
+ */
+export const FormattedErrorSchema = z.object({
+    /** File path where the error occurred */
+    file: z.string().optional(),
+    /** Line number (1-indexed) */
+    line: z.number().int().positive().optional(),
+    /** Column number (1-indexed) */
+    column: z.number().int().positive().optional(),
+    /** Error message */
+    message: z.string(),
+    /** Error code (e.g., TS2322, ESLint rule name) */
+    code: z.string().optional(),
+    /** Severity level */
+    severity: z.enum(['error', 'warning']).optional(),
+    /** Additional context (surrounding code, stack trace excerpt) */
+    context: z.string().optional(),
+    /** Guidance for fixing the error */
+    guidance: z.string().optional(),
+});
+/**
+ * Detection Metadata Schema
+ *
+ * Information about which extractor was selected and why
+ */
+export const DetectionMetadataSchema = z.object({
+    /** Which extractor was used */
+    extractor: z.string(),
+    /** Confidence in detection (0-100) */
+    confidence: z.number().min(0).max(100),
+    /** Patterns that matched */
+    patterns: z.array(z.string()),
+    /** Why this extractor was chosen */
+    reason: z.string(),
+});
+/**
+ * Extraction Metadata Schema
+ *
+ * Quality information about the extraction process
+ */
+export const ExtractionMetadataSchema = z.object({
+    /** Detection information (only included when developerFeedback: true) */
+    detection: DetectionMetadataSchema.optional(),
+    /** Extraction confidence (0-100) */
+    confidence: z.number().min(0).max(100),
+    /** Percentage of extracted errors with complete data (0-100) */
+    completeness: z.number().min(0).max(100),
+    /** Issues encountered during extraction */
+    issues: z.array(z.string()),
+    /** Suggestions for improvement (only included when developerFeedback: true) */
+    suggestions: z.array(z.string()).optional(),
+});
+/**
+ * Error Extractor Result Schema
+ *
+ * Complete result structure from error extraction operation
+ *
+ * Field ordering optimized for LLM consumption:
+ * - Summary and count first (high-level overview)
+ * - Structured errors (detailed breakdown)
+ * - Guidance and errorSummary (actionable context)
+ * - Metadata last (quality metrics)
+ */
+export const ErrorExtractorResultSchema = z.object({
+    /** Human-readable summary (e.g., "2 test failures", "5 type errors") */
+    summary: z.string(),
+    /** Total error count (may exceed errors.length if truncated to MAX_ERRORS_IN_ARRAY) */
+    totalErrors: z.number().int().nonnegative(),
+    /** Parsed and structured errors (limited to MAX_ERRORS_IN_ARRAY for token efficiency) */
+    errors: z.array(FormattedErrorSchema),
+    /** Step-specific actionable guidance for fixing errors */
+    guidance: z.string().optional(),
+    /**
+     * Formatted error summary - LLM-optimized text view of errors
+     *
+     * When errors exist: Concise file:line:column - message format
+     * When no errors: Keyword extraction from output (FAILED, Error, etc.)
+     * ANSI codes stripped, limited to first 10-20 relevant lines
+     * Provides 40x context window savings vs raw output
+     *
+     * Optional - only included when it provides value beyond structured errors array
+     */
+    errorSummary: z.string().optional(),
+    /** Extraction quality metadata (only included when developerFeedback: true) */
+    metadata: ExtractionMetadataSchema.optional(),
+});
+/**
+ * Safe validation function for ErrorExtractorResult
+ *
+ * NOTE: This duplicates the pattern from @vibe-validate/core's createSafeValidator.
+ * We can't import from core here due to circular dependency (core → extractors).
+ * This is an acceptable trade-off for a foundational package.
+ *
+ * @param data - Data to validate
+ * @returns Validation result with success/error information
+ */
+export function safeValidateExtractorResult(data) {
+    const result = ErrorExtractorResultSchema.safeParse(data);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    // Extract error messages with full path
+    const errors = result.error.errors.map(err => {
+        const path = err.path.join('.');
+        return path ? `${path}: ${err.message}` : err.message;
+    });
+    return { success: false, errors };
+}
+/**
+ * Strict validation function for ErrorExtractorResult
+ *
+ * Validates and throws on error.
+ *
+ * @param data - Data to validate
+ * @returns Validated result
+ * @throws {Error} If validation fails
+ */
+export function validateExtractorResult(data) {
+    return ErrorExtractorResultSchema.parse(data);
+}
+//# sourceMappingURL=result-schema.js.map

package/dist/result-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"result-schema.js","sourceRoot":"","sources":["../src/result-schema.ts"],"names":[],"mappings":"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"}

package/dist/scripts/generate-result-schema.d.ts

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+/**
+ * Generate JSON Schema File for Error Extractor Results
+ *
+ * Creates error-extractor-result.schema.json in the package root for use in
+ * validating documentation examples and agent integration code.
+ * This script runs during the build process.
+ */
+export {};
+//# sourceMappingURL=generate-result-schema.d.ts.map

package/dist/scripts/generate-result-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-result-schema.d.ts","sourceRoot":"","sources":["../../src/scripts/generate-result-schema.ts"],"names":[],"mappings":";AACA;;;;;;GAMG"}

package/dist/scripts/generate-result-schema.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+/**
+ * Generate JSON Schema File for Error Extractor Results
+ *
+ * Creates error-extractor-result.schema.json in the package root for use in
+ * validating documentation examples and agent integration code.
+ * This script runs during the build process.
+ */
+import { writeFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { extractorResultJsonSchema } from '../result-schema-export.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageRoot = join(__dirname, '..', '..');
+const schemaPath = join(packageRoot, 'error-extractor-result.schema.json');
+// Generate and write schema file
+writeFileSync(schemaPath, JSON.stringify(extractorResultJsonSchema, null, 2), 'utf-8');
+console.log('✓ Generated error-extractor-result.schema.json');
+//# sourceMappingURL=generate-result-schema.js.map

package/dist/scripts/generate-result-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-result-schema.js","sourceRoot":"","sources":["../../src/scripts/generate-result-schema.ts"],"names":[],"mappings":";AACA;;;;;;GAMG;AAEH,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AACzC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAEvE,MAAM,UAAU,GAAG,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAClD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;AACtC,MAAM,WAAW,GAAG,IAAI,CAAC,SAAS,EAAE,IAAI,EAAE,IAAI,CAAC,CAAC;AAChD,MAAM,UAAU,GAAG,IAAI,CAAC,WAAW,EAAE,oCAAoC,CAAC,CAAC;AAE3E,iCAAiC;AACjC,aAAa,CACX,UAAU,EACV,IAAI,CAAC,SAAS,CAAC,yBAAyB,EAAE,IAAI,EAAE,CAAC,CAAC,EAClD,OAAO,CACR,CAAC;AAEF,OAAO,CAAC,GAAG,CAAC,gDAAgD,CAAC,CAAC"}

package/dist/smart-extractor.d.ts

@@ -5,11 +5,11 @@
  *
  * @package @vibe-validate/extractors
  */
-import type { ErrorExtractorResult } from './types.js';
+import type { ErrorExtractorResult, ExtractorInput } from './types.js';
 /**
  * Auto-detect tool type from output patterns and extract errors
  *
- * Detection is 100% pattern-based - context parameter is NOT used for routing decisions.
+ * Detection is 100% pattern-based from output analysis only.
  * This ensures robust detection regardless of how users name their validation steps.
  *
  * Auto-detection rules (checked in order):
@@ -17,30 +17,27 @@ import type { ErrorExtractorResult } from './types.js';
  * 2. **ESLint**: `✖ X problems` summary or `line:col error/warning` format
  * 3. **JUnit XML**: `<?xml` + `<testsuite>` tags
  * 4. **Jasmine**: `Failures:` header + numbered list (`1) test name`)
- * 5. **Mocha**: `X passing`/`X failing` summary + numbered list
- * 6. **Playwright**: `.spec.ts` files + numbered failures with `›` separator
- * 7. **Jest**: `FAIL`/`PASS`/`●` markers or `Test Suites:` summary
- * 8. **Vitest**: `✓`/`✕` symbols or `Test Files` summary
+ * 5. **Jest**: `●` bullets or `Test Suites:` summary (checked before Mocha)
+ * 6. **Mocha**: `X passing`/`X failing` summary + numbered list
+ * 7. **Playwright**: `.spec.ts` files + numbered failures with `›` separator
+ * 8. **Vitest**: `×`/`❯`/`❌` symbols + `Test Files` summary
  * 9. **Generic**: Fallback for all other formats
  *
- * @param context - Context string (e.g., step name) preserved for generic extractor error messages only
- * @param output - Raw command output (may contain ANSI color codes)
+ * @param input - Raw command output (string) or separated streams (ExtractorInput)
  * @returns Structured error information from appropriate extractor
  *
  * @example
  * ```typescript
- * // TypeScript detection (from "error TS2322:" pattern, not context)
- * const result1 = autoDetectAndExtract('Build', tscOutput);
- * // Uses extractTypeScriptErrors
- *
- * // Jest detection (from "FAIL" markers, not context)
- * const result2 = autoDetectAndExtract('Validation', jestOutput);
- * // Uses extractJestErrors
- *
- * // Vitest detection (from "✓" symbols, not context)
- * const result3 = autoDetectAndExtract('Check', vitestOutput);
- * // Uses extractVitestErrors
+ * // Legacy usage (string)
+ * const result1 = autoDetectAndExtract(tscOutput);
+ *
+ * // New usage (separated streams)
+ * const result2 = autoDetectAndExtract({
+ *   stdout: stdoutString,
+ *   stderr: stderrString,
+ *   combined: combinedString
+ * });
  * ```
  */
-export declare function autoDetectAndExtract(context: string, output: string): ErrorExtractorResult;
+export declare function autoDetectAndExtract(input: string | ExtractorInput): ErrorExtractorResult;
 //# sourceMappingURL=smart-extractor.d.ts.map

package/dist/smart-extractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"smart-extractor.d.ts","sourceRoot":"","sources":["../src/smart-extractor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAC;AAYvD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,oBAAoB,CA+H1F"}
+{"version":3,"file":"smart-extractor.d.ts","sourceRoot":"","sources":["../src/smart-extractor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,oBAAoB,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAYvE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAEH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,GAAG,oBAAoB,CAmKzF"}