task-o-matic-core 0.1.0

package/dist/lib/config.js

@@ -0,0 +1,351 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configManager = exports.ConfigManager = exports.providerDefaults = void 0;
+exports.createDefaultConfigCallbacks = createDefaultConfigCallbacks;
+exports.setupWorkingDirectory = setupWorkingDirectory;
+const path_1 = require("path");
+const process_1 = require("process");
+const fs_1 = require("fs");
+const dotenv_1 = require("dotenv");
+const config_validation_1 = require("./config-validation");
+const task_o_matic_error_1 = require("../utils/task-o-matic-error");
+const logger_1 = require("./logger");
+// Provider-specific sensible defaults for 2025
+// Externalized to JSON for easy updates
+const provider_defaults_json_1 = __importDefault(require("./provider-defaults.json"));
+exports.providerDefaults = provider_defaults_json_1.default;
+function getApiKeyFromEnv(provider, getEnv) {
+    switch (provider) {
+        case "openrouter":
+            return getEnv("OPENROUTER_API_KEY");
+        case "anthropic":
+            return getEnv("ANTHROPIC_API_KEY");
+        case "openai":
+            return getEnv("OPENAI_API_KEY");
+        case "custom":
+            return getEnv("CUSTOM_API_KEY");
+        case "zai":
+            return getEnv("ZAI_API_KEY");
+        default:
+            return undefined;
+    }
+}
+function createDefaultConfigCallbacks(workingDir = (0, process_1.cwd)()) {
+    // Ensure dotenv is loaded for the default callbacks
+    const envPath = (0, path_1.join)(workingDir, ".env");
+    if ((0, fs_1.existsSync)(envPath)) {
+        (0, dotenv_1.config)({ path: envPath });
+    }
+    return {
+        read: async (key) => {
+            // If key is relative, assume it's in .task-o-matic dir relative to workingDir
+            // But ConfigManager usually passes "config.json"
+            // We need to resolve it.
+            // For default callbacks, we replicate the original behavior:
+            // .task-o-matic/config.json in workingDir
+            const configPath = (0, path_1.join)(workingDir, ".task-o-matic", key);
+            if ((0, fs_1.existsSync)(configPath)) {
+                return (0, fs_1.readFileSync)(configPath, "utf-8");
+            }
+            return null;
+        },
+        write: async (key, value) => {
+            const taskOMaticDir = (0, path_1.join)(workingDir, ".task-o-matic");
+            if (!(0, fs_1.existsSync)(taskOMaticDir)) {
+                (0, fs_1.mkdirSync)(taskOMaticDir, { recursive: true });
+            }
+            const configPath = (0, path_1.join)(taskOMaticDir, key);
+            (0, fs_1.writeFileSync)(configPath, value, "utf-8");
+        },
+        getEnv: (key) => process.env[key],
+    };
+}
+class ConfigManager {
+    config = null;
+    customWorkingDir = null;
+    callbacks;
+    constructor(callbacks, workingDirectory) {
+        if (workingDirectory) {
+            this.customWorkingDir = (0, path_1.resolve)(workingDirectory);
+        }
+        // If callbacks not provided, create defaults using the working directory
+        this.callbacks =
+            callbacks || createDefaultConfigCallbacks(this.getWorkingDirectory());
+        // We cannot await in constructor.
+        // Consumers MUST call load() or ensure it's loaded before accessing config.
+        // For backward compatibility in CLI (where sync access was common),
+        // we might need a way to force sync load if using default callbacks?
+        // But we want to support async callbacks.
+        // So we enforce async initialization pattern.
+    }
+    setWorkingDirectory(dir) {
+        this.customWorkingDir = (0, path_1.resolve)(dir);
+        // Re-create default callbacks to point to new dir
+        this.callbacks = createDefaultConfigCallbacks(this.getWorkingDirectory());
+        // Invalidate config so next access requires reload
+        this.config = null;
+    }
+    setCallbacks(callbacks) {
+        this.callbacks = callbacks;
+        this.config = null;
+    }
+    getWorkingDirectory() {
+        return this.customWorkingDir || (0, process_1.cwd)();
+    }
+    getTaskOMaticDir() {
+        return (0, path_1.join)(this.getWorkingDirectory(), ".task-o-matic");
+    }
+    loadEnvConfig() {
+        const providerStr = this.callbacks.getEnv("AI_PROVIDER")?.toLowerCase();
+        const provider = providerStr ? providerStr : undefined;
+        // Check if provider is valid if set
+        // (This validation is loose here, strict validation happens in validateConfig)
+        const maxTokensStr = this.callbacks.getEnv("AI_MAX_TOKENS");
+        const tempStr = this.callbacks.getEnv("AI_TEMPERATURE");
+        const modelStr = this.callbacks.getEnv("AI_MODEL");
+        const config = {};
+        if (provider)
+            config.provider = provider;
+        if (modelStr)
+            config.model = modelStr;
+        if (maxTokensStr)
+            config.maxTokens = parseInt(maxTokensStr);
+        if (tempStr)
+            config.temperature = parseFloat(tempStr);
+        // API Key logic needs to know the provider. 
+        // If provider is not in env, we should check the resolved provider... 
+        // But here we only return partial env overrides.
+        // The API key fetching logic in getApiKeyFromEnv depends on the provider.
+        // If the provider comes from file, we can't know it here easily if we are just returning overrides.
+        // However, getApiKeyFromEnv is a helper. 
+        // We can fetch ALL potential API keys? No, that's messy.
+        // Or we just fetch the API key if AI_PROVIDER is set? 
+        // If AI_PROVIDER is NOT set, we don't know which env var to read for the key yet 
+        // (unless we assume the default or the file one).
+        // If we return undefined for apiKey here, it might overwrite the file one? 
+        // No, undefined properties don't overwrite if we use spread correctly?
+        // { ...a, ...b } where b has undefined properties... 
+        // In JS/TS spread { ...{a:1}, ...{a: undefined} } results in {a: undefined}. 
+        // So we must NOT include undefined keys in the returned object.
+        if (provider) {
+            const key = getApiKeyFromEnv(provider, this.callbacks.getEnv);
+            if (key)
+                config.apiKey = key;
+        }
+        else {
+            // If provider not in env, we might miss the API key from env if the user 
+            // intended to use file-provider + env-key.
+            // This is a bit tricky with the current structure.
+            // But let's stick to the fix for provider override first.
+            // We will deal with API key resolution merging later or assume user sets both in env.
+            // Actually, we can check all possible keys?
+            // Or better: The merge logic in load() is complex.
+            // Let's defer API key resolution to after we know the final provider?
+            // But load() does: ai: { ...defaultConfig.ai, ...fileConfig.ai, ...envConfig }
+            // If I change loadEnvConfig to NOT return apiKey if provider is missing, 
+            // then apiKey will come from fileConfig or defaultConfig.
+        }
+        return config;
+    }
+    async load() {
+        const envConfig = this.loadEnvConfig();
+        // Default provider is openrouter
+        const defaultProvider = envConfig.provider || "openrouter";
+        // We can try to get API key for default provider if not in envConfig
+        let defaultApiKey = envConfig.apiKey;
+        if (!defaultApiKey) {
+            defaultApiKey = getApiKeyFromEnv(defaultProvider, this.callbacks.getEnv);
+        }
+        const defaultConfig = {
+            ai: {
+                provider: "openrouter",
+                model: "z-ai/glm-4.6",
+                maxTokens: 32768,
+                temperature: 0.5,
+                apiKey: defaultApiKey, // This might be overwritten by file or envConfig later
+            },
+        };
+        try {
+            // Use relative path "config.json" - callbacks handle resolution
+            const configData = await this.callbacks.read("config.json");
+            if (configData) {
+                const fileConfig = JSON.parse(configData);
+                // We need to resolve the final provider to get the correct API key from env 
+                // if it wasn't provided in envConfig.
+                const finalProvider = envConfig.provider || fileConfig.ai?.provider || defaultConfig.ai.provider;
+                // If envConfig didn't provide a key, check if we can get it based on finalProvider
+                let finalApiKey = envConfig.apiKey;
+                if (!finalApiKey) {
+                    finalApiKey = getApiKeyFromEnv(finalProvider, this.callbacks.getEnv);
+                }
+                // We construct a refined envConfig that includes the correct API key
+                const refinedEnvConfig = { ...envConfig };
+                if (finalApiKey) {
+                    refinedEnvConfig.apiKey = finalApiKey;
+                }
+                const mergedConfig = {
+                    ...defaultConfig,
+                    ...fileConfig,
+                    ai: { ...defaultConfig.ai, ...fileConfig.ai, ...refinedEnvConfig },
+                };
+                // Validate the merged configuration
+                const validatedConfig = (0, config_validation_1.validateConfig)(mergedConfig);
+                this.config = validatedConfig;
+                if (this.config && this.config.workingDirectory) {
+                    this.customWorkingDir = this.config.workingDirectory;
+                }
+            }
+            else {
+                // Apply envConfig to defaults
+                const mergedConfig = {
+                    ...defaultConfig,
+                    ai: { ...defaultConfig.ai, ...envConfig }
+                };
+                this.config = (0, config_validation_1.validateConfig)(mergedConfig);
+            }
+        }
+        catch (error) {
+            logger_1.logger.warn(`Failed to read or validate config, using defaults: ${error}`);
+            // Even defaults should be validated
+            this.config = (0, config_validation_1.validateConfig)(defaultConfig);
+        }
+        return this.config;
+    }
+    async save() {
+        if (!this.config) {
+            throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.CONFIGURATION_ERROR, "Config not loaded, cannot save.", {
+                suggestions: ["Call await configManager.load() before saving"],
+            });
+        }
+        try {
+            await this.callbacks.write("config.json", JSON.stringify(this.config, null, 2));
+        }
+        catch (error) {
+            logger_1.logger.error(`Failed to save config: ${error}`);
+            throw error;
+        }
+    }
+    getConfig() {
+        if (!this.config) {
+            // If we are here, it means load() wasn't called or hasn't finished.
+            // Since we can't be async here, we must throw or return defaults.
+            // Returning defaults might hide issues.
+            // Throwing forces users to await load().
+            throw (0, task_o_matic_error_1.createStandardError)(task_o_matic_error_1.TaskOMaticErrorCodes.CONFIGURATION_ERROR, "Config not loaded. Call await configManager.load() first.", {
+                context: "Configuration must be loaded before access",
+                suggestions: [
+                    "Call await configManager.load() first",
+                    "Check initialization order",
+                ],
+            });
+        }
+        return this.config;
+    }
+    getAIConfig() {
+        return this.getConfig().ai;
+    }
+    async setAIConfig(aiConfig) {
+        if (!this.config) {
+            await this.load();
+        }
+        // Validate the partial config before merging
+        const validatedPartial = (0, config_validation_1.validatePartialAIConfig)(aiConfig);
+        // Merge and validate the full config
+        const mergedAIConfig = { ...this.config.ai, ...validatedPartial };
+        const validatedConfig = (0, config_validation_1.validateConfig)({
+            ...this.config,
+            ai: mergedAIConfig,
+        });
+        this.config = validatedConfig;
+        await this.save();
+    }
+    setConfig(config) {
+        this.config = config;
+    }
+    // Helper for legacy code that might need path (deprecated for direct use)
+    getConfigFilePath() {
+        return (0, path_1.join)(this.getTaskOMaticDir(), "config.json");
+    }
+    /**
+     * Validate configuration independently of load().
+     * Can be used to validate config before applying changes.
+     */
+    validate(configToValidate) {
+        const errors = [];
+        const config = configToValidate || this.config;
+        if (!config) {
+            return {
+                valid: false,
+                errors: [
+                    "No configuration to validate. Either provide a config or call load() first.",
+                ],
+            };
+        }
+        // Validate AI config
+        if (config.ai) {
+            const { provider, model, apiKey, maxTokens, temperature } = config.ai;
+            // Validate provider
+            if (provider &&
+                ![
+                    "openrouter",
+                    "anthropic",
+                    "openai",
+                    "custom",
+                    "gemini",
+                    "zai",
+                ].includes(provider)) {
+                errors.push(`Invalid provider: ${provider}. Must be one of: openrouter, anthropic, openai, custom, gemini, zai`);
+            }
+            // Validate model
+            if (model !== undefined && typeof model !== "string") {
+                errors.push("Model must be a string");
+            }
+            // Validate maxTokens
+            if (maxTokens !== undefined) {
+                if (typeof maxTokens !== "number" ||
+                    maxTokens < 1 ||
+                    maxTokens > 200000) {
+                    errors.push("maxTokens must be a number between 1 and 200000");
+                }
+            }
+            // Validate temperature
+            if (temperature !== undefined) {
+                if (typeof temperature !== "number" ||
+                    temperature < 0 ||
+                    temperature > 2) {
+                    errors.push("temperature must be a number between 0 and 2");
+                }
+            }
+            // Warn about missing API key (not an error, just a warning)
+            if (!apiKey && provider !== "custom") {
+                // This is a soft validation - API key can be set via env vars
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+}
+exports.ConfigManager = ConfigManager;
+exports.configManager = new ConfigManager();
+/**
+ * Helper function to set working directory and reload config.
+ * Combines the common pattern of setWorkingDirectory + load.
+ *
+ * @param dir - Working directory path
+ * @param manager - ConfigManager instance (defaults to singleton)
+ * @returns Loaded config
+ *
+ * @example
+ * ```typescript
+ * await setupWorkingDirectory("/path/to/project");
+ * ```
+ */
+async function setupWorkingDirectory(dir, manager = exports.configManager) {
+    manager.setWorkingDirectory(dir);
+    return await manager.load();
+}

package/dist/lib/context-builder.d.ts

@@ -0,0 +1,66 @@
+import { TaskContext, TaskDocumentation } from "../types";
+import { TaskRepository } from "./storage/types";
+export interface FileStats {
+    mtime: number;
+    isDirectory: boolean;
+}
+export interface ContextCallbacks {
+    readFile: (path: string) => Promise<string | null>;
+    fileExists: (path: string) => Promise<boolean>;
+    listFiles: (dir: string) => Promise<string[]>;
+    stat: (path: string) => Promise<FileStats | null>;
+}
+export declare function createDefaultContextCallbacks(): ContextCallbacks;
+export declare class ContextBuilder {
+    private storage;
+    private callbacks;
+    private taskOMatic;
+    private initialized;
+    constructor(storage: TaskRepository, callbacks?: ContextCallbacks);
+    private ensureInitialized;
+    /**
+     * Build comprehensive context for AI operations
+     */
+    buildContext(taskId: string): Promise<TaskContext>;
+    /**
+     * Build context for new tasks (without requiring existing task)
+     */
+    buildContextForNewTask(title: string, description?: string, prdFile?: string): Promise<TaskContext>;
+    /**
+     * Get stack configuration from project (set by bootstrap)
+     */
+    private getStackConfig;
+    /**
+     * Get task documentation references
+     */
+    private getTaskDocumentation;
+    /**
+     * Get full task content from MD file
+     */
+    private getTaskFullContent;
+    /**
+     * Read documentation file content
+     */
+    private readDocumentationFile;
+    /**
+     * Check if documentation is fresh (less than 7 days old)
+     */
+    isDocumentationFresh(documentation: TaskDocumentation): boolean;
+    /**
+     * Check if documentation is stale (more than 30 days old)
+     */
+    isDocumentationStale(documentation: TaskDocumentation): boolean;
+    /**
+     * Get PRD content from file path
+     */
+    private getPRDContent;
+    /**
+     * Get relevant PRD content based on task title/description
+     */
+    private getRelevantPRDContent;
+    /**
+     * Format context for AI prompts
+     */
+    formatContextForAI(context: TaskContext): string;
+}
+//# sourceMappingURL=context-builder.d.ts.map

package/dist/lib/context-builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-builder.d.ts","sourceRoot":"","sources":["../../src/lib/context-builder.ts"],"names":[],"mappings":"AACA,OAAO,EAAQ,WAAW,EAAa,iBAAiB,EAAE,MAAM,UAAU,CAAC;AAC3E,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAKjD,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;IACnD,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC/C,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,EAAE,CAAC,CAAC;IAC9C,IAAI,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC;CACnD;AAED,wBAAgB,6BAA6B,IAAI,gBAAgB,CA4BhE;AAED,qBAAa,cAAc;IACzB,OAAO,CAAC,OAAO,CAAiB;IAChC,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,UAAU,CAAuB;IACzC,OAAO,CAAC,WAAW,CAAS;gBAEhB,OAAO,EAAE,cAAc,EAAE,SAAS,CAAC,EAAE,gBAAgB;IAKjE,OAAO,CAAC,iBAAiB;IASzB;;OAEG;IACG,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAsCxD;;OAEG;IACG,sBAAsB,CAC1B,KAAK,EAAE,MAAM,EACb,WAAW,CAAC,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,WAAW,CAAC;IAsBvB;;OAEG;YACW,cAAc;IA6C5B;;OAEG;IACH,OAAO,CAAC,oBAAoB;IAI5B;;OAEG;YACW,kBAAkB;IAgBhC;;OAEG;YACW,qBAAqB;IAmBnC;;OAEG;IACH,oBAAoB,CAAC,aAAa,EAAE,iBAAiB,GAAG,OAAO;IAK/D;;OAEG;IACH,oBAAoB,CAAC,aAAa,EAAE,iBAAiB,GAAG,OAAO;IAK/D;;OAEG;YACW,aAAa;IAkB3B;;OAEG;YACW,qBAAqB;IAqDnC;;OAEG;IACH,kBAAkB,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM;CAmDjD"}