task-o-matic 0.0.1

package/dist/lib/ai-service/json-parser.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONParser = void 0;
+class JSONParser {
+    /**
+     * Parses JSON from AI text response with improved error handling
+     * @deprecated Use generateObject instead for structured output
+     */
+    parseJSONFromResponse(text) {
+        try {
+            // Try to extract JSON from the response (handle various formats)
+            const jsonMatch = text.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) {
+                return {
+                    success: false,
+                    error: "Could not extract JSON from AI response",
+                    rawText: text,
+                };
+            }
+            const jsonStr = jsonMatch[0];
+            const parsed = JSON.parse(jsonStr);
+            return {
+                success: true,
+                data: parsed,
+                rawText: text,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                rawText: text,
+            };
+        }
+    }
+}
+exports.JSONParser = JSONParser;

package/dist/lib/ai-service/mcp-client.d.ts

@@ -0,0 +1,9 @@
+import { ToolSet } from "ai";
+export declare class Context7Client {
+    private mcpClient;
+    initializeMCPClient(): Promise<any>;
+    getMCPTools(): Promise<ToolSet>;
+    closeMCPConnection(): Promise<void>;
+    saveContext7Documentation(library: string, query: string, content: string): Promise<string>;
+}
+//# sourceMappingURL=mcp-client.d.ts.map

package/dist/lib/ai-service/mcp-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-client.d.ts","sourceRoot":"","sources":["../../../src/lib/ai-service/mcp-client.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,OAAO,EAAQ,MAAM,IAAI,CAAC;AAEnC,qBAAa,cAAc;IACzB,OAAO,CAAC,SAAS,CAAa;IAExB,mBAAmB;IAoBnB,WAAW,IAAI,OAAO,CAAC,OAAO,CAAC;IAW/B,kBAAkB;IAOlB,yBAAyB,CAC7B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC;CAInB"}

package/dist/lib/ai-service/mcp-client.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context7Client = void 0;
+const mcp_1 = require("@ai-sdk/mcp");
+const ai_service_factory_1 = require("../../utils/ai-service-factory");
+class Context7Client {
+    mcpClient = null;
+    async initializeMCPClient() {
+        if (this.mcpClient)
+            return this.mcpClient;
+        try {
+            // Connect to Context7 MCP server using HTTP transport
+            this.mcpClient = await (0, mcp_1.experimental_createMCPClient)({
+                transport: {
+                    type: "http",
+                    url: "https://mcp.context7.com/mcp",
+                    headers: {
+                        CONTEXT7_API_KEY: process.env.CONTEXT7_API_KEY || "",
+                    },
+                },
+            });
+            return this.mcpClient;
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async getMCPTools() {
+        const client = await this.initializeMCPClient();
+        if (!client) {
+            throw new Error("Failed to initialize MCP client");
+        }
+        // Return original tools without wrapping - tool wrapping doesn't work with MCP tools
+        // Context7 result saving will be handled in ai-operations.ts by processing toolResults
+        return await client.tools();
+    }
+    async closeMCPConnection() {
+        if (this.mcpClient) {
+            await this.mcpClient.close();
+            this.mcpClient = null;
+        }
+    }
+    async saveContext7Documentation(library, query, content) {
+        const storage = (0, ai_service_factory_1.getStorage)();
+        return await storage.saveContext7Documentation(library, query, content);
+    }
+}
+exports.Context7Client = Context7Client;

package/dist/lib/ai-service/model-provider.d.ts

@@ -0,0 +1,8 @@
+import type { LanguageModelV2 } from "@ai-sdk/provider";
+import { AIConfig } from "../../types";
+export declare class ModelProvider {
+    getAIConfig(): AIConfig;
+    private getEnvConfig;
+    getModel(aiConfig: AIConfig): LanguageModelV2;
+}
+//# sourceMappingURL=model-provider.d.ts.map

package/dist/lib/ai-service/model-provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-provider.d.ts","sourceRoot":"","sources":["../../../src/lib/ai-service/model-provider.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,qBAAa,aAAa;IACjB,WAAW,IAAI,QAAQ;IAY9B,OAAO,CAAC,YAAY;IAsBpB,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe;CA+B9C"}

package/dist/lib/ai-service/model-provider.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelProvider = void 0;
+const openai_1 = require("@ai-sdk/openai");
+const anthropic_1 = require("@ai-sdk/anthropic");
+const openai_compatible_1 = require("@ai-sdk/openai-compatible");
+const ai_sdk_provider_1 = require("@openrouter/ai-sdk-provider");
+const config_1 = require("../config");
+class ModelProvider {
+    getAIConfig() {
+        const config = config_1.configManager.getAIConfig();
+        const envConfig = this.getEnvConfig(config.provider);
+        // Override with environment variables if available
+        return {
+            ...config,
+            apiKey: config.apiKey || envConfig.apiKey,
+            baseURL: config.baseURL || envConfig.baseURL,
+        };
+    }
+    getEnvConfig(provider) {
+        const envConfigMap = {
+            openai: {
+                apiKey: process.env.OPENAI_API_KEY,
+            },
+            anthropic: {
+                apiKey: process.env.ANTHROPIC_API_KEY,
+            },
+            openrouter: {
+                apiKey: process.env.OPENROUTER_API_KEY,
+                baseURL: "https://openrouter.ai/api/v1",
+            },
+            custom: {
+                apiKey: process.env.CUSTOM_API_KEY,
+                baseURL: process.env.CUSTOM_API_URL,
+            },
+        };
+        return envConfigMap[provider] || {};
+    }
+    getModel(aiConfig) {
+        const { provider, model, apiKey, baseURL } = aiConfig;
+        switch (provider) {
+            case "openai":
+                if (!apiKey)
+                    throw new Error("OpenAI API key is required");
+                return (0, openai_1.openai)(model);
+            case "anthropic":
+                if (!apiKey)
+                    throw new Error("Anthropic API key is required");
+                return (0, anthropic_1.anthropic)(model);
+            case "openrouter":
+                if (!apiKey)
+                    throw new Error("OpenRouter API key is required");
+                const openRouterProvider = (0, ai_sdk_provider_1.createOpenRouter)({ apiKey });
+                return openRouterProvider(model);
+            case "custom":
+                if (!apiKey)
+                    throw new Error("Custom API key is required");
+                if (!baseURL)
+                    throw new Error("Custom provider requires baseURL");
+                const customProvider = (0, openai_compatible_1.createOpenAICompatible)({
+                    name: "custom",
+                    apiKey,
+                    baseURL,
+                });
+                return customProvider(model);
+            default:
+                throw new Error(`Unsupported provider: ${provider}`);
+        }
+    }
+}
+exports.ModelProvider = ModelProvider;

package/dist/lib/ai-service/research-tools.d.ts

@@ -0,0 +1,4 @@
+export declare class ResearchTools {
+    private storage;
+}
+//# sourceMappingURL=research-tools.d.ts.map

package/dist/lib/ai-service/research-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"research-tools.d.ts","sourceRoot":"","sources":["../../../src/lib/ai-service/research-tools.ts"],"names":[],"mappings":"AAIA,qBAAa,aAAa;IACxB,OAAO,CAAC,OAAO,CAAsB;CAwMtC"}

package/dist/lib/ai-service/research-tools.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResearchTools = void 0;
+const storage_1 = require("../storage");
+class ResearchTools {
+    storage = new storage_1.LocalStorage();
+}
+exports.ResearchTools = ResearchTools;

package/dist/lib/ai-service/retry-handler.d.ts

@@ -0,0 +1,8 @@
+import { RetryConfig } from "../../types";
+export declare class RetryHandler {
+    private getRetryConfig;
+    private shouldRetryError;
+    private delay;
+    executeWithRetry<T>(operation: () => Promise<T>, retryConfig?: Partial<RetryConfig>, operationName?: string): Promise<T>;
+}
+//# sourceMappingURL=retry-handler.d.ts.map

package/dist/lib/ai-service/retry-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retry-handler.d.ts","sourceRoot":"","sources":["../../../src/lib/ai-service/retry-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAE1C,qBAAa,YAAY;IACvB,OAAO,CAAC,cAAc;IAmBtB,OAAO,CAAC,gBAAgB;YAaV,KAAK;IAIb,gBAAgB,CAAC,CAAC,EACtB,SAAS,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAC3B,WAAW,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,EAClC,aAAa,GAAE,MAAuB,GACrC,OAAO,CAAC,CAAC,CAAC;CA6Cd"}

package/dist/lib/ai-service/retry-handler.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RetryHandler = void 0;
+class RetryHandler {
+    getRetryConfig() {
+        return {
+            maxAttempts: parseInt(process.env.AI_MAX_RETRY_ATTEMPTS || "3", 10),
+            baseDelay: parseInt(process.env.AI_RETRY_BASE_DELAY || "1000", 10),
+            maxDelay: parseInt(process.env.AI_RETRY_MAX_DELAY || "10000", 10),
+            backoffFactor: parseFloat(process.env.AI_RETRY_BACKOFF_FACTOR || "2"),
+            retryableErrors: [
+                "ECONNRESET",
+                "ENOTFOUND",
+                "ECONNREFUSED",
+                "ETIMEDOUT",
+                "NETWORK_ERROR",
+                "RATE_LIMIT",
+                "TEMPORARY_FAILURE",
+                "INTERNAL_ERROR",
+            ],
+        };
+    }
+    shouldRetryError(error, retryableErrors) {
+        if (!error)
+            return false;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        const errorName = error instanceof Error ? error.name : "";
+        return retryableErrors.some((retryableError) => errorMessage.toUpperCase().includes(retryableError) ||
+            errorName.toUpperCase().includes(retryableError));
+    }
+    async delay(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    async executeWithRetry(operation, retryConfig, operationName = "AI operation") {
+        const finalRetryConfig = { ...this.getRetryConfig(), ...retryConfig };
+        const { maxAttempts = 3, baseDelay = 1000, maxDelay = 10000, backoffFactor = 2, retryableErrors = [], } = finalRetryConfig;
+        let lastError;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                return await operation();
+            }
+            catch (error) {
+                lastError = error;
+                // Don't retry on the last attempt
+                if (attempt === maxAttempts) {
+                    break;
+                }
+                // Check if error is retryable
+                if (!this.shouldRetryError(error, retryableErrors)) {
+                    break;
+                }
+                // Calculate delay with exponential backoff
+                const delayMs = Math.min(baseDelay * Math.pow(backoffFactor, attempt - 1), maxDelay);
+                console.warn(`${operationName} failed (attempt ${attempt}/${maxAttempts}), retrying in ${delayMs}ms:`, error);
+                await this.delay(delayMs);
+            }
+        }
+        // Throw the original error - NO rebuilding bullshit
+        throw lastError;
+    }
+}
+exports.RetryHandler = RetryHandler;

package/dist/lib/better-t-stack-cli.d.ts

@@ -0,0 +1,35 @@
+import { BTSConfig } from "../types";
+export declare class BetterTStackService {
+    createProject(name: string, config: BTSConfig, workingDirectory?: string): Promise<{
+        success: boolean;
+        projectPath: string;
+        message: string;
+    }>;
+    private convertToAPIConfig;
+    private saveBTSConfig;
+}
+export interface InitOptions {
+    projectName?: string;
+    name?: string;
+    frontend: string;
+    backend: string;
+    database: string;
+    noAuth?: boolean;
+    addons?: string[];
+    runtime?: string;
+    api?: string;
+    payments?: string;
+    orm?: string;
+    dbSetup?: string;
+    packageManager?: string;
+    noGit?: boolean;
+    webDeploy?: string;
+    serverDeploy?: string;
+    noInstall?: boolean;
+    examples?: string[];
+}
+export declare function runBetterTStackCLI(options: InitOptions, workingDirectory?: string): Promise<{
+    success: boolean;
+    message: string;
+}>;
+//# sourceMappingURL=better-t-stack-cli.d.ts.map

package/dist/lib/better-t-stack-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"better-t-stack-cli.d.ts","sourceRoot":"","sources":["../../src/lib/better-t-stack-cli.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAC;AAKrC,qBAAa,mBAAmB;IACxB,aAAa,CACjB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,SAAS,EACjB,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC;QACT,OAAO,EAAE,OAAO,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,OAAO,EAAE,MAAM,CAAC;KACjB,CAAC;IAmDF,OAAO,CAAC,kBAAkB;YAsBZ,aAAa;CAqB5B;AAED,MAAM,WAAW,WAAW;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,WAAW,EACpB,gBAAgB,CAAC,EAAE,MAAM,GACxB,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC,CAkChD"}

package/dist/lib/better-t-stack-cli.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BetterTStackService = void 0;
+exports.runBetterTStackCLI = runBetterTStackCLI;
+const config_1 = require("./config");
+const fs_1 = require("fs");
+const path_1 = require("path");
+class BetterTStackService {
+    async createProject(name, config, workingDirectory) {
+        try {
+            console.log(`🚀 Bootstrapping Better-T-Stack project: ${name}`);
+            // Change to working directory if provided
+            const originalCwd = process.cwd();
+            if (workingDirectory) {
+                process.chdir(workingDirectory);
+                console.log(`🔥 Changed working directory to: ${workingDirectory}`);
+            }
+            // Convert our config to Better-T-Stack API format
+            const apiConfig = this.convertToAPIConfig(config);
+            console.log(`🔥 Calling Better-T-Stack programmatic API...`);
+            // Use dynamic import with eval to bypass TypeScript module resolution
+            // this is magically fucking terrible
+            const btsModule = await eval(`import("create-better-t-stack")`);
+            const result = await btsModule.init(name, apiConfig);
+            // Restore original directory
+            if (workingDirectory) {
+                process.chdir(originalCwd);
+            }
+            if (result.success) {
+                // Save configuration
+                await this.saveBTSConfig(name, config);
+                return {
+                    success: true,
+                    projectPath: result.relativePath,
+                    message: `Better-T-Stack project ${name} created successfully at ${result.projectDirectory}`,
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    projectPath: "",
+                    message: `Better-T-Stack bootstrap failed: ${result.error}`,
+                };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                projectPath: "",
+                message: `Better-T-Stack initialization failed: ${error instanceof Error ? error.message : "Unknown error"}`,
+            };
+        }
+    }
+    convertToAPIConfig(config) {
+        return {
+            // Don't use 'yes' flag when providing explicit configuration
+            frontend: [config.frontend],
+            backend: config.backend,
+            runtime: config.runtime,
+            api: config.api,
+            auth: config.auth,
+            database: config.database,
+            orm: config.orm,
+            dbSetup: config.dbSetup,
+            packageManager: config.packageManager,
+            webDeploy: config.webDeploy,
+            serverDeploy: config.serverDeploy,
+            git: config.git,
+            install: config.install,
+            addons: config.addons,
+            examples: config.examples,
+            disableAnalytics: true,
+        };
+    }
+    async saveBTSConfig(name, config) {
+        const taskOMaticDir = config_1.configManager.getTaskOMaticDir();
+        const configData = JSON.stringify({
+            ...config,
+            projectName: config.projectName || name,
+            createdAt: new Date().toISOString(),
+        }, null, 2);
+        // Save with project-specific name for tracking multiple projects
+        const namedConfigPath = (0, path_1.join)(taskOMaticDir, `${name}-bts-config.json`);
+        (0, fs_1.writeFileSync)(namedConfigPath, configData);
+        // Also save as canonical stack.json for easy discovery by context-builder
+        const stackConfigPath = (0, path_1.join)(taskOMaticDir, "stack.json");
+        (0, fs_1.writeFileSync)(stackConfigPath, configData);
+    }
+}
+exports.BetterTStackService = BetterTStackService;
+async function runBetterTStackCLI(options, workingDirectory) {
+    const btsService = new BetterTStackService();
+    const backend = options.backend;
+    const isConvex = backend === "convex";
+    const btsConfig = {
+        projectName: options.name || options.projectName || "default-project",
+        frontend: options.frontend || "next",
+        backend: backend || "convex",
+        database: isConvex
+            ? "none"
+            : options.database || "sqlite",
+        auth: options.noAuth ? "none" : "better-auth",
+        addons: options.addons || ["turborepo"],
+        runtime: isConvex ? "none" : options.runtime || "node",
+        api: options.api || "none",
+        payments: options.payments || "none",
+        orm: isConvex ? "none" : options.orm || "drizzle",
+        dbSetup: isConvex ? "none" : options.dbSetup || "none",
+        packageManager: options.packageManager || "npm",
+        git: !options.noGit,
+        webDeploy: options.webDeploy || "none",
+        serverDeploy: options.serverDeploy || "none",
+        install: !options.noInstall,
+        examples: options.examples || [],
+    };
+    const result = await btsService.createProject(options.projectName || options.name || "", btsConfig, workingDirectory);
+    return { success: result.success, message: result.message };
+}

package/dist/lib/config.d.ts

@@ -0,0 +1,24 @@
+import { AIConfig } from "../types";
+export interface Config {
+    ai: AIConfig;
+    workingDirectory?: string;
+}
+export declare class ConfigManager {
+    private config;
+    private customWorkingDir;
+    constructor(workingDirectory?: string);
+    setWorkingDirectory(dir: string): void;
+    getWorkingDirectory(): string;
+    ensureTaskOMaticDir(): void;
+    private loadEnvConfig;
+    load(): Config;
+    save(): void;
+    getConfig(): Config;
+    getAIConfig(): AIConfig;
+    setAIConfig(aiConfig: Partial<AIConfig>): void;
+    setConfig(config: Config): void;
+    getTaskOMaticDir(): string;
+    getConfigFilePath(): string;
+}
+export declare const configManager: ConfigManager;
+//# sourceMappingURL=config.d.ts.map

package/dist/lib/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/lib/config.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAA6C,MAAM,UAAU,CAAC;AAE/E,MAAM,WAAW,MAAM;IACrB,EAAE,EAAE,QAAQ,CAAC;IACb,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAyCD,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAuB;IACrC,OAAO,CAAC,gBAAgB,CAAuB;gBAEnC,gBAAgB,CAAC,EAAE,MAAM;IAOrC,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAMtC,mBAAmB,IAAI,MAAM;IAI7B,mBAAmB,IAAI,IAAI;IAO3B,OAAO,CAAC,aAAa;IAcrB,IAAI,IAAI,MAAM;IA2Cd,IAAI,IAAI,IAAI;IAaZ,SAAS,IAAI,MAAM;IAOnB,WAAW,IAAI,QAAQ;IAIvB,WAAW,CAAC,QAAQ,EAAE,OAAO,CAAC,QAAQ,CAAC,GAAG,IAAI;IAQ9C,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI;IAI/B,gBAAgB,IAAI,MAAM;IAIxB,iBAAiB,IAAI,MAAM;CAM5B;AAID,eAAO,MAAM,aAAa,eAAsB,CAAC"}

package/dist/lib/config.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configManager = exports.ConfigManager = void 0;
+const fs_1 = require("fs");
+const process_1 = require("process");
+const path_1 = require("path");
+const dotenv_1 = require("dotenv");
+// Provider-specific sensible defaults for 2025
+const PROVIDER_DEFAULTS = {
+    openrouter: {
+        model: "z-ai/glm-4.6",
+        maxTokens: 32768,
+        temperature: 0.5,
+    },
+    anthropic: {
+        model: "claude-sonnet-4.5",
+        maxTokens: 32768,
+        temperature: 0.5,
+    },
+    openai: {
+        model: "gpt-5",
+        maxTokens: 32768,
+        temperature: 0.5,
+    },
+    custom: {
+        model: "llama-3.3-70b",
+        maxTokens: 32768,
+        temperature: 0.5,
+    },
+};
+function getApiKeyFromEnv(provider) {
+    switch (provider) {
+        case "openrouter":
+            return process.env.OPENROUTER_API_KEY;
+        case "anthropic":
+            return process.env.ANTHROPIC_API_KEY;
+        case "openai":
+            return process.env.OPENAI_API_KEY;
+        case "custom":
+            return process.env.CUSTOM_API_KEY;
+        default:
+            return undefined;
+    }
+}
+class ConfigManager {
+    config = null;
+    customWorkingDir = null;
+    constructor(workingDirectory) {
+        if (workingDirectory) {
+            this.setWorkingDirectory(workingDirectory);
+        }
+        this.load();
+    }
+    setWorkingDirectory(dir) {
+        this.customWorkingDir = (0, path_1.resolve)(dir);
+        // Reload config when directory changes
+        this.load();
+    }
+    getWorkingDirectory() {
+        return this.customWorkingDir || (0, process_1.cwd)();
+    }
+    ensureTaskOMaticDir() {
+        const taskOMaticDir = this.getTaskOMaticDir();
+        if (!(0, fs_1.existsSync)(taskOMaticDir)) {
+            (0, fs_1.mkdirSync)(taskOMaticDir, { recursive: true });
+        }
+    }
+    loadEnvConfig() {
+        const env = process.env;
+        const provider = env.AI_PROVIDER?.toLowerCase() || "openrouter";
+        const defaults = PROVIDER_DEFAULTS[provider] || PROVIDER_DEFAULTS.openrouter;
+        return {
+            provider,
+            model: env.AI_MODEL || defaults.model,
+            maxTokens: env.AI_MAX_TOKENS ? parseInt(env.AI_MAX_TOKENS) : defaults.maxTokens,
+            temperature: env.AI_TEMPERATURE ? parseFloat(env.AI_TEMPERATURE) : defaults.temperature,
+            apiKey: getApiKeyFromEnv(provider),
+        };
+    }
+    load() {
+        const workingDir = this.getWorkingDirectory();
+        const envPath = (0, path_1.join)(workingDir, '.env');
+        if ((0, fs_1.existsSync)(envPath)) {
+            (0, dotenv_1.config)({ path: envPath });
+        }
+        const envConfig = this.loadEnvConfig();
+        const defaultConfig = {
+            ai: {
+                provider: "openrouter",
+                model: "z-ai/glm-4.6",
+                maxTokens: 32768,
+                temperature: 0.5,
+                ...envConfig,
+            },
+        };
+        const configFilePath = this.getConfigFilePath();
+        if ((0, fs_1.existsSync)(configFilePath)) {
+            try {
+                const configData = (0, fs_1.readFileSync)(configFilePath, "utf-8");
+                const fileConfig = JSON.parse(configData);
+                this.config = {
+                    ...defaultConfig,
+                    ...fileConfig,
+                    ai: { ...defaultConfig.ai, ...fileConfig.ai, ...envConfig }
+                };
+                if (this.config && this.config.workingDirectory) {
+                    this.customWorkingDir = this.config.workingDirectory;
+                }
+            }
+            catch (error) {
+                console.warn("Failed to read config file, using defaults:", error);
+                this.config = defaultConfig;
+            }
+        }
+        else {
+            this.config = defaultConfig;
+        }
+        return this.config;
+    }
+    save() {
+        if (!this.config) {
+            throw new Error("Config not loaded, cannot save.");
+        }
+        this.ensureTaskOMaticDir();
+        try {
+            const configFilePath = this.getConfigFilePath();
+            (0, fs_1.writeFileSync)(configFilePath, JSON.stringify(this.config, null, 2));
+        }
+        catch (error) {
+            console.error("Failed to save config:", error);
+        }
+    }
+    getConfig() {
+        if (!this.config) {
+            return this.load();
+        }
+        return this.config;
+    }
+    getAIConfig() {
+        return this.getConfig().ai;
+    }
+    setAIConfig(aiConfig) {
+        if (!this.config) {
+            this.load();
+        }
+        this.config.ai = { ...this.config.ai, ...aiConfig };
+        this.save();
+    }
+    setConfig(config) {
+        this.config = config;
+    }
+    getTaskOMaticDir() {
+        return (0, path_1.join)(this.getWorkingDirectory(), ".task-o-matic");
+    }
+    getConfigFilePath() {
+        return (0, path_1.join)(this.getTaskOMaticDir(), "config.json");
+    }
+}
+exports.ConfigManager = ConfigManager;
+exports.configManager = new ConfigManager();