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

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;

package/dist/lib/retrospective.js

@@ -124,7 +124,7 @@ export function incrementErrorCount(refDir, id) {
 export function addRetrospectiveEntry(refDir, category, pattern, solution, criticality) {
     const retroFile = getRetrospectiveFilePath(refDir);
     if (!fs.existsSync(retroFile)) {
-        throw new Error("RETROSPECTIVE.md not found");
+        throw new Error("retrospective.md not found");
     }
     const items = loadRetrospective(refDir);
     const nextId = items.length > 0
@@ -180,3 +180,113 @@ export function printRetroAddUsage() {
     console.log(`\n${colors.highlight("Example:")}`);
     console.log(`${colors.muted('taskflow retro add --category "Type Error" --pattern "Cannot find module" --solution "Check import path exists" --criticality "High"')}`);
 }
+// ============================================================================
+// Auto-Update Functions
+// ============================================================================
+/**
+ * Read retrospective file content
+ */
+export function readRetrospectiveBeforeWork(refDir) {
+    const retroFile = getRetrospectiveFilePath(refDir);
+    if (!fs.existsSync(retroFile)) {
+        return "";
+    }
+    return fs.readFileSync(retroFile, "utf-8");
+}
+/**
+ * Extract NEW error patterns from parsed errors
+ * Compares against existing retrospective to avoid duplicates
+ */
+export function extractNewPatterns(errors, refDir) {
+    const existingItems = loadRetrospective(refDir);
+    const newPatterns = [];
+    // Group errors by error code and message pattern
+    const errorGroups = new Map();
+    for (const error of errors) {
+        const key = error.code || error.message.substring(0, 50);
+        if (!errorGroups.has(key)) {
+            errorGroups.set(key, []);
+        }
+        errorGroups.get(key)?.push(error);
+    }
+    // For each group, check if it's a new pattern
+    for (const [, groupErrors] of errorGroups) {
+        const firstError = groupErrors[0];
+        if (!firstError)
+            continue;
+        // Create pattern from error message
+        const pattern = firstError.code || firstError.message;
+        // Check if this pattern already exists in retrospective
+        const alreadyExists = existingItems.some((item) => {
+            try {
+                const itemPattern = item.pattern.replace(/\\\|/g, "|");
+                const regex = new RegExp(itemPattern, "i");
+                return regex.test(pattern);
+            }
+            catch {
+                return item.pattern.toLowerCase().includes(pattern.toLowerCase());
+            }
+        });
+        if (!alreadyExists) {
+            // Determine category from error
+            let category = "Runtime";
+            if (firstError.code?.startsWith("TS")) {
+                category = "Type Error";
+            }
+            else if (firstError.message.includes("eslint") ||
+                firstError.message.includes("lint")) {
+                category = "Lint";
+            }
+            else if (firstError.message.includes("test")) {
+                category = "Test";
+            }
+            // Determine criticality based on severity
+            let criticality = "Medium";
+            if (firstError.severity === "error") {
+                criticality = "High";
+            }
+            else if (firstError.severity === "warning") {
+                criticality = "Low";
+            }
+            newPatterns.push({
+                category,
+                pattern,
+                solution: "Review error message and fix the underlying issue",
+                criticality,
+                errorCode: firstError.code,
+                affectedFiles: groupErrors.map((e) => e.file).filter(Boolean),
+            });
+        }
+    }
+    return newPatterns;
+}
+/**
+ * Append new patterns to retrospective file
+ * Uses existing addRetrospectiveEntry for each pattern
+ */
+export function appendNewPatternsToRetrospective(refDir, patterns) {
+    const addedIds = [];
+    for (const pattern of patterns) {
+        const id = addRetrospectiveEntry(refDir, pattern.category, pattern.pattern, pattern.solution, pattern.criticality);
+        addedIds.push(id);
+    }
+    return addedIds;
+}
+/**
+ * Format a new pattern for display (before adding to retrospective)
+ */
+export function formatNewPatternForDisplay(pattern) {
+    const lines = [];
+    lines.push(`${colors.highlight("New Error Pattern Detected:")}`);
+    lines.push(`  Category: ${colors.muted(pattern.category)}`);
+    lines.push(`  Pattern: ${colors.warning(pattern.pattern)}`);
+    if (pattern.errorCode) {
+        lines.push(`  Code: ${colors.error(pattern.errorCode)}`);
+    }
+    lines.push(`  Suggested Solution: ${colors.success(pattern.solution)}`);
+    lines.push(`  Criticality: ${colors.state(pattern.criticality)}`);
+    if (pattern.affectedFiles.length > 0) {
+        lines.push(`  Affected Files: ${colors.muted(pattern.affectedFiles.slice(0, 3).join(", "))}${pattern.affectedFiles.length > 3 ? "..." : ""}`);
+    }
+    return lines.join("\n");
+}

package/dist/lib/types.d.ts

@@ -10,6 +10,7 @@ import { z } from "zod";
 export declare const TaskStatusSchema: z.ZodEnum<{
     "not-started": "not-started";
     setup: "setup";
+    planning: "planning";
     implementing: "implementing";
     verifying: "verifying";
     validating: "validating";
@@ -20,7 +21,7 @@ export declare const TaskStatusSchema: z.ZodEnum<{
 }>;
 export type TaskStatus = z.infer<typeof TaskStatusSchema>;
 /** Status values that indicate a task is actively being worked on */
-export declare const ACTIVE_STATUSES: readonly ["setup", "implementing", "verifying", "validating", "committing"];
+export declare const ACTIVE_STATUSES: readonly ["setup", "planning", "implementing", "verifying", "validating", "committing"];
 export type ActiveStatus = (typeof ACTIVE_STATUSES)[number];
 /** Check if a status is an active (in-progress) status */
 export declare function isActiveStatus(status: string): status is ActiveStatus;
@@ -84,6 +85,7 @@ export declare const TaskFileContentSchema: z.ZodObject<{
     status: z.ZodEnum<{
         "not-started": "not-started";
         setup: "setup";
+        planning: "planning";
         implementing: "implementing";
         verifying: "verifying";
         validating: "validating";
@@ -113,6 +115,7 @@ export declare const TaskFileContentSchema: z.ZodObject<{
     previousStatus: z.ZodOptional<z.ZodEnum<{
         "not-started": "not-started";
         setup: "setup";
+        planning: "planning";
         implementing: "implementing";
         verifying: "verifying";
         validating: "validating";
@@ -149,6 +152,7 @@ export declare const TaskRefSchema: z.ZodObject<{
     status: z.ZodEnum<{
         "not-started": "not-started";
         setup: "setup";
+        planning: "planning";
         implementing: "implementing";
         verifying: "verifying";
         validating: "validating";
@@ -176,6 +180,7 @@ export declare const StorySchema: z.ZodObject<{
         status: z.ZodEnum<{
             "not-started": "not-started";
             setup: "setup";
+            planning: "planning";
             implementing: "implementing";
             verifying: "verifying";
             validating: "validating";
@@ -215,6 +220,7 @@ export declare const FeatureSchema: z.ZodObject<{
             status: z.ZodEnum<{
                 "not-started": "not-started";
                 setup: "setup";
+                planning: "planning";
                 implementing: "implementing";
                 verifying: "verifying";
                 validating: "validating";
@@ -274,6 +280,18 @@ export declare const TaskflowConfigSchema: z.ZodObject<{
     validation: z.ZodOptional<z.ZodObject<{
         commands: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     }, z.core.$strip>>;
+    ai: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        provider: z.ZodOptional<z.ZodString>;
+        models: z.ZodOptional<z.ZodObject<{
+            planning: z.ZodOptional<z.ZodString>;
+            execution: z.ZodOptional<z.ZodString>;
+            analysis: z.ZodOptional<z.ZodString>;
+            default: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        autoContinueTask: z.ZodDefault<z.ZodBoolean>;
+        clearContextOnComplete: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type TaskflowConfig = z.infer<typeof TaskflowConfigSchema>;
 export interface TasksProgress {
@@ -319,11 +337,6 @@ export interface RetrospectiveItem {
     count: number;
     criticality: string;
 }
-export interface CommandResult {
-    success: boolean;
-    message?: string;
-    data?: unknown;
-}
 export interface ValidationResult {
     command: string;
     label: string;

package/dist/lib/types.js

@@ -13,6 +13,7 @@ import { z } from "zod";
 export const TaskStatusSchema = z.enum([
     "not-started",
     "setup",
+    "planning",
     "implementing",
     "verifying",
     "validating",
@@ -24,6 +25,7 @@ export const TaskStatusSchema = z.enum([
 /** Status values that indicate a task is actively being worked on */
 export const ACTIVE_STATUSES = [
     "setup",
+    "planning",
     "implementing",
     "verifying",
     "validating",
@@ -35,7 +37,8 @@ export function isActiveStatus(status) {
 }
 /** Status transitions for workflow progression */
 export const STATUS_TRANSITIONS = {
-    setup: "implementing",
+    setup: "planning",
+    planning: "implementing",
     implementing: "verifying",
     verifying: "validating",
     validating: "committing",
@@ -149,6 +152,22 @@ export const TaskflowConfigSchema = z.object({
         commands: z.record(z.string(), z.string()).optional(),
     })
         .optional(),
+    ai: z
+        .object({
+        enabled: z.boolean().default(false),
+        provider: z.string().optional(),
+        models: z
+            .object({
+            planning: z.string().optional(),
+            execution: z.string().optional(),
+            analysis: z.string().optional(),
+            default: z.string().optional(),
+        })
+            .optional(),
+        autoContinueTask: z.boolean().default(false),
+        clearContextOnComplete: z.boolean().default(true),
+    })
+        .optional(),
 });
 // ============================================================================
 // Retrospective Types

package/dist/lib/validation.d.ts

@@ -27,6 +27,3 @@ export interface ValidationSummary {
 }
 export declare function runValidations(logsDir: string, taskId: string, commands?: Record<string, string>): ValidationSummary;
 export declare function assertValidationPassed(summary: ValidationSummary, logsDir: string): void;
-export declare function quickTypeCheck(): boolean;
-export declare function quickLintCheck(cwd?: string): boolean;
-export declare function quickAllChecks(cwd?: string): boolean;

package/dist/lib/validation.js

@@ -3,7 +3,7 @@
  */
 import fs from "node:fs";
 import { execaSync } from "execa";
-import { getLogFilePath, MAX_OUTPUT_BUFFER, } from "./config-paths.js";
+import { getLogFilePath, MAX_OUTPUT_BUFFER } from "./config-paths.js";
 import { saveLogFile } from "./data-access.js";
 import { ValidationFailedError } from "./errors.js";
 import { colors, extractErrorSummary } from "./output.js";
@@ -149,17 +149,3 @@ export function assertValidationPassed(summary, logsDir) {
     }
 }
 // ============================================================================
-// Quick Checks (without logging)
-// ============================================================================
-export function quickTypeCheck() {
-    // Without configuration, we cannot perform quick checks
-    return true;
-}
-export function quickLintCheck(cwd = process.cwd()) {
-    // Without configuration, we cannot perform quick checks
-    return true;
-}
-export function quickAllChecks(cwd = process.cwd()) {
-    // Without configuration, we cannot perform quick checks
-    return true;
-}

package/dist/llm/base.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Base LLM Provider interface
+ * All LLM providers must implement this interface
+ */
+export interface LLMMessage {
+    role: "system" | "user" | "assistant";
+    content: string;
+}
+export interface LLMGenerationOptions {
+    maxTokens?: number;
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+}
+export interface LLMGenerationResult {
+    content: string;
+    model: string;
+    tokensUsed?: number;
+    finishReason?: string;
+}
+export declare enum LLMProviderType {
+    OpenAICompatible = "openai-compatible",
+    Anthropic = "anthropic",
+    Ollama = "ollama"
+}
+export declare enum Phase {
+    Planning = "planning",
+    Execution = "execution",
+    Analysis = "analysis"
+}
+/**
+ * LLM Provider interface
+ * Defines the contract for all LLM provider implementations
+ */
+export declare abstract class LLMProvider {
+    readonly type: LLMProviderType;
+    readonly model: string;
+    constructor(type: LLMProviderType, model: string);
+    /**
+     * Generate text from the LLM
+     */
+    abstract generate(messages: LLMMessage[], options?: LLMGenerationOptions): Promise<LLMGenerationResult>;
+    /**
+     * Check if the provider is properly configured
+     */
+    abstract isConfigured(): boolean;
+    /**
+     * Get the model name for the specified phase
+     * Override if provider has phase-specific models
+     */
+    getModelForPhase(_phase: Phase): string;
+}

package/dist/llm/base.js

@@ -0,0 +1,35 @@
+/**
+ * Base LLM Provider interface
+ * All LLM providers must implement this interface
+ */
+export var LLMProviderType;
+(function (LLMProviderType) {
+    LLMProviderType["OpenAICompatible"] = "openai-compatible";
+    LLMProviderType["Anthropic"] = "anthropic";
+    LLMProviderType["Ollama"] = "ollama";
+})(LLMProviderType || (LLMProviderType = {}));
+export var Phase;
+(function (Phase) {
+    Phase["Planning"] = "planning";
+    Phase["Execution"] = "execution";
+    Phase["Analysis"] = "analysis";
+})(Phase || (Phase = {}));
+/**
+ * LLM Provider interface
+ * Defines the contract for all LLM provider implementations
+ */
+export class LLMProvider {
+    type;
+    model;
+    constructor(type, model) {
+        this.type = type;
+        this.model = model;
+    }
+    /**
+     * Get the model name for the specified phase
+     * Override if provider has phase-specific models
+     */
+    getModelForPhase(_phase) {
+        return this.model;
+    }
+}

package/dist/llm/factory.d.ts

@@ -0,0 +1,39 @@
+/**
+ * LLM Provider Factory
+ * Factory for creating LLM providers and model selectors
+ */
+import { type LLMGenerationOptions, type LLMGenerationResult, type LLMMessage, type LLMProvider, LLMProviderType } from "./base.js";
+import { type AIConfig, ModelSelector } from "./model-selector.js";
+export type { LLMMessage, LLMGenerationOptions, LLMGenerationResult };
+export { LLMProvider, LLMProviderType } from "./base.js";
+export { type AIConfig, ModelSelector } from "./model-selector.js";
+export { AnthropicProvider, OllamaProvider, OpenAICompatibleProvider, } from "./providers/index.js";
+/**
+ * Provider factory namespace
+ * Functions for creating LLM providers and model selectors
+ */
+export declare const ProviderFactory: {
+    /**
+     * Create a model selector from configuration
+     */
+    createSelector(config: AIConfig): ModelSelector;
+    /**
+     * Create a single provider (backward compatible)
+     */
+    createProvider(type: LLMProviderType, model: string, apiKey?: string, baseUrl?: string): LLMProvider;
+    /**
+     * Test if a provider is configured and working
+     */
+    testProvider(provider: LLMProvider): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Get available providers
+     */
+    getAvailableProviders(): string[];
+    /**
+     * Get default model for provider
+     */
+    getDefaultModel(providerType: LLMProviderType): string;
+};