@krr2020/taskflow-core 0.1.0-beta.4 → 0.1.0-beta.5

package/dist/lib/file-validator.js

@@ -0,0 +1,291 @@
+/**
+ * File Validator
+ * Validates code files using LLM to provide fix suggestions and guidance
+ */
+import { readFile } from "node:fs/promises";
+/**
+ * File Validator class
+ * Validates code files using LLM for analysis and fix suggestions
+ */
+export class FileValidator {
+    options;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Validate a file
+     */
+    async validate(filePath) {
+        const content = await readFile(filePath, "utf-8");
+        return this.validateContent(filePath, content);
+    }
+    /**
+     * Validate multiple files
+     */
+    async validateFiles(filePaths) {
+        const results = [];
+        for (const filePath of filePaths) {
+            const result = await this.validate(filePath);
+            results.push(result);
+        }
+        return results;
+    }
+    /**
+     * Validate file content
+     */
+    async validateContent(filePath, content) {
+        const provider = this.options.provider;
+        // Create validation prompt
+        const messages = [
+            {
+                role: "user",
+                content: this.createValidationPrompt(filePath, content),
+            },
+        ];
+        try {
+            // Call LLM for validation
+            const response = await provider.generate(messages, {
+                maxTokens: 2000,
+                temperature: 0.3, // Lower temperature for more deterministic results
+            });
+            // Parse LLM response
+            const issues = this.parseValidationResponse(response.content);
+            const suggestions = this.extractSuggestions(issues);
+            // Determine if passed
+            const hasErrors = issues.some((i) => i.severity === "error");
+            const hasWarnings = issues.some((i) => i.severity === "warning");
+            const summary = this.createSummary(issues, filePath);
+            return {
+                file: filePath,
+                passed: !hasErrors && !hasWarnings,
+                issues,
+                suggestions,
+                summary,
+            };
+        }
+        catch (error) {
+            // Fallback to basic validation if LLM fails
+            return this.createFallbackResult(filePath, content, error);
+        }
+    }
+    /**
+     * Create validation prompt
+     */
+    createValidationPrompt(filePath, content) {
+        const fileName = filePath.split("/").pop() || "";
+        const fileExtension = fileName.split(".").pop() || "";
+        const prompt = `Analyze the following ${fileExtension} file and identify any issues:
+
+File: ${fileName}
+Path: ${filePath}
+
+\`\`\`$${fileExtension}
+${this.truncateContent(content)}
+\`\`\`
+
+Please provide:
+1. Any syntax errors or type errors
+2. Any logical errors or bugs
+3. Code quality issues (naming, complexity, etc.)
+4. Security concerns
+5. Performance concerns
+6. Suggested fixes for issues found
+
+Format your response as JSON:
+\`\`\`json
+{
+  "issues": [
+    {
+      "severity": "error" | "warning" | "info",
+      "line": number,
+      "message": string,
+      "code": string,
+      "suggestedFix": string
+    }
+  ],
+  "suggestions": ["string", "string"]
+}
+\`\`\`
+
+If no issues are found, respond with:
+\`\`\`json
+{
+  "issues": [],
+  "suggestions": ["File looks good"]
+}
+\`\`\``;
+        return prompt;
+    }
+    /**
+     * Truncate content to fit within context limits
+     */
+    truncateContent(content, maxLength = 8000) {
+        if (content.length <= maxLength) {
+            return content;
+        }
+        // Return first part with indicator
+        return `${content.substring(0, maxLength)}\n\n... (content truncated)`;
+    }
+    /**
+     * Parse validation response from LLM
+     */
+    parseValidationResponse(response) {
+        try {
+            // Try to extract JSON from response
+            const jsonMatch = response.match(/```json\s*([\s\S]*?)\s*```/);
+            if (jsonMatch?.[1]) {
+                const parsed = JSON.parse(jsonMatch[1]);
+                return parsed.issues ?? [];
+            }
+            // Try to parse entire response as JSON
+            const parsed = JSON.parse(response);
+            return parsed.issues ?? [];
+        }
+        catch {
+            // If parsing fails, return empty issues
+            return [];
+        }
+    }
+    /**
+     * Extract suggestions from issues
+     */
+    extractSuggestions(issues) {
+        const suggestions = [];
+        for (const issue of issues) {
+            if (issue.suggestedFix) {
+                suggestions.push(issue.suggestedFix);
+            }
+        }
+        // Add general suggestions if needed
+        if (issues.length === 0) {
+            suggestions.push("No issues found in the file");
+        }
+        return suggestions;
+    }
+    /**
+     * Create validation summary
+     */
+    createSummary(issues, filePath) {
+        const errorCount = issues.filter((i) => i.severity === "error").length;
+        const warningCount = issues.filter((i) => i.severity === "warning").length;
+        const infoCount = issues.filter((i) => i.severity === "info").length;
+        const fileName = filePath.split("/").pop() || "";
+        if (errorCount === 0 && warningCount === 0 && infoCount === 0) {
+            return `${fileName}: No issues found`;
+        }
+        const parts = [`${fileName}:`];
+        if (errorCount > 0) {
+            parts.push(`${errorCount} error${errorCount > 1 ? "s" : ""}`);
+        }
+        if (warningCount > 0) {
+            parts.push(`${warningCount} warning${warningCount > 1 ? "s" : ""}`);
+        }
+        if (infoCount > 0) {
+            parts.push(`${infoCount} info`);
+        }
+        return parts.join(" ");
+    }
+    /**
+     * Create fallback result when LLM fails
+     */
+    createFallbackResult(filePath, content, error) {
+        const fileName = filePath.split("/").pop() || "";
+        // Basic validation checks
+        const issues = [];
+        if (content.trim().length === 0) {
+            issues.push({
+                severity: "error",
+                message: "File is empty",
+                code: "EMPTY_FILE",
+            });
+        }
+        if (content.length > 100000) {
+            issues.push({
+                severity: "warning",
+                message: "File is very large, may affect validation",
+                code: "LARGE_FILE",
+            });
+        }
+        return {
+            file: filePath,
+            passed: issues.length === 0,
+            issues,
+            suggestions: [
+                `Validation error: ${error.message}`,
+                "AI validation unavailable - showing basic checks only",
+            ],
+            summary: `${fileName}: Basic validation only (${issues.length} issue${issues.length > 1 ? "s" : ""})`,
+        };
+    }
+    /**
+     * Format validation result for display
+     */
+    formatResult(result) {
+        const lines = [];
+        lines.push(`\n${"=".repeat(60)}`);
+        lines.push(`File: ${result.file}`);
+        lines.push(`Status: ${result.passed ? "✓ PASSED" : "✗ FAILED"}`);
+        lines.push("=".repeat(60));
+        lines.push("");
+        if (result.issues.length > 0) {
+            lines.push("Issues:");
+            lines.push("");
+            for (const issue of result.issues.slice(0, this.options.maxIssues || 10)) {
+                const icon = issue.severity === "error"
+                    ? "✗"
+                    : issue.severity === "warning"
+                        ? "⚠"
+                        : "ℹ";
+                lines.push(`  ${icon} ${issue.message}`);
+                if (issue.line) {
+                    lines.push(`    Line: ${issue.line}`);
+                }
+                if (issue.code) {
+                    lines.push(`    Code: ${issue.code}`);
+                }
+                if (issue.suggestedFix) {
+                    lines.push(`    Fix: ${issue.suggestedFix}`);
+                }
+                lines.push("");
+            }
+            if (result.issues.length > (this.options.maxIssues || 10)) {
+                const remaining = result.issues.length - (this.options.maxIssues || 10);
+                lines.push(`  ... and ${remaining} more issue${remaining > 1 ? "s" : ""} (truncated)`);
+                lines.push("");
+            }
+        }
+        if (result.suggestions.length > 0) {
+            lines.push("Suggestions:");
+            lines.push("");
+            for (const suggestion of result.suggestions) {
+                lines.push(`  • ${suggestion}`);
+            }
+            lines.push("");
+        }
+        lines.push(`Summary: ${result.summary}`);
+        lines.push("");
+        return lines.join("\n");
+    }
+    /**
+     * Format multiple validation results
+     */
+    formatResults(results) {
+        const lines = [];
+        lines.push(`\n${"=".repeat(80)}`);
+        lines.push("Validation Report");
+        lines.push("=".repeat(80));
+        const passedCount = results.filter((r) => r.passed).length;
+        const failedCount = results.filter((r) => !r.passed).length;
+        const totalIssues = results.reduce((sum, r) => sum + r.issues.length, 0);
+        lines.push(`Files: ${results.length}`);
+        lines.push(`Passed: ${passedCount}`);
+        lines.push(`Failed: ${failedCount}`);
+        lines.push(`Total Issues: ${totalIssues}`);
+        lines.push("=".repeat(80));
+        lines.push("");
+        for (const result of results) {
+            lines.push(this.formatResult(result));
+        }
+        return lines.join("\n");
+    }
+}

package/dist/lib/log-parser.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Log Parser
+ * Extracts errors and diagnostic information from build/test logs
+ */
+export interface ParsedError {
+    /**
+     * File path (relative or absolute)
+     */
+    file: string;
+    /**
+     * Line number where error occurred
+     */
+    line: number;
+    /**
+     * Column number where error occurred
+     */
+    column: number;
+    /**
+     * Error message
+     */
+    message: string;
+    /**
+     * Error code or type (e.g., TS2322, E404)
+     */
+    code: string;
+    /**
+     * Error severity (error, warning, info)
+     */
+    severity: "error" | "warning" | "info";
+    /**
+     * Context lines around the error
+     */
+    context?: string[];
+    /**
+     * Raw log line
+     */
+    raw: string;
+}
+export interface LogParseResult {
+    /**
+     * Parsed errors
+     */
+    errors: ParsedError[];
+    /**
+     * Warning count
+     */
+    warningCount: number;
+    /**
+     * Error count
+     */
+    errorCount: number;
+    /**
+     * Success indicator (no errors found)
+     */
+    success: boolean;
+}
+/**
+ * Log Parser class
+ * Parses build/test logs to extract errors and diagnostics
+ */
+export declare class LogParser {
+    private patterns;
+    /**
+     * Parse log string
+     */
+    parse(logContent: string): LogParseResult;
+    /**
+     * Parse log file
+     */
+    parseFile(filePath: string): Promise<LogParseResult>;
+    /**
+     * Create error from regex match
+     */
+    private createErrorFromMatch;
+    /**
+     * Group errors by file
+     */
+    groupErrorsByFile(errors: ParsedError[]): Map<string, ParsedError[]>;
+    /**
+     * Filter errors by severity
+     */
+    filterBySeverity(errors: ParsedError[], severity: "error" | "warning" | "info"): ParsedError[];
+    /**
+     * Filter errors by file
+     */
+    filterByFile(errors: ParsedError[], filePattern: string): ParsedError[];
+    /**
+     * Format error for display
+     */
+    formatError(error: ParsedError): string;
+}

package/dist/lib/log-parser.js

@@ -0,0 +1,178 @@
+/**
+ * Log Parser
+ * Extracts errors and diagnostic information from build/test logs
+ */
+import { readFile } from "node:fs/promises";
+/**
+ * Log Parser class
+ * Parses build/test logs to extract errors and diagnostics
+ */
+export class LogParser {
+    patterns = [
+        {
+            name: "TypeScript error",
+            regex: /([^:\n]+?):(\d+):(\d+) - error (TS\d+): (.+)/g,
+            severity: "error",
+        },
+        {
+            name: "TypeScript warning",
+            regex: /([^:\n]+?):(\d+):(\d+) - warning (TS\d+): (.+)/g,
+            severity: "warning",
+        },
+        {
+            name: "ESLint error",
+            regex: /([^:\n]+?):(\d+):(\d+) error (.+)/g,
+            severity: "error",
+        },
+        {
+            name: "ESLint warning",
+            regex: /([^:\n]+?):(\d+):(\d+) warning (.+)/g,
+            severity: "warning",
+        },
+        {
+            name: "Test failure",
+            regex: /FAIL\s+([^\s]+?)(?:\n|$)/g,
+            severity: "error",
+        },
+        {
+            name: "Build error",
+            regex: /error\s+(.+?)(?:\n|$)/g,
+            severity: "error",
+        },
+        {
+            name: "Compilation error",
+            regex: /([^:\n]+?):(\d+): error: (.+)/g,
+            severity: "error",
+        },
+    ];
+    /**
+     * Parse log string
+     */
+    parse(logContent) {
+        const errors = [];
+        for (const pattern of this.patterns) {
+            let match = pattern.regex.exec(logContent);
+            while (match !== null) {
+                const error = this.createErrorFromMatch(match, pattern);
+                if (error) {
+                    errors.push(error);
+                }
+                match = pattern.regex.exec(logContent);
+            }
+        }
+        const errorCount = errors.filter((e) => e.severity === "error").length;
+        const warningCount = errors.filter((e) => e.severity === "warning").length;
+        return {
+            errors,
+            errorCount,
+            warningCount,
+            success: errorCount === 0,
+        };
+    }
+    /**
+     * Parse log file
+     */
+    async parseFile(filePath) {
+        const content = await readFile(filePath, "utf-8");
+        return this.parse(content);
+    }
+    /**
+     * Create error from regex match
+     */
+    createErrorFromMatch(match, pattern) {
+        const raw = match[0];
+        // Try to extract file, line, column, message, code
+        let file = "";
+        let line = 0;
+        let column = 0;
+        let message = raw;
+        let code = "";
+        switch (pattern.name) {
+            case "TypeScript error":
+            case "TypeScript warning":
+                file = match[1] || "";
+                line = Number.parseInt(match[2] || "0", 10);
+                column = Number.parseInt(match[3] || "0", 10);
+                code = match[4]?.split(":")[0] || "";
+                message = match[4] || raw;
+                break;
+            case "ESLint error":
+            case "ESLint warning":
+                file = match[1] || "";
+                line = Number.parseInt(match[2] || "0", 10);
+                column = Number.parseInt(match[3] || "0", 10);
+                message = match[4] || raw;
+                break;
+            case "Test failure":
+                file = match[1] || "";
+                message = `Test failed: ${match[1]}`;
+                break;
+            case "Build error":
+                message = match[1] || raw;
+                break;
+            case "Compilation error":
+                file = match[1] || "";
+                line = Number.parseInt(match[2] || "0", 10);
+                message = match[3] || raw;
+                break;
+            default:
+                message = raw;
+        }
+        return {
+            file,
+            line,
+            column,
+            message,
+            code,
+            severity: pattern.severity,
+            raw,
+        };
+    }
+    /**
+     * Group errors by file
+     */
+    groupErrorsByFile(errors) {
+        const grouped = new Map();
+        for (const error of errors) {
+            if (error.file) {
+                const existing = grouped.get(error.file) || [];
+                existing.push(error);
+                grouped.set(error.file, existing);
+            }
+        }
+        return grouped;
+    }
+    /**
+     * Filter errors by severity
+     */
+    filterBySeverity(errors, severity) {
+        return errors.filter((e) => e.severity === severity);
+    }
+    /**
+     * Filter errors by file
+     */
+    filterByFile(errors, filePattern) {
+        const regex = new RegExp(filePattern);
+        return errors.filter((e) => regex.test(e.file));
+    }
+    /**
+     * Format error for display
+     */
+    formatError(error) {
+        const parts = [];
+        if (error.file) {
+            parts.push(error.file);
+            if (error.line) {
+                parts.push(`:${error.line}`);
+                if (error.column) {
+                    parts.push(`:${error.column}`);
+                }
+            }
+        }
+        if (error.code) {
+            parts.push(`[${error.code}]`);
+        }
+        parts.push(`- ${error.message}`);
+        return parts.join(" ");
+    }
+}

package/dist/lib/retrospective.d.ts

@@ -1,7 +1,16 @@
 /**
  * Retrospective module for error pattern management
  */
+import type { ParsedError } from "./log-parser.js";
 import type { Criticality, ErrorCategory, RetrospectiveItem } from "./types.js";
+export interface NewPattern {
+    category: ErrorCategory | string;
+    pattern: string;
+    solution: string;
+    criticality: Criticality | string;
+    errorCode?: string;
+    affectedFiles: string[];
+}
 export declare function getRetrospectiveFilePath(refDir: string): string;
 export declare function loadRetrospective(refDir: string): RetrospectiveItem[];
 export declare function parseRetrospectiveContent(content: string): RetrospectiveItem[];
@@ -23,3 +32,21 @@ export declare const VALID_CRITICALITIES: Criticality[];
 export declare function isValidCategory(category: string): category is ErrorCategory;
 export declare function isValidCriticality(criticality: string): criticality is Criticality;
 export declare function printRetroAddUsage(): void;
+/**
+ * Read retrospective file content
+ */
+export declare function readRetrospectiveBeforeWork(refDir: string): string;
+/**
+ * Extract NEW error patterns from parsed errors
+ * Compares against existing retrospective to avoid duplicates
+ */
+export declare function extractNewPatterns(errors: ParsedError[], refDir: string): NewPattern[];
+/**
+ * Append new patterns to retrospective file
+ * Uses existing addRetrospectiveEntry for each pattern
+ */
+export declare function appendNewPatternsToRetrospective(refDir: string, patterns: NewPattern[]): number[];
+/**
+ * Format a new pattern for display (before adding to retrospective)
+ */
+export declare function formatNewPatternForDisplay(pattern: NewPattern): string;