codehere 0.2.1 → 0.3.0-rc.1

package/dist/infrastructure/cost/cost-tracker.js

@@ -1,360 +0,0 @@
-/**
- * Infrastructure: Cost Tracker
- * Tracks API costs per operation and provides budget alerts
- *
- * IMPORTANT: This is a LOCAL ESTIMATE based on token counts and pricing.
- * It does NOT sync with actual Cohere billing dashboard.
- * Use `codehere cost reset` to reset for new billing period.
- *
- * Clean Architecture: Infrastructure Layer
- * Strategic: Provides cost visibility and budget alerts (local estimate only)
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import initSqlJs from 'sql.js';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-// Cohere pricing (as of 2024, update as needed)
-// These are approximate - check Cohere pricing page for exact rates
-const PRICING = {
-    'command-r-plus': {
-        input: 0.000003, // $3 per 1M input tokens
-        output: 0.000015, // $15 per 1M output tokens
-    },
-    'command-r': {
-        input: 0.0000005, // $0.5 per 1M input tokens
-        output: 0.0000015, // $1.5 per 1M output tokens
-    },
-    'embed-english-v3.0': {
-        input: 0.0000001, // $0.1 per 1M tokens
-        output: 0,
-    },
-    'rerank-english-v3': {
-        input: 0.000001, // $1 per 1M tokens
-        output: 0,
-    },
-    'default': {
-        input: 0.000003, // Conservative default
-        output: 0.000015,
-    },
-};
-export class CostTracker {
-    db = null;
-    dbPath;
-    budgetLimit; // null = no budget limit
-    alertThreshold; // Alert at 80% of budget
-    // Default budget limit when no override is provided
-    static DEFAULT_BUDGET_LIMIT = 2.0;
-    constructor(budgetLimit, alertThreshold = 0.8) {
-        const agentDir = join(__dirname, '../../..');
-        const dataDir = join(agentDir, 'data');
-        if (!existsSync(dataDir)) {
-            mkdirSync(dataDir, { recursive: true });
-        }
-        this.dbPath = join(dataDir, 'costs.sqlite');
-        // Budget limit priority: explicit parameter > env var > default (2.0)
-        if (budgetLimit !== undefined) {
-            // Explicit parameter: null means no budget, otherwise use provided value if > 0
-            this.budgetLimit = (budgetLimit !== null && budgetLimit > 0) ? budgetLimit : null;
-        }
-        else {
-            // Check env var first
-            const envBudget = process.env.COHERE_BUDGET_LIMIT;
-            if (envBudget) {
-                const parsed = parseFloat(envBudget);
-                this.budgetLimit = (parsed > 0) ? parsed : null;
-            }
-            else {
-                // Default to 2.0 when no parameter and no env var
-                this.budgetLimit = CostTracker.DEFAULT_BUDGET_LIMIT;
-            }
-        }
-        this.alertThreshold = alertThreshold;
-    }
-    async getDb() {
-        if (this.db)
-            return this.db;
-        const SQL = await initSqlJs();
-        const dbDir = dirname(this.dbPath);
-        if (!existsSync(dbDir)) {
-            mkdirSync(dbDir, { recursive: true });
-        }
-        if (existsSync(this.dbPath)) {
-            const buffer = readFileSync(this.dbPath);
-            this.db = new SQL.Database(buffer);
-        }
-        else {
-            this.db = new SQL.Database();
-        }
-        // Initialize schema
-        this.db.run(`
-      CREATE TABLE IF NOT EXISTS costs (
-        id TEXT PRIMARY KEY,
-        timestamp INTEGER NOT NULL,
-        operation TEXT NOT NULL,
-        operation_type TEXT NOT NULL,
-        model TEXT,
-        input_tokens INTEGER,
-        output_tokens INTEGER,
-        cost REAL NOT NULL,
-        run_id TEXT,
-        metadata TEXT
-      );
-    `);
-        // Create indices (sql.js doesn't support CREATE INDEX IF NOT EXISTS, so we'll handle errors)
-        try {
-            this.db.run('CREATE INDEX idx_timestamp ON costs(timestamp);');
-        }
-        catch { }
-        try {
-            this.db.run('CREATE INDEX idx_operation ON costs(operation);');
-        }
-        catch { }
-        try {
-            this.db.run('CREATE INDEX idx_run_id ON costs(run_id);');
-        }
-        catch { }
-        return this.db;
-    }
-    async saveDb() {
-        if (!this.db)
-            return;
-        const buffer = this.db.export();
-        writeFileSync(this.dbPath, buffer);
-    }
-    /**
-     * Calculate cost for an operation
-     */
-    calculateCost(operationType, model = 'default', inputTokens, outputTokens) {
-        const pricing = PRICING[model] || PRICING.default;
-        let cost = 0;
-        if (operationType === 'chat') {
-            const inputCost = (inputTokens || 0) * pricing.input;
-            const outputCost = (outputTokens || 0) * pricing.output;
-            cost = inputCost + outputCost;
-        }
-        else if (operationType === 'embed') {
-            cost = (inputTokens || 0) * pricing.input;
-        }
-        else if (operationType === 'rerank') {
-            cost = (inputTokens || 0) * pricing.input;
-        }
-        return cost;
-    }
-    /**
-     * Record a cost
-     */
-    async recordCost(record) {
-        const db = await this.getDb();
-        const id = `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
-        const timestamp = Date.now();
-        db.run(`
-      INSERT INTO costs (id, timestamp, operation, operation_type, model, input_tokens, output_tokens, cost, run_id, metadata)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    `, [
-            id,
-            timestamp,
-            record.operation,
-            record.operationType,
-            record.model || null,
-            record.inputTokens || null,
-            record.outputTokens || null,
-            record.cost,
-            record.runId || null,
-            record.metadata ? JSON.stringify(record.metadata) : null
-        ]);
-        await this.saveDb();
-        // Check budget and alert if needed
-        await this.checkBudget();
-    }
-    /**
-     * Get cost summary
-     */
-    async getSummary(timeRange) {
-        const db = await this.getDb();
-        let query = `
-      SELECT 
-        operation,
-        operation_type,
-        model,
-        COUNT(*) as count,
-        SUM(cost) as total_cost
-      FROM costs
-    `;
-        const params = [];
-        if (timeRange) {
-            query += ' WHERE timestamp >= ? AND timestamp <= ?';
-            params.push(timeRange.start, timeRange.end);
-        }
-        query += ' GROUP BY operation, operation_type, model';
-        const stmt = db.prepare(query);
-        if (params.length > 0) {
-            stmt.bind(params);
-        }
-        const rows = [];
-        while (stmt.step()) {
-            const row = stmt.getAsObject();
-            rows.push({
-                operation: row.operation,
-                operation_type: row.operation_type,
-                model: row.model,
-                count: row.count,
-                total_cost: row.total_cost,
-            });
-        }
-        stmt.free();
-        const byOperation = {};
-        const byModel = {};
-        let totalCost = 0;
-        let operationCount = 0;
-        rows.forEach(row => {
-            totalCost += row.total_cost;
-            operationCount += row.count;
-            if (!byOperation[row.operation]) {
-                byOperation[row.operation] = { count: 0, cost: 0 };
-            }
-            byOperation[row.operation].count += row.count;
-            byOperation[row.operation].cost += row.total_cost;
-            const modelKey = row.model || 'default';
-            if (!byModel[modelKey]) {
-                byModel[modelKey] = { count: 0, cost: 0 };
-            }
-            byModel[modelKey].count += row.count;
-            byModel[modelKey].cost += row.total_cost;
-        });
-        // Calculate daily and monthly costs
-        const now = Date.now();
-        const oneDayAgo = now - (24 * 60 * 60 * 1000);
-        const oneMonthAgo = now - (30 * 24 * 60 * 60 * 1000);
-        const dailyStmt = db.prepare('SELECT SUM(cost) as total FROM costs WHERE timestamp >= ?');
-        dailyStmt.bind([oneDayAgo]);
-        dailyStmt.step();
-        const dailyRow = dailyStmt.getAsObject();
-        dailyStmt.free();
-        const monthlyStmt = db.prepare('SELECT SUM(cost) as total FROM costs WHERE timestamp >= ?');
-        monthlyStmt.bind([oneMonthAgo]);
-        monthlyStmt.step();
-        const monthlyRow = monthlyStmt.getAsObject();
-        monthlyStmt.free();
-        return {
-            totalCost,
-            operationCount,
-            byOperation,
-            byModel,
-            dailyCost: dailyRow.total || 0,
-            monthlyCost: monthlyRow.total || 0,
-        };
-    }
-    /**
-     * Get costs for a specific run
-     */
-    async getRunCosts(runId) {
-        const db = await this.getDb();
-        const stmt = db.prepare('SELECT * FROM costs WHERE run_id = ? ORDER BY timestamp');
-        stmt.bind([runId]);
-        const rows = [];
-        while (stmt.step()) {
-            const row = stmt.getAsObject();
-            rows.push({
-                id: row.id,
-                timestamp: row.timestamp,
-                operation: row.operation,
-                operation_type: row.operation_type,
-                model: row.model,
-                input_tokens: row.input_tokens,
-                output_tokens: row.output_tokens,
-                cost: row.cost,
-                run_id: row.run_id,
-                metadata: row.metadata,
-            });
-        }
-        stmt.free();
-        return rows.map(row => ({
-            id: row.id,
-            timestamp: row.timestamp,
-            operation: row.operation,
-            operationType: row.operation_type,
-            model: row.model || undefined,
-            inputTokens: row.input_tokens || undefined,
-            outputTokens: row.output_tokens || undefined,
-            cost: row.cost,
-            runId: row.run_id || undefined,
-            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
-        }));
-    }
-    /**
-     * Check budget and alert if threshold exceeded
-     * NOTE: This does NOT block API calls - it only warns
-     */
-    async checkBudget() {
-        // Only check budget if limit is set
-        if (this.budgetLimit === null || this.budgetLimit <= 0) {
-            return;
-        }
-        const summary = await this.getSummary();
-        const percentage = (summary.totalCost / this.budgetLimit) * 100;
-        const threshold = this.budgetLimit * this.alertThreshold;
-        if (summary.totalCost >= threshold && summary.totalCost < this.budgetLimit) {
-            console.warn(`⚠️  Budget Alert (LOCAL ESTIMATE ONLY): $${summary.totalCost.toFixed(4)} / $${this.budgetLimit} (${percentage.toFixed(1)}%)`);
-            console.warn(`   This is a LOCAL ESTIMATE - check https://dashboard.cohere.com for actual usage`);
-            console.warn(`   API calls will continue. Run 'codehere cost reset' to reset local tracking.`);
-        }
-        else if (summary.totalCost >= this.budgetLimit) {
-            console.warn(`⚠️  Budget Exceeded (LOCAL ESTIMATE ONLY): $${summary.totalCost.toFixed(4)} / $${this.budgetLimit}`);
-            console.warn(`   This is a LOCAL ESTIMATE - check https://dashboard.cohere.com for actual usage`);
-            console.warn(`   API calls will continue. Run 'codehere cost reset' to reset local tracking.`);
-        }
-    }
-    /**
-     * Get current budget status
-     */
-    async getBudgetStatus() {
-        const summary = await this.getSummary();
-        if (this.budgetLimit === null || this.budgetLimit <= 0) {
-            return {
-                spent: summary.totalCost,
-                limit: null,
-                remaining: null,
-                percentage: null,
-                alert: false,
-            };
-        }
-        const remaining = Math.max(0, this.budgetLimit - summary.totalCost);
-        const percentage = (summary.totalCost / this.budgetLimit) * 100;
-        const alert = summary.totalCost >= (this.budgetLimit * this.alertThreshold);
-        return {
-            spent: summary.totalCost,
-            limit: this.budgetLimit,
-            remaining,
-            percentage,
-            alert,
-        };
-    }
-    /**
-     * Get budget limit
-     */
-    getBudgetLimit() {
-        return this.budgetLimit;
-    }
-    /**
-     * Reset costs (for testing or new billing period)
-     */
-    async resetCosts() {
-        const db = await this.getDb();
-        db.run('DELETE FROM costs');
-        await this.saveDb();
-    }
-}
-// Singleton instance
-let costTrackerInstance = null;
-export function getCostTracker(budgetLimit) {
-    if (!costTrackerInstance) {
-        // Only set budget if explicitly provided via env var or parameter
-        // null = no budget tracking (default behavior)
-        const budget = budgetLimit ?? (process.env.COHERE_BUDGET_LIMIT ? parseFloat(process.env.COHERE_BUDGET_LIMIT) : null);
-        costTrackerInstance = new CostTracker(budget);
-    }
-    return costTrackerInstance;
-}
-//# sourceMappingURL=cost-tracker.js.map

package/dist/infrastructure/file-scanner/file-scanner.js

@@ -1,106 +0,0 @@
-/**
- * Infrastructure: File Scanner
- * Scans repository for code files to index
- */
-import { readdirSync, statSync, existsSync } from 'fs';
-import { join, extname } from 'path';
-export class FileScanner {
-    CODE_EXTENSIONS = new Set([
-        '.ts', '.tsx', '.js', '.jsx', '.py', '.java', '.go', '.rs',
-        '.cpp', '.c', '.h', '.hpp', '.cs', '.rb', '.php', '.swift',
-        '.kt', '.scala', '.clj', '.sh', '.bash', '.zsh',
-    ]);
-    DOC_EXTENSIONS = new Set([
-        '.md', '.txt', '.rst', '.adoc',
-    ]);
-    IGNORE_PATTERNS = [
-        /^node_modules$/,
-        /^\.git$/,
-        /^\.next$/,
-        /^\.nuxt$/,
-        /^dist$/,
-        /^build$/,
-        /^\.build$/,
-        /^coverage$/,
-        /^\.coverage$/,
-        /^\.venv$/,
-        /^venv$/,
-        /^\.env$/,
-        /^\.DS_Store$/,
-        /^\.vscode$/,
-        /^\.idea$/,
-    ];
-    /**
-     * Scan repository for code files
-     */
-    async scan(repoPath) {
-        if (!existsSync(repoPath)) {
-            throw new Error(`Repository path does not exist: ${repoPath}`);
-        }
-        const files = [];
-        this.scanDirectory(repoPath, repoPath, files);
-        return files;
-    }
-    /**
-     * Recursively scan directory
-     */
-    scanDirectory(dirPath, basePath, files) {
-        try {
-            const entries = readdirSync(dirPath);
-            for (const entry of entries) {
-                const fullPath = join(dirPath, entry);
-                const relativePath = fullPath.replace(basePath + '/', '').replace(basePath, '');
-                // Skip ignored patterns
-                if (this.shouldIgnore(entry, relativePath)) {
-                    continue;
-                }
-                const stat = statSync(fullPath);
-                if (stat.isDirectory()) {
-                    // Recursively scan subdirectories
-                    this.scanDirectory(fullPath, basePath, files);
-                }
-                else if (stat.isFile()) {
-                    // Check if file is code or documentation
-                    if (this.isCodeFile(entry) || this.isDocFile(entry)) {
-                        files.push(fullPath);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // Skip directories we can't read (permissions, etc.)
-            console.warn(`Warning: Could not scan directory ${dirPath}:`, error instanceof Error ? error.message : String(error));
-        }
-    }
-    /**
-     * Check if file should be ignored
-     */
-    shouldIgnore(filename, relativePath) {
-        // Check ignore patterns
-        for (const pattern of this.IGNORE_PATTERNS) {
-            if (pattern.test(filename) || pattern.test(relativePath)) {
-                return true;
-            }
-        }
-        // Ignore hidden files (except .env.example, .gitignore, etc.)
-        if (filename.startsWith('.') && !['.env.example', '.gitignore', '.eslintrc', '.prettierrc'].includes(filename)) {
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Check if file is a code file
-     */
-    isCodeFile(filename) {
-        const ext = extname(filename).toLowerCase();
-        return this.CODE_EXTENSIONS.has(ext);
-    }
-    /**
-     * Check if file is a documentation file
-     */
-    isDocFile(filename) {
-        const ext = extname(filename).toLowerCase();
-        return this.DOC_EXTENSIONS.has(ext);
-    }
-}
-//# sourceMappingURL=file-scanner.js.map