tarsk 0.2.5 → 0.3.0

package/dist/utils/env-manager.js

@@ -0,0 +1,60 @@
+import { promises as fs } from 'fs';
+import { join } from 'path';
+export async function updateEnvFile(keyNames) {
+    const envPath = join(process.cwd(), '.env');
+    let content = '';
+    try {
+        content = await fs.readFile(envPath, 'utf-8');
+    }
+    catch {
+        // If file doesn't exist, start with empty content
+    }
+    const lines = content.split('\n');
+    const envMap = {};
+    // Parse existing content
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith('#') && trimmed.includes('=')) {
+            const index = trimmed.indexOf('=');
+            const key = trimmed.substring(0, index).trim();
+            const value = trimmed.substring(index + 1).trim();
+            envMap[key] = value;
+        }
+    }
+    // Update with new values
+    for (const [key, value] of Object.entries(keyNames)) {
+        if (key) {
+            envMap[key] = value;
+        }
+    }
+    // Serialize back to file
+    const newLines = [];
+    // Try to preserve some order if keys already existed, or just rebuild
+    // For simplicity, we'll just rebuild based on current keys
+    for (const [key, value] of Object.entries(envMap)) {
+        newLines.push(`${key}=${value}`);
+    }
+    await fs.writeFile(envPath, newLines.join('\n') + '\n', 'utf-8');
+}
+export async function readEnvFile() {
+    const envPath = join(process.cwd(), '.env');
+    const envMap = {};
+    try {
+        const content = await fs.readFile(envPath, 'utf-8');
+        const lines = content.split('\n');
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed && !trimmed.startsWith('#') && trimmed.includes('=')) {
+                const index = trimmed.indexOf('=');
+                const key = trimmed.substring(0, index).trim();
+                const value = trimmed.substring(index + 1).trim();
+                envMap[key] = value;
+            }
+        }
+    }
+    catch {
+        // If file doesn't exist, return empty map
+    }
+    return envMap;
+}
+//# sourceMappingURL=env-manager.js.map

package/dist/utils/open-router-models.d.ts

@@ -0,0 +1,45 @@
+/**
+ * OpenRouter Models Manager
+ *
+ * Manages available models from @neovate/code's OpenRouter provider
+ * by fetching from the GitHub repository.
+ */
+import { Model } from '../types/models.js';
+/**
+ * OpenRouterModels manages access to OpenRouter models from @neovate/code
+ */
+export declare class OpenRouterModels {
+    private cache;
+    /**
+     * Create a new OpenRouterModels instance
+     */
+    constructor();
+    /**
+     * Get available models from @neovate/code
+     * Fetches the model list from the GitHub repository and parses the TypeScript source
+     *
+     * @returns Array of Model objects
+     * @throws Error if models cannot be fetched
+     */
+    getModels(): Promise<Model[]>;
+    /**
+     * Get a specific model by ID
+     * @param modelId - The model ID to fetch
+     * @returns Model object or null if not found
+     */
+    getModelById(modelId: string): Promise<Model | null>;
+    /**
+     * Clear the cache
+     */
+    clearCache(): void;
+}
+/**
+ * Get or create the singleton instance
+ * @returns OpenRouterModels instance
+ */
+export declare function getOpenRouterModels(): OpenRouterModels;
+/**
+ * Reset the singleton instance (useful for testing)
+ */
+export declare function resetOpenRouterModels(): void;
+//# sourceMappingURL=open-router-models.d.ts.map

package/dist/utils/open-router-models.js

@@ -0,0 +1,103 @@
+/**
+ * OpenRouter Models Manager
+ *
+ * Manages available models from @neovate/code's OpenRouter provider
+ * by fetching from the GitHub repository.
+ */
+/** URL to fetch OpenRouter models from @neovate/code repository */
+const OPENROUTER_MODELS_URL = 'https://raw.githubusercontent.com/neovateai/neovate-code/main/src/provider/providers/openrouter.ts';
+/**
+ * OpenRouterModels manages access to OpenRouter models from @neovate/code
+ */
+export class OpenRouterModels {
+    cache = null;
+    /**
+     * Create a new OpenRouterModels instance
+     */
+    constructor() {
+        // No API key needed - models loaded from @neovate/code repository
+    }
+    /**
+     * Get available models from @neovate/code
+     * Fetches the model list from the GitHub repository and parses the TypeScript source
+     *
+     * @returns Array of Model objects
+     * @throws Error if models cannot be fetched
+     */
+    async getModels() {
+        // Return cached data if available
+        if (this.cache) {
+            return this.cache;
+        }
+        try {
+            const response = await fetch(OPENROUTER_MODELS_URL);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch: ${response.status} ${response.statusText}`);
+            }
+            const source = await response.text();
+            // Extract model IDs from the TypeScript source
+            // Pattern: 'model-id': { ... },
+            const modelPattern = /'([a-z-]+\/[a-z0-9.]+)':/gi;
+            const modelIds = new Set();
+            let match;
+            while ((match = modelPattern.exec(source)) !== null) {
+                modelIds.add(match[1]);
+            }
+            // Transform to Model interface
+            const models = Array.from(modelIds)
+                .sort()
+                .map((id) => ({
+                id,
+                name: id,
+                description: `OpenRouter model: ${id}`,
+                provider: 'openrouter',
+                pricing: {
+                    prompt: 0,
+                    completion: 0,
+                },
+            }));
+            // Store in cache
+            this.cache = models;
+            return models;
+        }
+        catch (error) {
+            throw new Error(`Failed to load OpenRouter models: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Get a specific model by ID
+     * @param modelId - The model ID to fetch
+     * @returns Model object or null if not found
+     */
+    async getModelById(modelId) {
+        const models = await this.getModels();
+        return models.find((m) => m.id === modelId) || null;
+    }
+    /**
+     * Clear the cache
+     */
+    clearCache() {
+        this.cache = null;
+    }
+}
+/**
+ * Singleton instance for global access
+ */
+let instance = null;
+/**
+ * Get or create the singleton instance
+ * @returns OpenRouterModels instance
+ */
+export function getOpenRouterModels() {
+    if (!instance) {
+        instance = new OpenRouterModels();
+    }
+    return instance;
+}
+/**
+ * Reset the singleton instance (useful for testing)
+ */
+export function resetOpenRouterModels() {
+    instance = null;
+}
+//# sourceMappingURL=open-router-models.js.map

package/dist/utils/openai-models.d.ts

@@ -0,0 +1,63 @@
+/**
+ * OpenAI Models Fetcher
+ *
+ * Handles fetching available models from OpenAI API
+ * with local caching and TTL management.
+ */
+import { Model } from '../types/models.js';
+/**
+ * OpenAIModels manages fetching and caching of OpenAI models
+ */
+export declare class OpenAIModels {
+    private cache;
+    private cacheTTL;
+    private apiKey;
+    /**
+     * Create a new OpenAIModels instance
+     * @param apiKey - OpenAI API key (optional, will be fetched from OPENAI_API_KEY env var)
+     */
+    constructor(apiKey?: string);
+    /**
+     * Set the API key
+     * @param apiKey - OpenAI API key
+     */
+    setApiKey(apiKey: string): void;
+    /**
+     * Check if cache is valid
+     * @returns true if cache exists and is not expired
+     */
+    private isCacheValid;
+    /**
+     * Set cache TTL in milliseconds
+     * @param ttl - Time to live in milliseconds
+     */
+    setCacheTTL(ttl: number): void;
+    /**
+     * Clear the cache
+     */
+    clearCache(): void;
+    /**
+     * Fetch available models from OpenAI API
+     * Uses cache if valid, otherwise fetches fresh data
+     *
+     * API Reference: https://platform.openai.com/docs/api-reference/models/list
+     *
+     * @returns Array of Model objects
+     * @throws Error if API key is not set or API call fails
+     */
+    getModels(): Promise<Model[]>;
+    /**
+     * Format model ID to a readable name
+     * @param modelId - The model ID
+     * @returns Formatted model name
+     */
+    private formatModelName;
+    /**
+     * Get a specific model by ID
+     * @param modelId - The model ID to fetch
+     * @returns Model object or null if not found
+     */
+    getModelById(modelId: string): Promise<Model | null>;
+}
+export declare function getOpenAIModels(): OpenAIModels;
+//# sourceMappingURL=openai-models.d.ts.map

package/dist/utils/openai-models.js

@@ -0,0 +1,152 @@
+/**
+ * OpenAI Models Fetcher
+ *
+ * Handles fetching available models from OpenAI API
+ * with local caching and TTL management.
+ */
+/**
+ * OpenAIModels manages fetching and caching of OpenAI models
+ */
+export class OpenAIModels {
+    cache = null;
+    cacheTTL = 1000 * 60 * 60; // 1 hour in milliseconds
+    apiKey = null;
+    /**
+     * Create a new OpenAIModels instance
+     * @param apiKey - OpenAI API key (optional, will be fetched from OPENAI_API_KEY env var)
+     */
+    constructor(apiKey) {
+        this.apiKey = apiKey || process.env.OPENAI_API_KEY || null;
+    }
+    /**
+     * Set the API key
+     * @param apiKey - OpenAI API key
+     */
+    setApiKey(apiKey) {
+        this.apiKey = apiKey;
+        // Invalidate cache when API key changes
+        this.cache = null;
+    }
+    /**
+     * Check if cache is valid
+     * @returns true if cache exists and is not expired
+     */
+    isCacheValid() {
+        if (!this.cache) {
+            return false;
+        }
+        const now = Date.now();
+        return now - this.cache.timestamp < this.cacheTTL;
+    }
+    /**
+     * Set cache TTL in milliseconds
+     * @param ttl - Time to live in milliseconds
+     */
+    setCacheTTL(ttl) {
+        this.cacheTTL = ttl;
+    }
+    /**
+     * Clear the cache
+     */
+    clearCache() {
+        this.cache = null;
+    }
+    /**
+     * Fetch available models from OpenAI API
+     * Uses cache if valid, otherwise fetches fresh data
+     *
+     * API Reference: https://platform.openai.com/docs/api-reference/models/list
+     *
+     * @returns Array of Model objects
+     * @throws Error if API key is not set or API call fails
+     */
+    async getModels() {
+        // Return cached data if valid
+        if (this.isCacheValid() && this.cache) {
+            return this.cache.models;
+        }
+        if (!this.apiKey) {
+            throw new Error('OpenAI API key is not set. Please set OPENAI_API_KEY environment variable or provide it to the constructor.');
+        }
+        try {
+            const response = await fetch('https://api.openai.com/v1/models', {
+                method: 'GET',
+                headers: {
+                    'Authorization': `Bearer ${this.apiKey}`,
+                },
+            });
+            if (!response.ok) {
+                throw new Error(`OpenAI API error: ${response.status} ${response.statusText}`);
+            }
+            const data = (await response.json());
+            // Transform OpenAI response to our Model interface
+            // Only includes models that are likely suitable for chat/completion
+            const models = data.data
+                .filter((item) => {
+                // Filter to only include gpt models and models suitable for API use
+                const id = item.id.toLowerCase();
+                return id.includes('gpt') && !id.includes('vision-request') && !id.includes('dall-e');
+            })
+                .map((item) => ({
+                id: item.id,
+                name: this.formatModelName(item.id),
+                description: `OpenAI model: ${item.id}`,
+                provider: 'openai',
+                pricing: {
+                    prompt: 0, // OpenAI API doesn't provide pricing in the models list
+                    completion: 0, // Users should check pricing on OpenAI's website
+                },
+            }));
+            // Store in cache
+            this.cache = {
+                models,
+                timestamp: Date.now(),
+            };
+            return models;
+        }
+        catch (error) {
+            throw new Error(`Failed to fetch OpenAI models: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Format model ID to a readable name
+     * @param modelId - The model ID
+     * @returns Formatted model name
+     */
+    formatModelName(modelId) {
+        // Convert "gpt-4-turbo" to "GPT-4 Turbo"
+        return modelId
+            .split('-')
+            .map((part) => {
+            if (part === 'gpt')
+                return 'GPT';
+            // Handle version numbers like "4turbo"
+            if (part === part.toLowerCase() && /^\d+/.test(part)) {
+                return part.charAt(0).toUpperCase() + part.slice(1);
+            }
+            return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
+        })
+            .join(' ')
+            .replace(/\s+/g, ' ');
+    }
+    /**
+     * Get a specific model by ID
+     * @param modelId - The model ID to fetch
+     * @returns Model object or null if not found
+     */
+    async getModelById(modelId) {
+        const models = await this.getModels();
+        return models.find((m) => m.id === modelId) || null;
+    }
+}
+/**
+ * Get or create a singleton OpenAIModels instance
+ */
+let instance = null;
+export function getOpenAIModels() {
+    if (!instance) {
+        instance = new OpenAIModels();
+    }
+    return instance;
+}
+//# sourceMappingURL=openai-models.js.map

package/dist/utils/openai-pricing-scraper.d.ts

@@ -0,0 +1,17 @@
+/**
+ * OpenAI Pricing Scraper
+ *
+ * Scrapes pricing information from OpenAI's pricing page and caches it locally for 24 hours.
+ * This is necessary because the OpenAI API doesn't return pricing in the models list.
+ */
+import type { ModelInfoPricing } from '../model-info.js';
+/**
+ * Get OpenAI pricing with caching.
+ * Returns cached pricing if available and fresh, otherwise attempts to scrape and cache new data.
+ * Falls back to hardcoded pricing if scraping fails (due to Cloudflare or other blocks).
+ *
+ * @param cacheDir - Directory to store cache file (typically .metadata)
+ * @returns Map of model name -> ModelInfoPricing
+ */
+export declare function getOpenAIPricing(cacheDir: string): Promise<Map<string, ModelInfoPricing>>;
+//# sourceMappingURL=openai-pricing-scraper.d.ts.map

package/dist/utils/openai-pricing-scraper.js

@@ -0,0 +1,185 @@
+/**
+ * OpenAI Pricing Scraper
+ *
+ * Scrapes pricing information from OpenAI's pricing page and caches it locally for 24 hours.
+ * This is necessary because the OpenAI API doesn't return pricing in the models list.
+ */
+import { promises as fs } from 'fs';
+import { join } from 'path';
+const PRICING_URL = 'https://openai.com/api/pricing';
+const CACHE_DURATION_MS = 24 * 60 * 60 * 1000; // 24 hours
+// Fallback pricing data in case scraping fails or Cloudflare blocks access
+// Source: OpenAI's public pricing page (manually curated)
+// Updated: February 2026
+const FALLBACK_PRICING = {
+    'gpt-4-turbo': { input: 0.000010, output: 0.000030 },
+    'gpt-4': { input: 0.000030, output: 0.000060 },
+    'gpt-4.1': { input: 0.000003, output: 0.000012 },
+    'gpt-4o': { input: 0.000005, output: 0.000015 },
+    'gpt-4o-mini': { input: 0.00000015, output: 0.0000006 },
+    'gpt-3.5-turbo': { input: 0.0000005, output: 0.0000015 },
+    'o1': { input: 0.000015, output: 0.000060 },
+    'o1-mini': { input: 0.000003, output: 0.000012 },
+};
+/** Strip HTML tags and normalize whitespace */
+function stripTags(html) {
+    return html.replace(/<[^>]*>/g, '').replace(/\s+/g, ' ').trim();
+}
+/** Parse price from text (e.g., "$0.005 / 1M tokens" -> 0.000005) */
+function parsePrice(text) {
+    if (!text)
+        return undefined;
+    const match = text.match(/[\d.]+/);
+    if (!match)
+        return undefined;
+    const price = Number(match[0]);
+    // Convert from price per 1M tokens to price per token
+    return price / 1_000_000;
+}
+/** Fetch and parse pricing from OpenAI's pricing page */
+async function scrapePricingFromWeb() {
+    console.log('[OpenAI Pricing] Fetching pricing from', PRICING_URL);
+    const response = await fetch(PRICING_URL, {
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch pricing page: ${response.status}`);
+    }
+    const html = await response.text();
+    const pricing = {
+        currency: 'USD',
+        unit: 'per_token',
+        last_updated: new Date().toISOString(),
+        text_models: {},
+    };
+    // Extract all tables
+    const tables = [...html.matchAll(/<table[\s\S]*?<\/table>/gi)];
+    console.log(`[OpenAI Pricing] Found ${tables.length} tables`);
+    for (const tableMatch of tables) {
+        const table = tableMatch[0];
+        // Extract rows
+        const rows = [...table.matchAll(/<tr[\s\S]*?<\/tr>/gi)];
+        for (const rowMatch of rows) {
+            const cells = [...rowMatch[0].matchAll(/<t[hd][\s\S]*?<\/t[hd]>/gi)].map((c) => stripTags(c[0]));
+            if (cells.length < 2)
+                continue;
+            const [model, input, cached, output] = cells;
+            console.log(`[OpenAI Pricing] Parsed row - model: "${model}", input: "${input}", cached: "${cached}", output: "${output}"`);
+            const inputPrice = parsePrice(input);
+            const cachedPrice = parsePrice(cached);
+            const outputPrice = parsePrice(output);
+            if (!model || (!inputPrice && !cachedPrice && !outputPrice))
+                continue;
+            pricing.text_models[model] = {
+                ...(inputPrice !== undefined && { input: inputPrice }),
+                ...(cachedPrice !== undefined && { cached_input: cachedPrice }),
+                ...(outputPrice !== undefined && { output: outputPrice }),
+            };
+            if (Object.keys(pricing.text_models).length % 5 === 0) {
+                console.log(`[OpenAI Pricing] Parsed ${Object.keys(pricing.text_models).length} models...`);
+            }
+        }
+    }
+    console.log(`[OpenAI Pricing] Successfully scraped ${Object.keys(pricing.text_models).length} models`);
+    return pricing;
+}
+/** Check if cache file exists and is fresh */
+async function isCacheFresh(cacheFile) {
+    try {
+        const stats = await fs.stat(cacheFile);
+        const age = Date.now() - stats.mtime.getTime();
+        const isFresh = age < CACHE_DURATION_MS;
+        console.log(`[OpenAI Pricing] Cache age: ${Math.round(age / 1000 / 60)} minutes, fresh: ${isFresh}`);
+        return isFresh;
+    }
+    catch {
+        console.log('[OpenAI Pricing] No cache file found');
+        return false;
+    }
+}
+/** Read cached pricing from file */
+async function readCachedPricing(cacheFile) {
+    const content = await fs.readFile(cacheFile, 'utf-8');
+    return JSON.parse(content);
+}
+/** Write pricing cache to file */
+async function writeCachedPricing(cacheFile, pricing) {
+    const dir = cacheFile.substring(0, cacheFile.lastIndexOf('/'));
+    await fs.mkdir(dir, { recursive: true });
+    await fs.writeFile(cacheFile, JSON.stringify(pricing, null, 2));
+}
+/**
+ * Get OpenAI pricing with caching.
+ * Returns cached pricing if available and fresh, otherwise attempts to scrape and cache new data.
+ * Falls back to hardcoded pricing if scraping fails (due to Cloudflare or other blocks).
+ *
+ * @param cacheDir - Directory to store cache file (typically .metadata)
+ * @returns Map of model name -> ModelInfoPricing
+ */
+export async function getOpenAIPricing(cacheDir) {
+    const cacheFile = join(cacheDir, 'openai-pricing.json');
+    const result = new Map();
+    try {
+        let pricing = null;
+        // Try to use cache if it's fresh
+        if (await isCacheFresh(cacheFile)) {
+            try {
+                pricing = await readCachedPricing(cacheFile);
+                console.log('[OpenAI Pricing] Using cached pricing');
+            }
+            catch (error) {
+                console.error('[OpenAI Pricing] Error reading cache:', error);
+                pricing = null;
+            }
+        }
+        // Scrape if we don't have fresh cache
+        if (!pricing) {
+            try {
+                pricing = await scrapePricingFromWeb();
+                try {
+                    await writeCachedPricing(cacheFile, pricing);
+                    console.log('[OpenAI Pricing] Cached pricing to', cacheFile);
+                }
+                catch (error) {
+                    console.error('[OpenAI Pricing] Error writing cache:', error);
+                }
+            }
+            catch (error) {
+                console.error('[OpenAI Pricing] Error scraping pricing, using fallback data:', error);
+                // Use fallback pricing
+                for (const [model, prices] of Object.entries(FALLBACK_PRICING)) {
+                    result.set(model, {
+                        prompt: prices.input,
+                        completion: prices.output,
+                    });
+                }
+                console.log(`[OpenAI Pricing] Using fallback pricing for ${result.size} models`);
+                return result;
+            }
+        }
+        // Convert to ModelInfoPricing format
+        for (const [model, prices] of Object.entries(pricing.text_models)) {
+            if (prices.input !== undefined && prices.output !== undefined) {
+                result.set(model, {
+                    prompt: prices.input,
+                    completion: prices.output,
+                });
+            }
+        }
+        console.log(`[OpenAI Pricing] Loaded pricing for ${result.size} models`);
+    }
+    catch (error) {
+        console.error('[OpenAI Pricing] Unexpected error getting pricing, using fallback:', error);
+        // Use fallback pricing as last resort
+        for (const [model, prices] of Object.entries(FALLBACK_PRICING)) {
+            result.set(model, {
+                prompt: prices.input,
+                completion: prices.output,
+            });
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=openai-pricing-scraper.js.map

package/dist/utils/validation.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Validation utilities for thread and project names
+ */
+export declare const MAX_THREAD_NAME_LENGTH = 256;
+/**
+ * Validates a thread name
+ * Returns an error message if invalid, or null if valid
+ */
+export declare function validateThreadName(name: string | undefined): string | null;
+//# sourceMappingURL=validation.d.ts.map

package/dist/utils/validation.js

@@ -0,0 +1,20 @@
+/**
+ * Validation utilities for thread and project names
+ */
+export const MAX_THREAD_NAME_LENGTH = 256;
+/**
+ * Validates a thread name
+ * Returns an error message if invalid, or null if valid
+ */
+export function validateThreadName(name) {
+    // Empty or whitespace-only is allowed (will auto-generate)
+    if (!name || name.trim() === '') {
+        return null;
+    }
+    // Check length
+    if (name.length > MAX_THREAD_NAME_LENGTH) {
+        return `Thread name must be ${MAX_THREAD_NAME_LENGTH} characters or less`;
+    }
+    return null;
+}
+//# sourceMappingURL=validation.js.map

package/dist/utils.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Utility functions for the CLI
+ */
+/**
+ * Delays execution for a specified number of milliseconds
+ * @param ms - Number of milliseconds to delay
+ * @returns Promise that resolves after the delay
+ */
+export declare function delay(ms: number): Promise<void>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.js

@@ -0,0 +1,12 @@
+/**
+ * Utility functions for the CLI
+ */
+/**
+ * Delays execution for a specified number of milliseconds
+ * @param ms - Number of milliseconds to delay
+ * @returns Promise that resolves after the delay
+ */
+export function delay(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+//# sourceMappingURL=utils.js.map