codehere 0.8.0 → 1.0.2

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

@@ -1,104 +0,0 @@
-/**
- * Cost Router
- *
- * Given a trust score and task complexity, recommends the cheapest model
- * that's safe to use. The 42x cost difference between Haiku and Opus means
- * routing decisions have real financial impact at scale.
- *
- * Model tiers (approximate $/M output tokens, 2026):
- *   fast tier    (e.g. claude-haiku-4-5)    $1.25    — cheap, good for simple tasks
- *   balanced tier (e.g. claude-sonnet-4-6)  $15.00   — good for most tasks
- *   max tier     (e.g. claude-opus-4-6)     $75.00   — strongest, use sparingly
- *
- * Routing logic:
- *   trust >= 90, simple task  → fast tier      (60x cheaper than max tier)
- *   trust >= 75, any task     → balanced tier  (5x cheaper than max tier)
- *   trust < 75, or critical   → balanced tier with human review flag
- *   critical findings present → block before reaching model
- */
-const MODEL_COSTS = {
-    haiku: 1.25,
-    sonnet: 15.0,
-    opus: 75.0,
-};
-const MODEL_IDS = {
-    haiku: 'claude-haiku-4-5-20251001',
-    sonnet: 'claude-sonnet-4-6',
-    opus: 'claude-opus-4-6',
-};
-const TIER_LABELS = {
-    haiku: 'fast tier',
-    sonnet: 'balanced tier',
-    opus: 'max tier',
-};
-function savingsLabel(chosen) {
-    if (chosen === 'opus')
-        return 'max tier (baseline)';
-    const ratio = MODEL_COSTS.opus / MODEL_COSTS[chosen];
-    return `${TIER_LABELS[chosen]} · ${Math.round(ratio)}x cheaper than max tier`;
-}
-/**
- * Recommend the optimal model for a given trust score and task complexity.
- */
-export function recommendModel(trustScore, complexity = 'standard', criticalFindings = 0) {
-    // Critical findings → require human review regardless of model
-    if (criticalFindings > 0) {
-        return {
-            model: 'sonnet',
-            modelId: MODEL_IDS.sonnet,
-            reason: `${criticalFindings} critical finding${criticalFindings !== 1 ? 's' : ''} — human review required before applying any edit`,
-            costPer1MTokens: MODEL_COSTS.sonnet,
-            savingsVsOpus: savingsLabel('sonnet'),
-            humanReview: true,
-        };
-    }
-    // High-trust simple tasks → Haiku
-    if (trustScore >= 90 && complexity === 'simple') {
-        return {
-            model: 'haiku',
-            modelId: MODEL_IDS.haiku,
-            reason: `Trust ${trustScore}/100 · simple task — safe for fastest, cheapest model`,
-            costPer1MTokens: MODEL_COSTS.haiku,
-            savingsVsOpus: savingsLabel('haiku'),
-            humanReview: false,
-        };
-    }
-    // Good trust, standard task → Sonnet
-    if (trustScore >= 75) {
-        return {
-            model: 'sonnet',
-            modelId: MODEL_IDS.sonnet,
-            reason: `Trust ${trustScore}/100 · ${complexity} task — Sonnet is the right balance`,
-            costPer1MTokens: MODEL_COSTS.sonnet,
-            savingsVsOpus: savingsLabel('sonnet'),
-            humanReview: false,
-        };
-    }
-    // Low trust → Sonnet with human review
-    return {
-        model: 'sonnet',
-        modelId: MODEL_IDS.sonnet,
-        reason: `Trust ${trustScore}/100 — lower confidence; recommend reviewing the output`,
-        costPer1MTokens: MODEL_COSTS.sonnet,
-        savingsVsOpus: savingsLabel('sonnet'),
-        humanReview: true,
-    };
-}
-/**
- * Estimate monthly savings from routing decisions.
- * @param avgTokensPerTask Average output tokens per AI task
- * @param tasksPerMonth Monthly task volume
- * @param distribution Fraction of tasks at each tier
- */
-export function estimateMonthlySavings(avgTokensPerTask = 2000, tasksPerMonth = 500, distribution = { haiku: 0.4, sonnet: 0.55, opus: 0.05 }) {
-    const tokensMillion = avgTokensPerTask / 1_000_000;
-    let routedCost = 0;
-    for (const [tier, fraction] of Object.entries(distribution)) {
-        routedCost += fraction * tasksPerMonth * tokensMillion * MODEL_COSTS[tier];
-    }
-    const opusCost = tasksPerMonth * tokensMillion * MODEL_COSTS.opus;
-    const saving = opusCost - routedCost;
-    const savingPct = (saving / opusCost) * 100;
-    return { routedCost, opusCost, saving, savingPct };
-}
-//# sourceMappingURL=cost-router.js.map

package/dist/infrastructure/cost/spend-aggregator.js

@@ -1,147 +0,0 @@
-/**
- * v0.6 S3 slice 1 — spend-today aggregator.
- *
- * Reads ~/.codehere/sessions.jsonl (the same append-only log session-persistence
- * writes), filters completed records to today (local timezone), and estimates
- * dollar spend per agent based on token usage × per-tier output-rate ceilings.
- *
- * Why · claim_market_position v3 lists "cost-bounded execution" as one of the
- * few capture-strategy edges still possibly open. Demonstrating cost awareness
- * starts here: surface what the user has actually spent today across all spawned
- * agents, then (slice 2) enforce a per-day ceiling.
- *
- * Why estimates not exact · codehere doesn't see provider invoices. Adapters
- * report token counts via TaskArtifacts.usage; we multiply by published tier
- * ceilings. Per feedback_overconfidence_guard.md, copy frames this as
- * "estimate" and points to vendor dashboards as authoritative.
- *
- * Cost table · output-tier ceilings (input is rougher; we use a 5x ratio).
- * All values 2026 published rates. When a model isn't surfaced in usage,
- * default to the agent's typical tier.
- */
-import { existsSync, readFileSync } from 'fs';
-import { homedir } from 'os';
-import { join } from 'path';
-/** Resolved at call time, not module load, so test setups that swap $HOME
- *  after import still get a fresh path on each invocation. */
-function sessionsFile() {
-    return join(process.env.CODEHERE_HOME || homedir(), '.codehere', 'sessions.jsonl');
-}
-/** USD per million OUTPUT tokens at the agent's typical 2026 tier. Input is
- *  estimated at 1/5 of output rate (Anthropic + OpenAI both publish ~5x
- *  output:input ratios on their flagship coding tiers). Cache reads ~1/10
- *  of input. Free-tier agents → 0.
- *
- *  Conservative-ceiling philosophy: better to over-estimate spend than
- *  under-promise and miss a real bill. */
-const COST_PER_M_OUTPUT_TOKENS_USD = {
-    'claude-code': 15.0, // Sonnet 4.6 baseline
-    codex: 10.0, // GPT-5 / codex baseline
-    aider: 15.0, // typically Sonnet
-    gemini: 0, // free tier (Google AI Studio)
-    opencode: 0, // typically free local / NIM-routed
-    conductor: 15.0, // routes to Claude Code by default
-};
-const INPUT_RATE_RATIO = 0.2; // input ≈ 1/5 of output
-const CACHE_READ_RATIO = 0.1; // cache reads ≈ 1/10 of input (so 1/50 output)
-/**
- * Estimate dollar cost for one session's token usage at one agent's typical tier.
- * Returns 0 for free-tier agents and unknown agents (no mapping → no estimate).
- */
-export function estimateCostUsd(agent, usage) {
-    if (!usage)
-        return 0;
-    const outputRate = COST_PER_M_OUTPUT_TOKENS_USD[agent];
-    if (outputRate === undefined || outputRate === 0)
-        return 0;
-    const inputRate = outputRate * INPUT_RATE_RATIO;
-    const cacheReadRate = inputRate * CACHE_READ_RATIO;
-    // Cache CREATION is billed at input rate (Anthropic). Use same default.
-    const tokens = {
-        input: Math.max(0, usage.inputTokens || 0),
-        output: Math.max(0, usage.outputTokens || 0),
-        cacheRead: Math.max(0, usage.cacheReadTokens || 0),
-        cacheCreate: Math.max(0, usage.cacheCreationTokens || 0),
-    };
-    return ((tokens.input / 1_000_000) * inputRate +
-        (tokens.output / 1_000_000) * outputRate +
-        (tokens.cacheRead / 1_000_000) * cacheReadRate +
-        (tokens.cacheCreate / 1_000_000) * inputRate);
-}
-/** Return the millisecond timestamp for the start of "today" in local time. */
-function startOfTodayLocalMs(now = new Date()) {
-    const d = new Date(now);
-    d.setHours(0, 0, 0, 0);
-    return d.getTime();
-}
-/**
- * Walk sessions.jsonl, sum estimated USD spend for sessions whose
- * `completedAt` falls within today (local). Best-effort: missing file =
- * empty report; parse errors per-line ignored. Pairs spawned + completed
- * by id so we know which agent spent what.
- */
-export function computeSpendToday(now = new Date()) {
-    const cutoff = startOfTodayLocalMs(now);
-    const empty = {
-        totalUsd: 0,
-        tokens: { input: 0, output: 0, cache: 0 },
-        sessionCount: 0,
-        byAgent: {},
-        windowStartedAt: cutoff,
-    };
-    if (!existsSync(sessionsFile()))
-        return empty;
-    let content;
-    try {
-        content = readFileSync(sessionsFile(), 'utf-8');
-    }
-    catch {
-        return empty;
-    }
-    // Pair spawned (carries agent) with completed (carries usage + completedAt).
-    const spawnedAgent = new Map();
-    const report = { ...empty, byAgent: {} };
-    for (const line of content.split('\n')) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        let rec;
-        try {
-            rec = JSON.parse(trimmed);
-        }
-        catch {
-            continue;
-        }
-        if (rec.t === 'spawned' && rec.id && rec.agent) {
-            spawnedAgent.set(rec.id, rec.agent);
-            continue;
-        }
-        if (rec.t !== 'completed' || !rec.id)
-            continue;
-        if (typeof rec.completedAt !== 'number' || rec.completedAt < cutoff)
-            continue;
-        const agent = spawnedAgent.get(rec.id);
-        if (!agent)
-            continue;
-        const usage = rec.artifacts?.usage;
-        const usd = estimateCostUsd(agent, usage);
-        report.sessionCount += 1;
-        if (usage) {
-            report.tokens.input += usage.inputTokens || 0;
-            report.tokens.output += usage.outputTokens || 0;
-            report.tokens.cache += (usage.cacheReadTokens || 0) + (usage.cacheCreationTokens || 0);
-        }
-        report.totalUsd += usd;
-        const cur = report.byAgent[agent] || { usd: 0, sessions: 0 };
-        cur.usd += usd;
-        cur.sessions += 1;
-        report.byAgent[agent] = cur;
-    }
-    // Round totals to 4 decimals (1/100 of a cent) — final display rounds to 2.
-    report.totalUsd = Math.round(report.totalUsd * 10_000) / 10_000;
-    for (const k of Object.keys(report.byAgent)) {
-        report.byAgent[k].usd = Math.round(report.byAgent[k].usd * 10_000) / 10_000;
-    }
-    return report;
-}
-//# sourceMappingURL=spend-aggregator.js.map