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

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/dist/schemas/task.d.ts

@@ -1,12 +1,12 @@
 import { z } from "zod";
 export declare const TaskStatusSchema: z.ZodEnum<{
+    planning: "planning";
     implementing: "implementing";
     verifying: "verifying";
     completed: "completed";
     blocked: "blocked";
     todo: "todo";
     in_progress: "in_progress";
-    planning: "planning";
 }>;
 export declare const SubtaskSchema: z.ZodObject<{
     id: z.ZodString;
@@ -21,13 +21,13 @@ export declare const TaskSchema: z.ZodObject<{
     title: z.ZodString;
     description: z.ZodString;
     status: z.ZodDefault<z.ZodEnum<{
+        planning: "planning";
         implementing: "implementing";
         verifying: "verifying";
         completed: "completed";
         blocked: "blocked";
         todo: "todo";
         in_progress: "in_progress";
-        planning: "planning";
     }>>;
     type: z.ZodDefault<z.ZodEnum<{
         feat: "feat";

package/dist/state-machine.d.ts

@@ -1,3 +1,15 @@
+/**
+ * Workflow State Machine
+ *
+ * This class provides an in-memory state machine for managing task workflow.
+ * It operates at a higher level of abstraction than task files - it manages
+ * the developer's session state rather than persistent task state.
+ *
+ * NOTE: This is currently NOT used by the CLI commands. CLI commands
+ * (StartCommand, CheckCommand, etc.) use task files directly via the
+ * data-access module. This class can be used as an alternative
+ * programmatic API or for future session management features.
+ */
 import type { ConfigLoader } from "./config.js";
 import type { GitManager } from "./git.js";
 export type MachineState = "IDLE" | "PLANNING" | "EXECUTION" | "VERIFICATION" | "COMPLETED";

package/dist/state-machine.js

@@ -52,7 +52,7 @@ export class StateMachine {
         // In a real impl, we would find the task file.
         this.activeTaskId = taskId;
         this.currentState = "PLANNING";
-        // TODO: Return initial context (Rules, Retro)
+        // FUTURE: Return initial context (Rules, Retro) when this is actively used
     }
     /**
      * Transition: PLANNING -> EXECUTION
@@ -82,7 +82,7 @@ export class StateMachine {
         if (this.currentState !== "VERIFICATION") {
             throw new Error("Cannot complete task: Not in VERIFICATION state.");
         }
-        // TODO: Verify checks passed? (Or rely on caller to ensure this)
+        // FUTURE: Verify checks passed? For now, rely on caller to ensure this
         this.currentState = "COMPLETED";
         this.activeTaskId = null;
         // Auto-transition back to IDLE? Or stay in COMPLETED until explicit 'next'?

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@krr2020/taskflow-core",
-	"version": "0.1.0-beta.3",
+	"version": "0.1.0-beta.5",
 	"description": "Core logic for Taskflow - AI-first task management and workflow system",
 	"license": "MIT",
 	"publishConfig": {

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