@wundam/orchex 1.0.0-rc.2 → 1.0.0-rc.21

package/dist/intelligence/cost-tracker.d.ts

@@ -1,114 +0,0 @@
-/**
- * Token cost tracking and estimation for Orchex Learn.
- * Provides cost estimation and aggregation for multi-provider token usage.
- */
-import type { TelemetryEvent } from '../telemetry/telemetry-types.js';
-/**
- * Token costs per 1000 tokens (in USD).
- * Prices as of February 2026 - should be updated periodically.
- *
- * Reference (per 1M tokens):
- * - DeepSeek V3.2:   $0.28 / $0.42   (~95% cheaper than Claude)
- * - Gemini 2.5 Pro:  $1.25 / $10.00  (~60% cheaper than Claude)
- * - Claude Sonnet:   $3.00 / $15.00  (baseline)
- * - OpenAI GPT-4o:   $5.00 / $15.00  (~40% more than Claude)
- * - Claude Opus:     $15.00 / $75.00 (5x Claude Sonnet)
- */
-export declare const TOKEN_COSTS: Record<string, {
-    input: number;
-    output: number;
-}>;
-/**
- * Cache discount rate for Anthropic prompt caching.
- * Cached tokens cost 90% less than regular input tokens.
- */
-export declare const CACHE_DISCOUNT_RATE = 0.9;
-/**
- * Cost estimate for a single execution.
- */
-export interface CostEstimate {
-    /** Number of input tokens */
-    inputTokens: number;
-    /** Number of output tokens */
-    outputTokens: number;
-    /** Cost for input tokens (USD) */
-    inputCost: number;
-    /** Cost for output tokens (USD) */
-    outputCost: number;
-    /** Total cost before cache savings (USD) */
-    totalCost: number;
-    /** Tokens read from cache (if applicable) */
-    cacheHitTokens?: number;
-    /** Estimated savings from cache (USD) */
-    cacheDiscount?: number;
-    /** Final cost after cache discount (USD) */
-    finalCost: number;
-    /** Model used for this estimate */
-    model: string;
-}
-/**
- * Aggregated cost summary across multiple executions.
- */
-export interface CostSummary {
-    /** Total cost across all executions (USD) */
-    totalCost: number;
-    /** Total input tokens */
-    totalInputTokens: number;
-    /** Total output tokens */
-    totalOutputTokens: number;
-    /** Total cache hit tokens */
-    totalCacheHitTokens: number;
-    /** Total savings from cache (USD) */
-    totalCacheSavings: number;
-    /** Final cost after cache discounts (USD) */
-    finalCost: number;
-    /** Cost breakdown by provider */
-    byProvider: Record<string, number>;
-    /** Cost breakdown by model */
-    byModel: Record<string, number>;
-    /** Number of executions */
-    executionCount: number;
-    /** Average cost per execution (USD) */
-    avgCostPerExecution: number;
-}
-/**
- * Get token costs for a model, falling back to default if unknown.
- */
-export declare function getModelCosts(model: string): {
-    input: number;
-    output: number;
-};
-/**
- * Estimate cost for a single execution.
- *
- * @param inputTokens - Number of input tokens
- * @param outputTokens - Number of output tokens
- * @param model - Model identifier
- * @param cacheHitTokens - Optional tokens read from cache
- * @returns Cost estimate with breakdown
- */
-export declare function estimateCost(inputTokens: number, outputTokens: number, model: string, cacheHitTokens?: number): CostEstimate;
-/**
- * Aggregate costs from multiple telemetry events.
- *
- * @param events - Array of telemetry events with token data
- * @returns Aggregated cost summary
- */
-export declare function aggregateCosts(events: TelemetryEvent[]): CostSummary;
-/**
- * Format a cost value for display.
- *
- * @param cost - Cost in USD
- * @returns Formatted string like "$0.0123" or "<$0.01"
- */
-export declare function formatCost(cost: number): string;
-/**
- * Estimate cost for a planned execution based on token estimates.
- * Useful for budget warnings before execution.
- *
- * @param estimatedInputTokens - Estimated input tokens
- * @param model - Model to use
- * @param estimatedOutputRatio - Expected output/input ratio (default 0.3)
- * @returns Cost estimate
- */
-export declare function estimatePlannedCost(estimatedInputTokens: number, model: string, estimatedOutputRatio?: number): CostEstimate;

package/dist/intelligence/cost-tracker.js

@@ -1,183 +0,0 @@
-/**
- * Token cost tracking and estimation for Orchex Learn.
- * Provides cost estimation and aggregation for multi-provider token usage.
- */
-/**
- * Token costs per 1000 tokens (in USD).
- * Prices as of February 2026 - should be updated periodically.
- *
- * Reference (per 1M tokens):
- * - DeepSeek V3.2:   $0.28 / $0.42   (~95% cheaper than Claude)
- * - Gemini 2.5 Pro:  $1.25 / $10.00  (~60% cheaper than Claude)
- * - Claude Sonnet:   $3.00 / $15.00  (baseline)
- * - OpenAI GPT-4o:   $5.00 / $15.00  (~40% more than Claude)
- * - Claude Opus:     $15.00 / $75.00 (5x Claude Sonnet)
- */
-export const TOKEN_COSTS = {
-    // Anthropic models (Feb 2026)
-    'claude-opus-4-5-20251101': { input: 0.015, output: 0.075 },
-    'claude-sonnet-4-5-20250929': { input: 0.003, output: 0.015 },
-    'claude-sonnet-4-20250514': { input: 0.003, output: 0.015 },
-    'claude-3-5-sonnet-20241022': { input: 0.003, output: 0.015 },
-    'claude-3-opus-20240229': { input: 0.015, output: 0.075 },
-    'claude-3-haiku-20240307': { input: 0.00025, output: 0.00125 },
-    // OpenAI models (Feb 2026)
-    'gpt-4.5-turbo': { input: 0.005, output: 0.015 },
-    'gpt-4-turbo': { input: 0.01, output: 0.03 },
-    'gpt-4-turbo-preview': { input: 0.01, output: 0.03 },
-    'gpt-4o': { input: 0.005, output: 0.015 },
-    'gpt-4o-mini': { input: 0.00015, output: 0.0006 },
-    'o1-preview': { input: 0.015, output: 0.06 },
-    'o1-mini': { input: 0.003, output: 0.012 },
-    'o3-mini': { input: 0.0011, output: 0.0044 },
-    'gpt-3.5-turbo': { input: 0.0005, output: 0.0015 },
-    // Google models (Feb 2026)
-    'gemini-2.5-pro': { input: 0.00125, output: 0.01 },
-    'gemini-2.0-flash': { input: 0.0001, output: 0.0004 },
-    'gemini-1.5-pro': { input: 0.00125, output: 0.005 },
-    'gemini-1.5-flash': { input: 0.000075, output: 0.0003 },
-    'gemini-pro': { input: 0.000125, output: 0.000375 },
-    // DeepSeek models (Feb 2026) — ~95% cheaper than Claude!
-    'deepseek-chat': { input: 0.00028, output: 0.00042 },
-    'deepseek-coder': { input: 0.00028, output: 0.00042 },
-    'deepseek-reasoner': { input: 0.00055, output: 0.00219 },
-    // Ollama/Local (free but track for comparison)
-    'llama3.3:70b': { input: 0, output: 0 },
-    'llama3.2:latest': { input: 0, output: 0 },
-    'mistral:latest': { input: 0, output: 0 },
-    // Default fallback (conservative estimate)
-    default: { input: 0.003, output: 0.015 },
-};
-/**
- * Cache discount rate for Anthropic prompt caching.
- * Cached tokens cost 90% less than regular input tokens.
- */
-export const CACHE_DISCOUNT_RATE = 0.9;
-/**
- * Get token costs for a model, falling back to default if unknown.
- */
-export function getModelCosts(model) {
-    // Try exact match first
-    if (TOKEN_COSTS[model]) {
-        return TOKEN_COSTS[model];
-    }
-    // Try to match by prefix (handles versioned model names)
-    const modelLower = model.toLowerCase();
-    for (const [key, costs] of Object.entries(TOKEN_COSTS)) {
-        if (key !== 'default' && modelLower.includes(key.split('-').slice(0, 2).join('-'))) {
-            return costs;
-        }
-    }
-    return TOKEN_COSTS.default;
-}
-/**
- * Estimate cost for a single execution.
- *
- * @param inputTokens - Number of input tokens
- * @param outputTokens - Number of output tokens
- * @param model - Model identifier
- * @param cacheHitTokens - Optional tokens read from cache
- * @returns Cost estimate with breakdown
- */
-export function estimateCost(inputTokens, outputTokens, model, cacheHitTokens) {
-    const costs = getModelCosts(model);
-    // Calculate base costs (per 1000 tokens)
-    const inputCost = (inputTokens / 1000) * costs.input;
-    const outputCost = (outputTokens / 1000) * costs.output;
-    const totalCost = inputCost + outputCost;
-    // Calculate cache discount
-    let cacheDiscount;
-    if (cacheHitTokens && cacheHitTokens > 0) {
-        // Cache hits save CACHE_DISCOUNT_RATE of the input cost for those tokens
-        cacheDiscount = (cacheHitTokens / 1000) * costs.input * CACHE_DISCOUNT_RATE;
-    }
-    const finalCost = totalCost - (cacheDiscount ?? 0);
-    return {
-        inputTokens,
-        outputTokens,
-        inputCost,
-        outputCost,
-        totalCost,
-        cacheHitTokens,
-        cacheDiscount,
-        finalCost,
-        model,
-    };
-}
-/**
- * Aggregate costs from multiple telemetry events.
- *
- * @param events - Array of telemetry events with token data
- * @returns Aggregated cost summary
- */
-export function aggregateCosts(events) {
-    const byProvider = {};
-    const byModel = {};
-    let totalInputTokens = 0;
-    let totalOutputTokens = 0;
-    let totalCacheHitTokens = 0;
-    let totalCost = 0;
-    let totalCacheSavings = 0;
-    let executionCount = 0;
-    for (const event of events) {
-        // Skip events without token data
-        if (!event.tokensInput && !event.tokensOutput) {
-            continue;
-        }
-        const inputTokens = event.tokensInput ?? 0;
-        const outputTokens = event.tokensOutput ?? 0;
-        const cacheHitTokens = event.cacheReadTokens ?? 0;
-        const model = event.model ?? 'default';
-        const provider = event.provider ?? 'unknown';
-        const estimate = estimateCost(inputTokens, outputTokens, model, cacheHitTokens);
-        totalInputTokens += inputTokens;
-        totalOutputTokens += outputTokens;
-        totalCacheHitTokens += cacheHitTokens;
-        totalCost += estimate.totalCost;
-        totalCacheSavings += estimate.cacheDiscount ?? 0;
-        executionCount++;
-        // Aggregate by provider
-        byProvider[provider] = (byProvider[provider] ?? 0) + estimate.finalCost;
-        // Aggregate by model
-        byModel[model] = (byModel[model] ?? 0) + estimate.finalCost;
-    }
-    const finalCost = totalCost - totalCacheSavings;
-    return {
-        totalCost,
-        totalInputTokens,
-        totalOutputTokens,
-        totalCacheHitTokens,
-        totalCacheSavings,
-        finalCost,
-        byProvider,
-        byModel,
-        executionCount,
-        avgCostPerExecution: executionCount > 0 ? finalCost / executionCount : 0,
-    };
-}
-/**
- * Format a cost value for display.
- *
- * @param cost - Cost in USD
- * @returns Formatted string like "$0.0123" or "<$0.01"
- */
-export function formatCost(cost) {
-    if (cost === 0)
-        return '$0.00';
-    if (cost < 0.01)
-        return '< $0.01';
-    return `$${cost.toFixed(4)}`;
-}
-/**
- * Estimate cost for a planned execution based on token estimates.
- * Useful for budget warnings before execution.
- *
- * @param estimatedInputTokens - Estimated input tokens
- * @param model - Model to use
- * @param estimatedOutputRatio - Expected output/input ratio (default 0.3)
- * @returns Cost estimate
- */
-export function estimatePlannedCost(estimatedInputTokens, model, estimatedOutputRatio = 0.3) {
-    const estimatedOutputTokens = Math.ceil(estimatedInputTokens * estimatedOutputRatio);
-    return estimateCost(estimatedInputTokens, estimatedOutputTokens, model);
-}

package/dist/intelligence/deliverable-extractor.d.ts

@@ -1,134 +0,0 @@
-/**
- * Atomic deliverable extraction from parsed planning documents.
- * Transforms parsed sections into stream-ready deliverables.
- *
- * Phase 8B-C: Semantic splitting based on file content classification.
- * YAML-sourced deliverables are never auto-split (author knows best).
- */
-import type { ParsedSection, ParsedPlan, CodeBlock } from './plan-parser.js';
-import { type StreamCategory } from './learning-engine.js';
-import type { LearnDiagnostics } from './diagnostics.js';
-/**
- * Concern types for semantic file classification.
- * Used to group files by their purpose when splitting deliverables.
- */
-export type FileConcern = 'types' | 'migrations' | 'core' | 'tests' | 'docs' | 'styles';
-/**
- * Classify a file path into a concern bucket based on filename and path.
- * Uses CONCERN_PRIORITY to resolve ambiguous matches.
- */
-export declare function classifyFile(filePath: string): FileConcern;
-/**
- * Extract relevant plan lines for a specific concern.
- * Matches lines containing concern keywords or file names.
- * Never returns generic template text - always preserves original content.
- */
-export declare function extractPlanForConcern(originalPlan: string, concern: FileConcern, files: string[]): string;
-/**
- * A deliverable extracted from a planning document.
- */
-export interface Deliverable {
-    /** Unique identifier (stream ID) */
-    id: string;
-    /** Human-readable name */
-    name: string;
-    /** Description of the deliverable */
-    description: string;
-    /** Stream category */
-    category: StreamCategory;
-    /** Files this deliverable will own */
-    ownedFiles: string[];
-    /** Files this deliverable needs to read */
-    readFiles: string[];
-    /** Explicit dependencies mentioned */
-    explicitDeps: string[];
-    /** Code examples from the document */
-    codeExamples: CodeBlock[];
-    /** Whether this is atomic (small enough for one stream) */
-    isAtomic: boolean;
-    /** Reasons for suggested split if not atomic */
-    suggestedSplit?: string[];
-    /** Number of H3+ children in the source section */
-    childCount?: number;
-}
-/**
- * Generate a stream ID from a section title.
- */
-export declare function generateStreamId(title: string, prefix?: string): string;
-/**
- * Infer owned files from section content and its children.
- * Priority order:
- * 1. "Create:/Modify:/Test:" in **Files:** sections (from section + children)
- * 2. Code block filename comments (// filename on first line)
- * 3. Explicit `owns: [files]` pattern in content
- * 4. NO blind fallback to fileReferences — that causes false ownership
- *
- * Files in explicit `reads:` declarations are excluded from ownership.
- */
-export declare function inferOwnedFiles(section: ParsedSection, codeBlocks: CodeBlock[]): string[];
-/**
- * Infer read files from section content (files referenced but not owned).
- */
-export declare function inferReadFiles(section: ParsedSection, ownedFiles: string[]): string[];
-/**
- * Extended deliverable type with YAML source marker.
- */
-export interface DeliverableWithMeta extends Deliverable {
-    /** True if this deliverable came from explicit YAML definition */
-    _fromYaml?: boolean;
-    /** Verify commands from YAML */
-    _verify?: string[];
-    /** Setup commands from YAML */
-    _setup?: string[];
-}
-/**
- * Check if a deliverable should be split.
- * YAML-sourced deliverables are never split (author knows best).
- * Uses semantic concern-based analysis instead of templates.
- */
-export declare function shouldSplit(deliverable: Deliverable): {
-    split: boolean;
-    reasons: string[];
-};
-/**
- * Extract deliverables from YAML stream definitions in all sections.
- * Scans entire document for yaml code blocks with stream definitions.
- */
-export declare function extractFromYamlBlocks(plan: ParsedPlan, prefix?: string, diagnostics?: LearnDiagnostics): Deliverable[];
-/**
- * Check if a plan contains YAML stream definitions.
- */
-export declare function hasYamlStreamDefinitions(plan: ParsedPlan): boolean;
-/**
- * Extract deliverables from a parsed plan.
- * Automatically detects YAML stream definitions and uses them if found.
- * Falls back to header-based extraction if no YAML streams are present.
- */
-export declare function extractDeliverables(plan: ParsedPlan, options?: {
-    deliverableLevel?: number;
-    prefix?: string;
-    preferYaml?: boolean;
-    diagnostics?: LearnDiagnostics;
-}): Deliverable[];
-/**
- * Split a non-atomic deliverable using semantic file classification.
- *
- * Phase 8B-C: Files are grouped by concern (types, migrations, core, tests, docs).
- * Each group becomes a separate deliverable with:
- * - Relevant plan content extracted from original (not generic templates)
- * - Proper dependency chaining (types → migrations → core → tests → docs)
- * - Parent's explicit dependencies inherited by first split
- */
-export declare function splitDeliverable(deliverable: Deliverable): Deliverable[];
-/**
- * Process all deliverables, splitting non-atomic ones.
- */
-export declare function processDeliverables(deliverables: Deliverable[]): Deliverable[];
-/**
- * Format deliverable as human-readable summary.
- */
-export declare function formatDeliverable(deliverable: Deliverable): string;
-/**
- * Format all deliverables as a report.
- */
-export declare function formatDeliverablesReport(deliverables: Deliverable[]): string;