tarsk 0.3.3 → 0.3.16

package/dist/routes/threads-old.js

@@ -1,393 +0,0 @@
-/**
- * Thread routes for the REST API
- *
- * Handles all thread-related operations:
- * - POST /api/threads - Create a new thread
- * - GET /api/threads?projectId=xxx - List threads for a project
- * - DELETE /api/threads/:id - Delete a thread
- */
-import { Hono } from 'hono';
-import { validateThreadName } from '../utils/validation.js';
-import { streamAsyncGenerator } from '../lib/stream-helper.js';
-const extractTextBlocksFromContent = (content) => {
-    const trimmed = content.trim();
-    if (!trimmed.startsWith('[') && !trimmed.startsWith('{')) {
-        return [];
-    }
-    try {
-        const parsed = JSON.parse(trimmed);
-        if (Array.isArray(parsed)) {
-            return parsed
-                .filter((block) => block && typeof block === 'object' && block.type === 'text')
-                .map((block) => (typeof block.text === 'string' ? block.text : ''))
-                .filter((text) => text.length > 0);
-        }
-        if (parsed && typeof parsed === 'object' && typeof parsed.text === 'string') {
-            return [parsed.text];
-        }
-    }
-    catch {
-        return [];
-    }
-    return [];
-};
-const extractAssistantContent = (events, fallback) => {
-    if (!events || events.length === 0) {
-        return fallback;
-    }
-    const resultEvent = [...events].reverse().find((event) => event.type === 'result');
-    if (resultEvent && typeof resultEvent.content === 'string' && resultEvent.content.trim().length > 0) {
-        return resultEvent.content;
-    }
-    const assistantMessages = events.filter((event) => event.type === 'message' && event.role === 'assistant');
-    let lastTextBlock = null;
-    const assistantChunks = [];
-    for (const event of assistantMessages) {
-        if (typeof event.content !== 'string') {
-            continue;
-        }
-        assistantChunks.push(event.content);
-        const textBlocks = extractTextBlocksFromContent(event.content);
-        if (textBlocks.length > 0) {
-            lastTextBlock = textBlocks[textBlocks.length - 1];
-        }
-    }
-    if (lastTextBlock) {
-        return lastTextBlock;
-    }
-    if (assistantChunks.length === 0) {
-        return fallback;
-    }
-    const combined = assistantChunks.join('');
-    return combined.trim().length > 0 ? combined : fallback;
-};
-export function createThreadRoutes(threadManager, gitManager, conversationManager) {
-    const router = new Hono();
-    /**
-     * POST /api/threads
-     * Create a new thread for a project
-     *
-     * Request body:
-     * {
-     *   "projectId": "uuid",
-     *   "title": "Optional thread title"
-     * }
-     *
-     * Response: Newline-delimited JSON stream of ThreadEvent objects
-     *
-     * Requirements:
-     * - 6.3 - THE CLI SHALL expose REST API endpoints for Thread operations
-     * - 8.3 - WHEN creating a Thread, THE App SHALL send a POST request with the Project identifier to the CLI
-     * - 8.4 - THE CLI SHALL support streaming responses to the client
-     */
-    router.post('/', async (c) => {
-        try {
-            const body = await c.req.json();
-            const { projectId, title } = body;
-            // Validate projectId is provided
-            if (!projectId || typeof projectId !== 'string') {
-                const errorResponse = {
-                    error: {
-                        code: 'INVALID_REQUEST',
-                        message: 'projectId is required and must be a string',
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 400);
-            }
-            // Validate title if provided
-            if (title !== undefined && typeof title !== 'string') {
-                const errorResponse = {
-                    error: {
-                        code: 'INVALID_REQUEST',
-                        message: 'title must be a string if provided',
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 400);
-            }
-            // Validate thread name (empty/whitespace is allowed, will auto-generate)
-            if (title && title.trim() !== '') {
-                const nameError = validateThreadName(title);
-                if (nameError) {
-                    const errorResponse = {
-                        error: {
-                            code: 'INVALID_REQUEST',
-                            message: nameError,
-                            timestamp: new Date().toISOString()
-                        }
-                    };
-                    return c.json(errorResponse, 400);
-                }
-                // Check for duplicate branch names
-                const existingThreads = await threadManager.listThreads(projectId);
-                const sanitizedNewName = gitManager.sanitizeBranchName(title);
-                const existingSanitized = existingThreads.map(t => gitManager.sanitizeBranchName(t.title));
-                if (existingSanitized.includes(sanitizedNewName)) {
-                    const errorResponse = {
-                        error: {
-                            code: 'DUPLICATE_BRANCH',
-                            message: `A thread with branch name "${sanitizedNewName}" already exists`,
-                            timestamp: new Date().toISOString()
-                        }
-                    };
-                    return c.json(errorResponse, 409);
-                }
-            }
-            // Stream the thread creation events
-            return streamAsyncGenerator(c, threadManager.createThread(projectId, title));
-        }
-        catch (error) {
-            const errorResponse = {
-                error: {
-                    code: 'REQUEST_PARSE_ERROR',
-                    message: 'Failed to parse request body',
-                    details: error instanceof Error ? error.message : String(error),
-                    timestamp: new Date().toISOString()
-                }
-            };
-            return c.json(errorResponse, 400);
-        }
-    });
-    /**
-     * GET /api/threads?projectId=xxx
-     * List all threads for a specific project
-     *
-     * Query parameters:
-     * - projectId (required): The project ID to filter threads
-     *
-     * Response:
-     * [
-     *   {
-     *     "id": "uuid",
-     *     "projectId": "uuid",
-     *     "title": "Thread title",
-     *     "path": "/path/to/thread",
-     *     "currentBranch": "branch-name",
-     *     "createdAt": "2024-01-01T00:00:00Z"
-     *   }
-     * ]
-     *
-     * Requirements:
-     * - 6.3 - THE CLI SHALL expose REST API endpoints for Thread operations
-     */
-    router.get('/', async (c) => {
-        try {
-            const projectId = c.req.query('projectId');
-            // Validate projectId is provided
-            if (!projectId) {
-                const errorResponse = {
-                    error: {
-                        code: 'INVALID_REQUEST',
-                        message: 'projectId query parameter is required',
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 400);
-            }
-            const threads = await threadManager.listThreads(projectId);
-            return c.json(threads);
-        }
-        catch (error) {
-            const errorResponse = {
-                error: {
-                    code: 'LIST_THREADS_ERROR',
-                    message: 'Failed to list threads',
-                    details: error instanceof Error ? error.message : String(error),
-                    timestamp: new Date().toISOString()
-                }
-            };
-            return c.json(errorResponse, 500);
-        }
-    });
-    /**
-     * DELETE /api/threads/:id
-     * Delete a thread
-     *
-     * Response:
-     * {
-     *   "success": true,
-     *   "message": "Thread deleted successfully"
-     * }
-     *
-     * Requirements:
-     * - 6.3 - THE CLI SHALL expose REST API endpoints for Thread operations
-     * - 8.4 - WHEN deleting a Thread, THE App SHALL send a DELETE request with the Thread identifier to the CLI
-     */
-    router.delete('/:id', async (c) => {
-        try {
-            const threadId = c.req.param('id');
-            if (!threadId) {
-                const errorResponse = {
-                    error: {
-                        code: 'INVALID_REQUEST',
-                        message: 'Thread ID is required',
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 400);
-            }
-            await threadManager.deleteThread(threadId);
-            return c.json({
-                success: true,
-                message: 'Thread deleted successfully'
-            });
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            // Check if it's a "not found" error
-            if (errorMessage.includes('not found')) {
-                const errorResponse = {
-                    error: {
-                        code: 'THREAD_NOT_FOUND',
-                        message: errorMessage,
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 404);
-            }
-            const errorResponse = {
-                error: {
-                    code: 'DELETE_THREAD_ERROR',
-                    message: 'Failed to delete thread',
-                    details: errorMessage,
-                    timestamp: new Date().toISOString()
-                }
-            };
-            return c.json(errorResponse, 500);
-        }
-    });
-    /**
-     * POST /api/threads/:id/select
-     * Select a thread as the active thread
-     *
-     * Response:
-     * {
-     *   "success": true,
-     *   "message": "Thread selected successfully",
-     *   "threadId": "uuid"
-     * }
-     *
-     * Requirements:
-     * - 6.3 - THE CLI SHALL expose REST API endpoints for Thread operations
-     */
-    router.post('/:id/select', async (c) => {
-        try {
-            const threadId = c.req.param('id');
-            if (!threadId) {
-                const errorResponse = {
-                    error: {
-                        code: 'INVALID_REQUEST',
-                        message: 'Thread ID is required',
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 400);
-            }
-            // Verify thread exists
-            const thread = await threadManager.getThread(threadId);
-            if (!thread) {
-                const errorResponse = {
-                    error: {
-                        code: 'THREAD_NOT_FOUND',
-                        message: `Thread not found: ${threadId}`,
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 404);
-            }
-            await threadManager.selectThread(threadId);
-            return c.json({
-                success: true,
-                message: 'Thread selected successfully',
-                threadId
-            });
-        }
-        catch (error) {
-            const errorResponse = {
-                error: {
-                    code: 'SELECT_THREAD_ERROR',
-                    message: 'Failed to select thread',
-                    details: error instanceof Error ? error.message : String(error),
-                    timestamp: new Date().toISOString()
-                }
-            };
-            return c.json(errorResponse, 500);
-        }
-    });
-    /**
-     * GET /api/threads/:id/messages
-     * Get chat history for a thread
-     */
-    router.get('/:id/messages', async (c) => {
-        try {
-            const threadId = c.req.param('id');
-            if (!threadId) {
-                const errorResponse = {
-                    error: {
-                        code: 'INVALID_REQUEST',
-                        message: 'Thread ID is required',
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 400);
-            }
-            const thread = await threadManager.getThread(threadId);
-            if (!thread) {
-                const errorResponse = {
-                    error: {
-                        code: 'THREAD_NOT_FOUND',
-                        message: `Thread not found: ${threadId}`,
-                        timestamp: new Date().toISOString()
-                    }
-                };
-                return c.json(errorResponse, 404);
-            }
-            const history = await conversationManager.getConversationHistory(thread.path);
-            if (!history || history.messages.length === 0) {
-                return c.json([]);
-            }
-            const messages = history.messages.flatMap((message) => {
-                const userMessage = {
-                    messageId: `user-${message.id}`,
-                    sender: 'user',
-                    content: message.request.message,
-                    contentType: 'text',
-                    timestamp: message.timestamp,
-                    model: message.request.model,
-                    attachments: message.request.attachments?.map((attachment) => ({
-                        fileName: attachment.name,
-                        content: attachment.content,
-                        size: attachment.size,
-                    }))
-                };
-                if (!message.response) {
-                    return [userMessage];
-                }
-                const agentMessage = {
-                    messageId: `agent-${message.id}`,
-                    sender: 'agent',
-                    content: extractAssistantContent(message.response.events, message.response.content),
-                    contentType: 'markdown',
-                    timestamp: message.response.completedAt,
-                    model: message.request.model,
-                };
-                return [userMessage, agentMessage];
-            });
-            return c.json(messages);
-        }
-        catch (error) {
-            const errorResponse = {
-                error: {
-                    code: 'GET_THREAD_MESSAGES_ERROR',
-                    message: 'Failed to load thread messages',
-                    details: error instanceof Error ? error.message : String(error),
-                    timestamp: new Date().toISOString()
-                }
-            };
-            return c.json(errorResponse, 500);
-        }
-    });
-    return router;
-}
-//# sourceMappingURL=threads-old.js.map

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

@@ -1,17 +0,0 @@
-/**
- * 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

@@ -1,185 +0,0 @@
-/**
- * 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