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

package/dist/lib/retrospective.js

@@ -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

@@ -281,6 +281,14 @@ export declare const TaskflowConfigSchema: 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>>;

package/dist/lib/types.js

@@ -154,14 +154,18 @@ export const TaskflowConfigSchema = z.object({
         .optional(),
     ai: z
         .object({
-        autoContinueTask: z
-            .boolean()
-            .default(false)
-            .describe("Automatically continue to next task without user confirmation"),
-        clearContextOnComplete: z
-            .boolean()
-            .default(true)
-            .describe("Clear AI model context after task completion"),
+        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(),
 });

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;
+};

package/dist/llm/factory.js

@@ -0,0 +1,102 @@
+/**
+ * LLM Provider Factory
+ * Factory for creating LLM providers and model selectors
+ */
+import { LLMProviderType, } from "./base.js";
+import { ModelSelector } from "./model-selector.js";
+import { AnthropicProvider } from "./providers/anthropic.js";
+import { OllamaProvider } from "./providers/ollama.js";
+import { OpenAICompatibleProvider } from "./providers/openai-compatible.js";
+export { LLMProvider, LLMProviderType } from "./base.js";
+export { 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 const ProviderFactory = {
+    /**
+     * Create a model selector from configuration
+     */
+    createSelector(config) {
+        return new ModelSelector(config);
+    },
+    /**
+     * Create a single provider (backward compatible)
+     */
+    createProvider(type, model, apiKey, baseUrl) {
+        switch (type) {
+            case LLMProviderType.OpenAICompatible: {
+                const config = { model };
+                if (apiKey)
+                    config.apiKey = apiKey;
+                if (baseUrl)
+                    config.baseUrl = baseUrl;
+                return OpenAICompatibleProvider.fromEnv(config);
+            }
+            case LLMProviderType.Anthropic: {
+                const config = { model };
+                if (apiKey)
+                    config.apiKey = apiKey;
+                return AnthropicProvider.fromEnv(config);
+            }
+            case LLMProviderType.Ollama: {
+                const config = { model };
+                if (baseUrl)
+                    config.baseUrl = baseUrl;
+                return OllamaProvider.fromEnv(config);
+            }
+            default:
+                throw new Error(`Unknown provider type: ${type}`);
+        }
+    },
+    /**
+     * Test if a provider is configured and working
+     */
+    async testProvider(provider) {
+        try {
+            if (!provider.isConfigured()) {
+                return { success: false, error: "Provider not configured" };
+            }
+            // Simple test request
+            await provider.generate([
+                {
+                    role: "user",
+                    content: "Hello, please respond with just 'OK'.",
+                },
+            ], { maxTokens: 10 });
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    },
+    /**
+     * Get available providers
+     */
+    getAvailableProviders() {
+        return [
+            LLMProviderType.OpenAICompatible,
+            LLMProviderType.Anthropic,
+            LLMProviderType.Ollama,
+        ];
+    },
+    /**
+     * Get default model for provider
+     */
+    getDefaultModel(providerType) {
+        switch (providerType) {
+            case LLMProviderType.OpenAICompatible:
+                return "gpt-4o-mini";
+            case LLMProviderType.Anthropic:
+                return "claude-3-5-sonnet-20241022";
+            case LLMProviderType.Ollama:
+                return "llama2";
+            default:
+                throw new Error(`Unknown provider type: ${providerType}`);
+        }
+    },
+};

package/dist/llm/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * LLM package exports
+ */
+export * from "./base.js";
+export * from "./factory.js";
+export * from "./model-selector.js";
+export * from "./providers/index.js";

package/dist/llm/index.js

@@ -0,0 +1,7 @@
+/**
+ * LLM package exports
+ */
+export * from "./base.js";
+export * from "./factory.js";
+export * from "./model-selector.js";
+export * from "./providers/index.js";

package/dist/llm/model-selector.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Model Selector
+ * Selects the appropriate model for each phase (planning, execution, analysis)
+ */
+import { type LLMProvider, LLMProviderType, Phase } from "./base.js";
+export interface ModelSelection {
+    planning: LLMProvider;
+    execution: LLMProvider;
+    analysis: LLMProvider;
+}
+export interface AIConfig {
+    enabled: boolean;
+    provider: LLMProviderType;
+    apiKey?: string;
+    models: {
+        default: string;
+        planning?: string;
+        execution?: string;
+        analysis?: string;
+    };
+    planningProvider?: LLMProviderType;
+    planningApiKey?: string;
+    executionProvider?: LLMProviderType;
+    executionApiKey?: string;
+    analysisProvider?: LLMProviderType;
+    analysisApiKey?: string;
+    ollamaBaseUrl?: string;
+    openaiBaseUrl?: string;
+}
+/**
+ * Model Selector class
+ * Manages per-phase model selection and provider instantiation
+ */
+export declare class ModelSelector {
+    private selection;
+    private modelNames;
+    constructor(config: AIConfig);
+    /**
+     * Get the provider for a specific phase
+     */
+    getProvider(phase: Phase): LLMProvider;
+    /**
+     * Get the model name for a specific phase
+     */
+    getModelName(phase: Phase): string;
+    /**
+     * Check if any provider is configured
+     */
+    isConfigured(): boolean;
+    /**
+     * Create provider from configuration
+     */
+    private createProvider;
+    /**
+     * Create model selection from configuration
+     */
+    private createSelection;
+    /**
+     * Get base URL for provider
+     */
+    private getBaseUrlForProvider;
+    /**
+     * Create ModelSelector from minimal config (backward compatible)
+     */
+    static fromSimpleConfig(config: {
+        enabled: boolean;
+        provider: LLMProviderType;
+        apiKey?: string;
+        model?: string;
+    }): ModelSelector;
+}

package/dist/llm/model-selector.js

@@ -0,0 +1,139 @@
+/**
+ * Model Selector
+ * Selects the appropriate model for each phase (planning, execution, analysis)
+ */
+import { LLMProviderType, Phase } from "./base.js";
+import { AnthropicProvider } from "./providers/anthropic.js";
+import { OllamaProvider } from "./providers/ollama.js";
+import { OpenAICompatibleProvider } from "./providers/openai-compatible.js";
+/**
+ * Model Selector class
+ * Manages per-phase model selection and provider instantiation
+ */
+export class ModelSelector {
+    selection;
+    modelNames;
+    constructor(config) {
+        this.selection = this.createSelection(config);
+        this.modelNames = {
+            planning: config.models.planning || config.models.default,
+            execution: config.models.execution || config.models.default,
+            analysis: config.models.analysis || config.models.default,
+        };
+    }
+    /**
+     * Get the provider for a specific phase
+     */
+    getProvider(phase) {
+        switch (phase) {
+            case Phase.Planning:
+                return this.selection.planning;
+            case Phase.Execution:
+                return this.selection.execution;
+            case Phase.Analysis:
+                return this.selection.analysis;
+            default:
+                return this.selection.planning;
+        }
+    }
+    /**
+     * Get the model name for a specific phase
+     */
+    getModelName(phase) {
+        switch (phase) {
+            case Phase.Planning:
+                return this.modelNames.planning;
+            case Phase.Execution:
+                return this.modelNames.execution;
+            case Phase.Analysis:
+                return this.modelNames.analysis;
+            default:
+                return this.modelNames.planning;
+        }
+    }
+    /**
+     * Check if any provider is configured
+     */
+    isConfigured() {
+        return (this.selection.planning.isConfigured() ||
+            this.selection.execution.isConfigured() ||
+            this.selection.analysis.isConfigured());
+    }
+    /**
+     * Create provider from configuration
+     */
+    createProvider(providerType, model, apiKey, baseUrl) {
+        switch (providerType) {
+            case LLMProviderType.OpenAICompatible: {
+                const config = { model };
+                if (apiKey)
+                    config.apiKey = apiKey;
+                if (baseUrl)
+                    config.baseUrl = baseUrl;
+                return OpenAICompatibleProvider.fromEnv(config);
+            }
+            case LLMProviderType.Anthropic: {
+                const config = { model };
+                if (apiKey)
+                    config.apiKey = apiKey;
+                return AnthropicProvider.fromEnv(config);
+            }
+            case LLMProviderType.Ollama: {
+                const config = { model };
+                if (baseUrl)
+                    config.baseUrl = baseUrl;
+                return OllamaProvider.fromEnv(config);
+            }
+            default:
+                throw new Error(`Unknown provider type: ${providerType}`);
+        }
+    }
+    /**
+     * Create model selection from configuration
+     */
+    createSelection(config) {
+        const defaultProvider = this.createProvider(config.provider, config.models.default, config.apiKey, this.getBaseUrlForProvider(config, config.provider));
+        // Planning provider
+        const planningProvider = config.planningProvider
+            ? this.createProvider(config.planningProvider, config.models.planning || config.models.default, config.planningApiKey, this.getBaseUrlForProvider(config, config.planningProvider))
+            : defaultProvider;
+        // Execution provider
+        const executionProvider = config.executionProvider
+            ? this.createProvider(config.executionProvider, config.models.execution || config.models.default, config.executionApiKey, this.getBaseUrlForProvider(config, config.executionProvider))
+            : defaultProvider;
+        // Analysis provider
+        const analysisProvider = config.analysisProvider
+            ? this.createProvider(config.analysisProvider, config.models.analysis || config.models.default, config.analysisApiKey, this.getBaseUrlForProvider(config, config.analysisProvider))
+            : defaultProvider;
+        return {
+            planning: planningProvider,
+            execution: executionProvider,
+            analysis: analysisProvider,
+        };
+    }
+    /**
+     * Get base URL for provider
+     */
+    getBaseUrlForProvider(config, providerType) {
+        if (providerType === LLMProviderType.Ollama) {
+            return config.ollamaBaseUrl;
+        }
+        if (providerType === LLMProviderType.OpenAICompatible) {
+            return config.openaiBaseUrl;
+        }
+        return undefined;
+    }
+    /**
+     * Create ModelSelector from minimal config (backward compatible)
+     */
+    static fromSimpleConfig(config) {
+        return new ModelSelector({
+            enabled: config.enabled,
+            provider: config.provider,
+            apiKey: config.apiKey ?? "",
+            models: {
+                default: config.model || "gpt-4o-mini",
+            },
+        });
+    }
+}

package/dist/llm/providers/anthropic.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Anthropic Claude LLM Provider
+ * Supports Claude models via Anthropic API
+ */
+import { type LLMGenerationOptions, type LLMGenerationResult, type LLMMessage, LLMProvider } from "../base.js";
+export interface AnthropicConfig {
+    apiKey: string;
+    model: string;
+    maxTokens?: number;
+}
+export declare class AnthropicProvider extends LLMProvider {
+    private config;
+    private readonly DEFAULT_MAX_TOKENS;
+    constructor(config: AnthropicConfig);
+    /**
+     * Generate text using Anthropic Claude API
+     */
+    generate(messages: LLMMessage[], options?: LLMGenerationOptions): Promise<LLMGenerationResult>;
+    /**
+     * Check if provider is configured
+     */
+    isConfigured(): boolean;
+    /**
+     * Create provider from environment variables
+     */
+    static fromEnv(config: {
+        apiKey?: string;
+        model?: string;
+        maxTokens?: number;
+    }): AnthropicProvider;
+}