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

package/dist/llm/providers/anthropic.js

@@ -0,0 +1,116 @@
+/**
+ * Anthropic Claude LLM Provider
+ * Supports Claude models via Anthropic API
+ */
+import { LLMProvider, LLMProviderType, } from "../base.js";
+export class AnthropicProvider extends LLMProvider {
+    config;
+    DEFAULT_MAX_TOKENS = 4096;
+    constructor(config) {
+        super(LLMProviderType.Anthropic, config.model);
+        this.config = config;
+        this.config.maxTokens = config.maxTokens || this.DEFAULT_MAX_TOKENS;
+    }
+    /**
+     * Generate text using Anthropic Claude API
+     */
+    async generate(messages, options) {
+        if (!this.isConfigured()) {
+            throw new Error("Anthropic provider is not configured properly");
+        }
+        // Extract system message (Anthropic separates system message)
+        let systemMessage = "";
+        const apiMessages = [];
+        for (const msg of messages) {
+            if (msg.role === "system") {
+                systemMessage = msg.content;
+            }
+            else {
+                apiMessages.push(msg);
+            }
+        }
+        const requestBody = {
+            model: this.config.model,
+            messages: apiMessages,
+            max_tokens: options?.maxTokens || this.config.maxTokens,
+            stream: false,
+        };
+        if (systemMessage) {
+            requestBody.system = systemMessage;
+        }
+        if (options?.temperature !== undefined) {
+            requestBody.temperature = options.temperature;
+        }
+        if (options?.topP !== undefined) {
+            requestBody.top_p = options.topP;
+        }
+        if (options?.topK !== undefined) {
+            requestBody.top_k = options.topK;
+        }
+        const response = await fetch("https://api.anthropic.com/v1/messages", {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-api-key": this.config.apiKey,
+                "anthropic-version": "2023-06-01",
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Anthropic API error: ${response.status} - ${error}`);
+        }
+        const data = (await response.json());
+        const contentItem = data.content[0];
+        if (!contentItem) {
+            throw new Error("No content returned from Anthropic API");
+        }
+        return {
+            content: contentItem.text,
+            model: data.model,
+            tokensUsed: (data.usage?.input_tokens ?? 0) + (data.usage?.output_tokens ?? 0),
+            finishReason: data.stop_reason,
+        };
+    }
+    /**
+     * Check if provider is configured
+     */
+    isConfigured() {
+        return !!this.config.apiKey;
+    }
+    /**
+     * Create provider from environment variables
+     */
+    static fromEnv(config) {
+        const apiKey = config.apiKey || process.env.ANTHROPIC_API_KEY || "";
+        const model = config.model ||
+            process.env.ANTHROPIC_MODEL ||
+            "claude-3-5-sonnet-20241022";
+        const maxTokensValue = config.maxTokens ||
+            Number.parseInt(process.env.ANTHROPIC_MAX_TOKENS || "4096", 10);
+        if (!apiKey) {
+            console.warn("Warning: Anthropic provider missing API key");
+        }
+        const maxTokens = Number.isNaN(maxTokensValue) ? undefined : maxTokensValue;
+        return new AnthropicProvider({
+            apiKey: expandEnvVar(apiKey),
+            model,
+            maxTokens: maxTokens ?? 4096,
+        });
+    }
+}
+/**
+ * Expand environment variable in string (e.g., "${VAR_NAME}" -> actual value)
+ */
+function expandEnvVar(value) {
+    if (!value) {
+        return value;
+    }
+    const envVarMatch = value.match(/^\$\{([^}]+)\}$/);
+    if (envVarMatch?.[1]) {
+        const envVar = envVarMatch[1];
+        const envValue = process.env[envVar];
+        return envValue ?? value;
+    }
+    return value;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Provider exports
+ */
+export { type AnthropicConfig, AnthropicProvider } from "./anthropic.js";
+export { type OllamaConfig, OllamaProvider } from "./ollama.js";
+export { type OpenAICompatibleConfig, OpenAICompatibleProvider, } from "./openai-compatible.js";

package/dist/llm/providers/index.js

@@ -0,0 +1,6 @@
+/**
+ * Provider exports
+ */
+export { AnthropicProvider } from "./anthropic.js";
+export { OllamaProvider } from "./ollama.js";
+export { OpenAICompatibleProvider, } from "./openai-compatible.js";

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

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

package/dist/llm/providers/ollama.js

@@ -0,0 +1,91 @@
+/**
+ * Ollama LLM Provider
+ * Supports local LLM models via Ollama API
+ */
+import { LLMProvider, LLMProviderType, } from "../base.js";
+export class OllamaProvider extends LLMProvider {
+    config;
+    constructor(config) {
+        super(LLMProviderType.Ollama, config.model);
+        this.config = config;
+    }
+    /**
+     * Generate text using Ollama API
+     */
+    async generate(messages, options) {
+        if (!this.isConfigured()) {
+            throw new Error("Ollama provider is not configured properly");
+        }
+        // Convert messages to Ollama format
+        const prompt = messages
+            .map((msg) => `${msg.role}: ${msg.content}`)
+            .join("\n\n");
+        const requestBody = {
+            model: this.config.model,
+            prompt,
+            stream: false,
+        };
+        if (options?.temperature !== undefined) {
+            requestBody.temperature = options.temperature;
+        }
+        if (options?.topP !== undefined) {
+            requestBody.top_p = options.topP;
+        }
+        if (options?.topK !== undefined) {
+            requestBody.top_k = options.topK;
+        }
+        if (options?.maxTokens) {
+            requestBody.num_predict = options.maxTokens;
+        }
+        const response = await fetch(`${this.config.baseUrl}/api/generate`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+            },
+            body: JSON.stringify(requestBody),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Ollama API error: ${response.status} - ${error}`);
+        }
+        const data = (await response.json());
+        return {
+            content: data.response,
+            model: data.model,
+            tokensUsed: data.eval_count,
+            finishReason: data.done ? "stop" : "length",
+        };
+    }
+    /**
+     * Check if provider is configured
+     */
+    isConfigured() {
+        return !!(this.config.baseUrl && this.config.model);
+    }
+    /**
+     * Create provider from environment variables
+     */
+    static fromEnv(config) {
+        const baseUrl = config.baseUrl || process.env.OLLAMA_BASE_URL || "http://localhost:11434";
+        const model = config.model || process.env.OLLAMA_MODEL || "llama2";
+        return new OllamaProvider({
+            baseUrl: expandEnvVar(baseUrl),
+            model: expandEnvVar(model),
+        });
+    }
+}
+/**
+ * Expand environment variable in string (e.g., "${VAR_NAME}" -> actual value)
+ */
+function expandEnvVar(value) {
+    if (!value) {
+        return value;
+    }
+    const envVarMatch = value.match(/^\$\{([^}]+)\}$/);
+    if (envVarMatch?.[1]) {
+        const envVar = envVarMatch[1];
+        const envValue = process.env[envVar];
+        return envValue ?? value;
+    }
+    return value;
+}

package/dist/llm/providers/openai-compatible.d.ts

@@ -0,0 +1,30 @@
+/**
+ * OpenAI-compatible LLM Provider
+ * Supports: OpenAI, Azure OpenAI, Together AI, Groq, DeepSeek, and any OpenAI-compatible API
+ */
+import { type LLMGenerationOptions, type LLMGenerationResult, type LLMMessage, LLMProvider } from "../base.js";
+export interface OpenAICompatibleConfig {
+    baseUrl: string;
+    apiKey: string;
+    model: string;
+}
+export declare class OpenAICompatibleProvider extends LLMProvider {
+    private config;
+    constructor(config: OpenAICompatibleConfig);
+    /**
+     * Generate text using OpenAI-compatible API
+     */
+    generate(messages: LLMMessage[], options?: LLMGenerationOptions): Promise<LLMGenerationResult>;
+    /**
+     * Check if provider is configured
+     */
+    isConfigured(): boolean;
+    /**
+     * Create provider from environment variables
+     */
+    static fromEnv(config: {
+        baseUrl?: string;
+        apiKey?: string;
+        model?: string;
+    }): OpenAICompatibleProvider;
+}

package/dist/llm/providers/openai-compatible.js

@@ -0,0 +1,93 @@
+/**
+ * OpenAI-compatible LLM Provider
+ * Supports: OpenAI, Azure OpenAI, Together AI, Groq, DeepSeek, and any OpenAI-compatible API
+ */
+import { LLMProvider, LLMProviderType, } from "../base.js";
+export class OpenAICompatibleProvider extends LLMProvider {
+    config;
+    constructor(config) {
+        super(LLMProviderType.OpenAICompatible, config.model);
+        this.config = config;
+    }
+    /**
+     * Generate text using OpenAI-compatible API
+     */
+    async generate(messages, options) {
+        if (!this.isConfigured()) {
+            throw new Error("OpenAI-compatible provider is not configured properly");
+        }
+        const response = await fetch(`${this.config.baseUrl}/chat/completions`, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${this.config.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: this.config.model,
+                messages,
+                max_tokens: options?.maxTokens,
+                temperature: options?.temperature,
+                top_p: options?.topP,
+                stream: false,
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`OpenAI-compatible API error: ${response.status} - ${error}`);
+        }
+        const data = (await response.json());
+        const choice = data.choices[0];
+        if (!choice) {
+            throw new Error("No choice returned from OpenAI API");
+        }
+        return {
+            content: choice.message.content,
+            model: data.model,
+            tokensUsed: data.usage?.total_tokens ?? 0,
+            finishReason: choice.finish_reason,
+        };
+    }
+    /**
+     * Check if provider is configured
+     */
+    isConfigured() {
+        return !!(this.config.apiKey && this.config.baseUrl);
+    }
+    /**
+     * Create provider from environment variables
+     */
+    static fromEnv(config) {
+        const baseUrl = config.baseUrl ||
+            process.env.OPENAI_BASE_URL ||
+            process.env.AI_BASE_URL ||
+            "https://api.openai.com/v1";
+        const apiKey = config.apiKey ||
+            process.env.OPENAI_API_KEY ||
+            process.env.AI_API_KEY ||
+            "";
+        const model = config.model || process.env.AI_MODEL || "gpt-4o-mini";
+        if (!apiKey) {
+            console.warn("Warning: OpenAI-compatible provider missing API key");
+        }
+        return new OpenAICompatibleProvider({
+            baseUrl,
+            apiKey: expandEnvVar(apiKey),
+            model,
+        });
+    }
+}
+/**
+ * Expand environment variable in string (e.g., "${VAR_NAME}" -> actual value)
+ */
+function expandEnvVar(value) {
+    if (!value) {
+        return value;
+    }
+    const envVarMatch = value.match(/^\$\{([^}]+)\}$/);
+    if (envVarMatch?.[1]) {
+        const envVar = envVarMatch[1];
+        const envValue = process.env[envVar];
+        return envValue ?? value;
+    }
+    return value;
+}

package/dist/schemas/config.d.ts

@@ -14,6 +14,48 @@ export declare const GatesSchema: z.ZodObject<{
     requirePlanApproval: z.ZodDefault<z.ZodBoolean>;
     requireTestPass: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
+declare const LLMProviderTypeSchema: z.ZodEnum<{
+    "openai-compatible": "openai-compatible";
+    anthropic: "anthropic";
+    ollama: "ollama";
+}>;
+declare const AIConfigSchema: z.ZodOptional<z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    provider: z.ZodDefault<z.ZodEnum<{
+        "openai-compatible": "openai-compatible";
+        anthropic: "anthropic";
+        ollama: "ollama";
+    }>>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    models: z.ZodDefault<z.ZodObject<{
+        default: z.ZodDefault<z.ZodString>;
+        planning: z.ZodOptional<z.ZodString>;
+        execution: z.ZodOptional<z.ZodString>;
+        analysis: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    planningProvider: z.ZodOptional<z.ZodEnum<{
+        "openai-compatible": "openai-compatible";
+        anthropic: "anthropic";
+        ollama: "ollama";
+    }>>;
+    planningApiKey: z.ZodOptional<z.ZodString>;
+    executionProvider: z.ZodOptional<z.ZodEnum<{
+        "openai-compatible": "openai-compatible";
+        anthropic: "anthropic";
+        ollama: "ollama";
+    }>>;
+    executionApiKey: z.ZodOptional<z.ZodString>;
+    analysisProvider: z.ZodOptional<z.ZodEnum<{
+        "openai-compatible": "openai-compatible";
+        anthropic: "anthropic";
+        ollama: "ollama";
+    }>>;
+    analysisApiKey: z.ZodOptional<z.ZodString>;
+    ollamaBaseUrl: z.ZodDefault<z.ZodString>;
+    openaiBaseUrl: z.ZodDefault<z.ZodString>;
+    autoContinueTask: z.ZodDefault<z.ZodBoolean>;
+    clearContextOnComplete: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>>;
 export declare const TaskflowConfigSchema: z.ZodObject<{
     version: z.ZodDefault<z.ZodString>;
     projectType: z.ZodDefault<z.ZodString>;
@@ -36,5 +78,45 @@ export declare const TaskflowConfigSchema: z.ZodObject<{
         validate: z.ZodOptional<z.ZodString>;
         test: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    ai: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        provider: z.ZodDefault<z.ZodEnum<{
+            "openai-compatible": "openai-compatible";
+            anthropic: "anthropic";
+            ollama: "ollama";
+        }>>;
+        apiKey: z.ZodOptional<z.ZodString>;
+        models: z.ZodDefault<z.ZodObject<{
+            default: z.ZodDefault<z.ZodString>;
+            planning: z.ZodOptional<z.ZodString>;
+            execution: z.ZodOptional<z.ZodString>;
+            analysis: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        planningProvider: z.ZodOptional<z.ZodEnum<{
+            "openai-compatible": "openai-compatible";
+            anthropic: "anthropic";
+            ollama: "ollama";
+        }>>;
+        planningApiKey: z.ZodOptional<z.ZodString>;
+        executionProvider: z.ZodOptional<z.ZodEnum<{
+            "openai-compatible": "openai-compatible";
+            anthropic: "anthropic";
+            ollama: "ollama";
+        }>>;
+        executionApiKey: z.ZodOptional<z.ZodString>;
+        analysisProvider: z.ZodOptional<z.ZodEnum<{
+            "openai-compatible": "openai-compatible";
+            anthropic: "anthropic";
+            ollama: "ollama";
+        }>>;
+        analysisApiKey: z.ZodOptional<z.ZodString>;
+        ollamaBaseUrl: z.ZodDefault<z.ZodString>;
+        openaiBaseUrl: z.ZodDefault<z.ZodString>;
+        autoContinueTask: z.ZodDefault<z.ZodBoolean>;
+        clearContextOnComplete: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type TaskflowConfig = z.infer<typeof TaskflowConfigSchema>;
+export type AIConfig = z.infer<typeof AIConfigSchema>;
+export type LLMProviderType = z.infer<typeof LLMProviderTypeSchema>;
+export {};

package/dist/schemas/config.js

@@ -12,6 +12,40 @@ export const GatesSchema = z.object({
     requirePlanApproval: z.boolean().default(true),
     requireTestPass: z.boolean().default(true),
 });
+// ============================================================================
+// AI Configuration Schema
+// ============================================================================
+const LLMProviderTypeSchema = z.enum([
+    "openai-compatible",
+    "anthropic",
+    "ollama",
+]);
+const AIModelsSchema = z.object({
+    default: z.string().default("gpt-4o-mini"),
+    planning: z.string().optional(),
+    execution: z.string().optional(),
+    analysis: z.string().optional(),
+});
+const AIConfigSchema = z
+    .object({
+    enabled: z.boolean().default(false),
+    provider: LLMProviderTypeSchema.default("openai-compatible"),
+    apiKey: z.string().optional(),
+    models: AIModelsSchema.default({
+        default: "gpt-4o-mini",
+    }),
+    planningProvider: LLMProviderTypeSchema.optional(),
+    planningApiKey: z.string().optional(),
+    executionProvider: LLMProviderTypeSchema.optional(),
+    executionApiKey: z.string().optional(),
+    analysisProvider: LLMProviderTypeSchema.optional(),
+    analysisApiKey: z.string().optional(),
+    ollamaBaseUrl: z.string().default("http://localhost:11434"),
+    openaiBaseUrl: z.string().default("https://api.openai.com/v1"),
+    autoContinueTask: z.boolean().default(false),
+    clearContextOnComplete: z.boolean().default(true),
+})
+    .optional();
 export const TaskflowConfigSchema = z.object({
     version: z.string().default("2.0"),
     projectType: z.string().default("custom"),
@@ -31,4 +65,5 @@ export const TaskflowConfigSchema = z.object({
         test: z.string().optional(),
     })
         .optional(),
+    ai: AIConfigSchema,
 });

package/package.json

@@ -1,44 +1,44 @@
 {
-  "name": "@krr2020/taskflow-core",
-  "version": "0.1.0-beta.4",
-  "description": "Core logic for Taskflow - AI-first task management and workflow system",
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "type": "module",
-  "bin": {
-    "taskflow": "./bin/taskflow.js"
-  },
-  "files": [
-    "dist",
-    "bin",
-    "templates"
-  ],
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    },
-    "./config": {
-      "import": "./dist/config.js",
-      "types": "./dist/config.d.ts"
-    }
-  },
-  "dependencies": {
-    "zod": "4.3.2",
-    "execa": "9.6.1",
-    "commander": "14.0.2"
-  },
-  "devDependencies": {
-    "typescript": "5.9.3",
-    "vitest": "4.0.16",
-    "@types/node": "25.0.3"
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest"
-  }
-}
+	"name": "@krr2020/taskflow-core",
+	"version": "0.1.0-beta.5",
+	"description": "Core logic for Taskflow - AI-first task management and workflow system",
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public"
+	},
+	"main": "dist/index.js",
+	"types": "dist/index.d.ts",
+	"type": "module",
+	"bin": {
+		"taskflow": "./bin/taskflow.js"
+	},
+	"files": [
+		"dist",
+		"bin",
+		"templates"
+	],
+	"scripts": {
+		"build": "tsc",
+		"test": "vitest"
+	},
+	"exports": {
+		".": {
+			"import": "./dist/index.js",
+			"types": "./dist/index.d.ts"
+		},
+		"./config": {
+			"import": "./dist/config.js",
+			"types": "./dist/config.d.ts"
+		}
+	},
+	"dependencies": {
+		"zod": "4.3.2",
+		"execa": "9.6.1",
+		"commander": "14.0.2"
+	},
+	"devDependencies": {
+		"typescript": "5.9.3",
+		"vitest": "4.0.16",
+		"@types/node": "25.0.3"
+	}
+}

package/dist/lib/package-manager.d.ts

@@ -1,17 +0,0 @@
-export type PackageManager = "npm" | "pnpm" | "yarn" | "bun";
-export interface PackageManagerCommands {
-    run: string;
-    exec: string;
-}
-/**
- * Detect the package manager used in the project
- */
-export declare function detectPackageManager(projectRoot: string): PackageManager;
-/**
- * Get the run command prefix for the detected package manager
- */
-export declare function getRunCommand(projectRoot: string): string;
-/**
- * Get the exec command prefix for the detected package manager
- */
-export declare function getExecCommand(projectRoot: string): string;

package/dist/lib/package-manager.js

@@ -1,53 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-const COMMANDS = {
-    npm: {
-        run: "npm run",
-        exec: "npx",
-    },
-    pnpm: {
-        run: "pnpm run",
-        exec: "pnpm exec",
-    },
-    yarn: {
-        run: "yarn run",
-        exec: "yarn run",
-    },
-    bun: {
-        run: "bun run",
-        exec: "bun x",
-    },
-};
-/**
- * Detect the package manager used in the project
- */
-export function detectPackageManager(projectRoot) {
-    if (fs.existsSync(path.join(projectRoot, "pnpm-lock.yaml"))) {
-        return "pnpm";
-    }
-    if (fs.existsSync(path.join(projectRoot, "yarn.lock"))) {
-        return "yarn";
-    }
-    if (fs.existsSync(path.join(projectRoot, "bun.lockb"))) {
-        return "bun";
-    }
-    if (fs.existsSync(path.join(projectRoot, "package-lock.json"))) {
-        return "npm";
-    }
-    // Default to npm if no lock file found
-    return "npm";
-}
-/**
- * Get the run command prefix for the detected package manager
- */
-export function getRunCommand(projectRoot) {
-    const pm = detectPackageManager(projectRoot);
-    return COMMANDS[pm].run;
-}
-/**
- * Get the exec command prefix for the detected package manager
- */
-export function getExecCommand(projectRoot) {
-    const pm = detectPackageManager(projectRoot);
-    return COMMANDS[pm].exec;
-}