@outputai/cli 0.1.4 → 0.1.5

package/dist/services/coding_agents.spec.js

@@ -0,0 +1,256 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { checkAgentStructure, prepareTemplateVariables, initializeAgentConfig, ensureOutputAISystem, ensureClaudePlugin } from './coding_agents.js';
+import { access } from 'node:fs/promises';
+import fs from 'node:fs/promises';
+vi.mock('node:fs/promises');
+vi.mock('../utils/paths.js', () => ({
+    getTemplateDir: vi.fn().mockReturnValue('/templates')
+}));
+vi.mock('../utils/template.js', () => ({
+    processTemplate: vi.fn().mockImplementation((content) => content)
+}));
+vi.mock('../utils/claude.js', () => ({
+    executeClaudeCommand: vi.fn().mockResolvedValue(undefined)
+}));
+vi.mock('@oclif/core', () => ({
+    ux: {
+        warn: vi.fn(),
+        stdout: vi.fn(),
+        colorize: vi.fn().mockImplementation((_color, text) => text)
+    }
+}));
+vi.mock('@inquirer/prompts', () => ({
+    confirm: vi.fn()
+}));
+describe('coding_agents service', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    describe('checkAgentStructure', () => {
+        it('should return needsInit true when settings.json does not exist', async () => {
+            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
+            vi.mocked(fs.readFile).mockRejectedValue({ code: 'ENOENT' });
+            const result = await checkAgentStructure('/test/project');
+            expect(result).toEqual({
+                isComplete: false,
+                needsInit: true
+            });
+        });
+        it('should return complete when settings and CLAUDE.md exist with valid configuration', async () => {
+            vi.mocked(access).mockResolvedValue(undefined);
+            vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({
+                extraKnownMarketplaces: {
+                    'team-tools': {
+                        source: {
+                            source: 'github',
+                            repo: 'growthxai/output'
+                        }
+                    }
+                },
+                enabledPlugins: {
+                    'outputai@outputai': true
+                }
+            }));
+            const result = await checkAgentStructure('/test/project');
+            expect(result).toEqual({
+                isComplete: true,
+                needsInit: false
+            });
+        });
+        it('should return needsInit true when settings.json has wrong marketplace repo', async () => {
+            vi.mocked(access).mockResolvedValue(undefined);
+            vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({
+                extraKnownMarketplaces: {
+                    'team-tools': {
+                        source: {
+                            source: 'github',
+                            repo: 'wrong/repo'
+                        }
+                    }
+                },
+                enabledPlugins: {
+                    'outputai@outputai': true
+                }
+            }));
+            const result = await checkAgentStructure('/test/project');
+            expect(result.isComplete).toBe(false);
+            expect(result.needsInit).toBe(true);
+        });
+        it('should return needsInit true when plugin is not enabled', async () => {
+            vi.mocked(access).mockResolvedValue(undefined);
+            vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({
+                extraKnownMarketplaces: {
+                    'team-tools': {
+                        source: {
+                            source: 'github',
+                            repo: 'growthxai/output-claude-plugins'
+                        }
+                    }
+                },
+                enabledPlugins: {
+                    'outputai@outputai': false
+                }
+            }));
+            const result = await checkAgentStructure('/test/project');
+            expect(result.isComplete).toBe(false);
+            expect(result.needsInit).toBe(true);
+        });
+    });
+    describe('prepareTemplateVariables', () => {
+        it('should return template variables with formatted date', () => {
+            const variables = prepareTemplateVariables();
+            expect(variables).toHaveProperty('date');
+            expect(typeof variables.date).toBe('string');
+            expect(variables.date).toMatch(/^[A-Z][a-z]+ \d{1,2}, \d{4}$/);
+        });
+    });
+    describe('initializeAgentConfig', () => {
+        beforeEach(() => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
+            vi.mocked(fs.readFile).mockResolvedValue('template content');
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+        });
+        it('should create exactly 2 outputs: settings.json and CLAUDE.md file', async () => {
+            await initializeAgentConfig({
+                projectRoot: '/test/project',
+                force: false
+            });
+            expect(fs.mkdir).toHaveBeenCalledTimes(1);
+            expect(fs.mkdir).toHaveBeenCalledWith('/test/project/.claude', expect.objectContaining({ recursive: true }));
+            expect(fs.writeFile).toHaveBeenCalledWith('/test/project/.claude/settings.json', expect.any(String), 'utf-8');
+            expect(fs.writeFile).toHaveBeenCalledWith('/test/project/CLAUDE.md', expect.any(String), 'utf-8');
+            // No symlink should be created - CLAUDE.md is now a real file
+            expect(fs.symlink).not.toHaveBeenCalled();
+        });
+        it('should skip existing files when force is false', async () => {
+            vi.mocked(access).mockResolvedValue(undefined);
+            await initializeAgentConfig({
+                projectRoot: '/test/project',
+                force: false
+            });
+            expect(fs.writeFile).not.toHaveBeenCalled();
+        });
+        it('should overwrite existing files when force is true', async () => {
+            vi.mocked(access).mockResolvedValue(undefined);
+            vi.mocked(fs.unlink).mockResolvedValue(undefined);
+            await initializeAgentConfig({
+                projectRoot: '/test/project',
+                force: true
+            });
+            expect(fs.writeFile).toHaveBeenCalled();
+        });
+    });
+    describe('ensureClaudePlugin', () => {
+        beforeEach(() => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
+            vi.mocked(fs.readFile).mockResolvedValue('template content');
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+        });
+        it('should call registerPluginMarketplace and installOutputAIPlugin', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            await ensureClaudePlugin('/test/project');
+            expect(executeClaudeCommand).toHaveBeenCalledWith(['plugin', 'marketplace', 'add', 'growthxai/output'], '/test/project', { ignoreFailure: true });
+            expect(executeClaudeCommand).toHaveBeenCalledWith(['plugin', 'marketplace', 'update', 'outputai'], '/test/project');
+            expect(executeClaudeCommand).toHaveBeenCalledWith(['plugin', 'install', 'outputai@outputai', '--scope', 'project'], '/test/project');
+        });
+        it('should show error and prompt user when plugin commands fail', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { confirm } = await import('@inquirer/prompts');
+            vi.mocked(executeClaudeCommand)
+                .mockResolvedValueOnce(undefined) // marketplace add
+                .mockRejectedValueOnce(new Error('Plugin update failed')); // marketplace update
+            vi.mocked(confirm).mockResolvedValue(true);
+            await expect(ensureClaudePlugin('/test/project')).resolves.not.toThrow();
+            expect(confirm).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('proceed')
+            }));
+        });
+        it('should allow user to proceed without plugin setup if they confirm', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { confirm } = await import('@inquirer/prompts');
+            vi.mocked(executeClaudeCommand)
+                .mockRejectedValue(new Error('All plugin commands fail'));
+            vi.mocked(confirm).mockResolvedValue(true);
+            await expect(ensureClaudePlugin('/test/project')).resolves.not.toThrow();
+        });
+    });
+    describe('ensureOutputAISystem', () => {
+        beforeEach(() => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
+            vi.mocked(fs.readFile).mockResolvedValue('template content');
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+        });
+        it('should return immediately when agent structure is complete', async () => {
+            vi.mocked(access).mockResolvedValue(undefined);
+            vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({
+                extraKnownMarketplaces: {
+                    'team-tools': {
+                        source: { source: 'github', repo: 'growthxai/output' }
+                    }
+                },
+                enabledPlugins: { 'outputai@outputai': true }
+            }));
+            await ensureOutputAISystem('/test/project');
+            expect(fs.mkdir).not.toHaveBeenCalled();
+        });
+        it('should auto-initialize when settings.json is invalid', async () => {
+            vi.mocked(access).mockResolvedValue(undefined);
+            vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify({
+                extraKnownMarketplaces: {
+                    'team-tools': {
+                        source: { source: 'github', repo: 'wrong/repo' }
+                    }
+                },
+                enabledPlugins: { 'outputai@outputai': true }
+            }));
+            await ensureOutputAISystem('/test/project');
+            expect(fs.mkdir).toHaveBeenCalled();
+        });
+    });
+    describe('Claude plugin error handling', () => {
+        beforeEach(() => {
+            vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+            vi.mocked(access).mockRejectedValue({ code: 'ENOENT' });
+            vi.mocked(fs.readFile).mockResolvedValue('template content');
+            vi.mocked(fs.writeFile).mockResolvedValue(undefined);
+        });
+        it('should show error and prompt user when registerPluginMarketplace fails', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { confirm } = await import('@inquirer/prompts');
+            vi.mocked(executeClaudeCommand)
+                .mockResolvedValueOnce(undefined) // marketplace add
+                .mockRejectedValueOnce(new Error('Plugin update failed')); // marketplace update
+            vi.mocked(confirm).mockResolvedValue(true);
+            await expect(initializeAgentConfig({ projectRoot: '/test/project', force: true })).resolves.not.toThrow();
+            expect(confirm).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('proceed')
+            }));
+        });
+        it('should show error and prompt user when installOutputAIPlugin fails', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { confirm } = await import('@inquirer/prompts');
+            vi.mocked(executeClaudeCommand)
+                .mockResolvedValueOnce(undefined) // marketplace add
+                .mockResolvedValueOnce(undefined) // marketplace update
+                .mockRejectedValueOnce(new Error('Plugin install failed')); // plugin install
+            vi.mocked(confirm).mockResolvedValue(true);
+            await expect(initializeAgentConfig({ projectRoot: '/test/project', force: true })).resolves.not.toThrow();
+            expect(confirm).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('proceed')
+            }));
+        });
+        it('should allow user to proceed without plugin setup if they confirm', async () => {
+            const { executeClaudeCommand } = await import('../utils/claude.js');
+            const { confirm } = await import('@inquirer/prompts');
+            vi.mocked(executeClaudeCommand)
+                .mockRejectedValue(new Error('All plugin commands fail'));
+            vi.mocked(confirm).mockResolvedValue(true);
+            await expect(initializeAgentConfig({ projectRoot: '/test/project', force: true })).resolves.not.toThrow();
+            // File operations should still complete
+            expect(fs.mkdir).toHaveBeenCalled();
+        });
+    });
+});

package/dist/services/copy_assets.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/copy_assets.spec.js

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Resolve to the cli package root, then into dist/templates
+const cliRoot = path.resolve(__dirname, '..', '..');
+const distTemplatesDir = path.join(cliRoot, 'dist', 'templates', 'project');
+describe('copy-assets build output', () => {
+    it('should include dotfile templates in dist/templates/project/', () => {
+        const dotfiles = ['.env.example.template', '.gitignore.template'];
+        for (const dotfile of dotfiles) {
+            const filePath = path.join(distTemplatesDir, dotfile);
+            expect(fs.existsSync(filePath), `Missing dotfile template in dist: ${dotfile}`).toBe(true);
+        }
+    });
+    it('should include config templates in dist/templates/project/', () => {
+        const configFile = path.join(distTemplatesDir, 'config', 'costs.yml.template');
+        expect(fs.existsSync(configFile), 'Missing config/costs.yml.template in dist').toBe(true);
+    });
+});

package/dist/services/cost_calculator.d.ts

@@ -0,0 +1,18 @@
+import type { TraceNode, LLMCall, HTTPCall, TokenUsage, PricingConfig, ModelPricing, ServiceConfig, ServiceCostResult, CostReport } from '#types/cost.js';
+export declare function extractValue(obj: unknown, path: string): unknown;
+export declare function loadPricingConfig(configPath?: string): PricingConfig;
+export declare function findLLMCalls(node: TraceNode, parentStepName?: string | null, seenIds?: Set<string>): LLMCall[];
+export declare function findHTTPCalls(node: TraceNode, parentStepName?: string | null, seenIds?: Set<string>): HTTPCall[];
+export declare function calculateLLMCallCost(usage: TokenUsage, modelPricing: ModelPricing | undefined): {
+    cost: number;
+    warning?: string;
+};
+export declare function identifyService(httpCall: HTTPCall, services: Record<string, ServiceConfig>): {
+    serviceName: string;
+    config: ServiceConfig;
+} | null;
+export declare function calculateServiceCost(httpCall: HTTPCall, serviceInfo: {
+    serviceName: string;
+    config: ServiceConfig;
+}): ServiceCostResult;
+export declare function calculateCost(trace: TraceNode, config: PricingConfig, traceFile?: string): CostReport;

package/dist/services/cost_calculator.js

@@ -0,0 +1,359 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import yaml from 'js-yaml';
+const ARRAY_ACCESS_PATTERN = /^(\w+)\[(\d+)\]$/;
+function tokenCost(tokens, pricePerMillion) {
+    return (tokens / 1_000_000) * pricePerMillion;
+}
+export function extractValue(obj, path) {
+    if (!path || !obj) {
+        return obj;
+    }
+    return path.split('.').reduce((current, part) => {
+        if (current === null || current === undefined) {
+            return current;
+        }
+        const arrayMatch = part.match(ARRAY_ACCESS_PATTERN);
+        if (arrayMatch) {
+            const [, key, index] = arrayMatch;
+            return current[key]?.[parseInt(index, 10)];
+        }
+        return current[part];
+    }, obj);
+}
+function loadYaml(filePath) {
+    return yaml.load(readFileSync(filePath, 'utf-8'));
+}
+export function loadPricingConfig(configPath) {
+    const bundledPath = new URL('../assets/config/costs.yml', import.meta.url).pathname;
+    const bundled = loadYaml(configPath ?? bundledPath);
+    const projectPath = join(process.cwd(), 'config', 'costs.yml');
+    if (!configPath && existsSync(projectPath)) {
+        const project = loadYaml(projectPath);
+        return {
+            models: { ...bundled.models, ...project.models },
+            services: { ...bundled.services, ...project.services }
+        };
+    }
+    return bundled;
+}
+function resolveStepName(node, parentStepName) {
+    if (node.kind === 'step' && node.name) {
+        return node.name.includes('#') ?
+            node.name.split('#').pop() :
+            node.name;
+    }
+    return parentStepName;
+}
+function findCalls(node, match, extract, parentStepName = null, seenIds = new Set()) {
+    const calls = [];
+    if (match(node)) {
+        const id = node.id;
+        if (id && seenIds.has(id)) {
+            return calls;
+        }
+        if (id) {
+            seenIds.add(id);
+        }
+        calls.push(extract(node, parentStepName));
+    }
+    const currentStepName = resolveStepName(node, parentStepName);
+    if (node.children) {
+        for (const child of node.children) {
+            calls.push(...findCalls(child, match, extract, currentStepName, seenIds));
+        }
+    }
+    return calls;
+}
+export function findLLMCalls(node, parentStepName = null, seenIds = new Set()) {
+    return findCalls(node, n => n.kind === 'llm' && !!n.output?.usage, (n, stepName) => {
+        const loadedPrompt = n.input?.loadedPrompt;
+        const outputRecord = n.output;
+        const inputRecord = n.input;
+        const model = loadedPrompt?.config?.model ||
+            outputRecord?.model ||
+            inputRecord?.model ||
+            'unknown';
+        return {
+            stepName: stepName || n.name || 'unknown',
+            llmName: n.name || 'llm',
+            model,
+            usage: n.output.usage
+        };
+    }, parentStepName, seenIds);
+}
+export function findHTTPCalls(node, parentStepName = null, seenIds = new Set()) {
+    return findCalls(node, n => n.kind === 'http', (n, stepName) => ({
+        stepName: stepName || 'unknown',
+        url: n.input?.url || '',
+        method: n.input?.method || 'GET',
+        input: n.input || {},
+        output: n.output || {},
+        status: n.output?.status
+    }), parentStepName, seenIds);
+}
+export function calculateLLMCallCost(usage, modelPricing) {
+    if (!modelPricing) {
+        return { cost: 0, warning: 'unknown model' };
+    }
+    const inputCost = tokenCost(usage.inputTokens ?? 0, modelPricing.input ?? 0);
+    const outputCost = tokenCost(usage.outputTokens ?? 0, modelPricing.output ?? 0);
+    const cachedCost = tokenCost(usage.cachedInputTokens ?? 0, modelPricing.cached_input ?? 0);
+    const reasoningCost = tokenCost(usage.reasoningTokens ?? 0, modelPricing.reasoning || modelPricing.output || 0);
+    return { cost: inputCost + outputCost + cachedCost + reasoningCost };
+}
+export function identifyService(httpCall, services) {
+    if (!services) {
+        return null;
+    }
+    for (const [serviceName, config] of Object.entries(services)) {
+        if (httpCall.url.includes(config.url_pattern)) {
+            return { serviceName, config };
+        }
+    }
+    return null;
+}
+function calculateTokenServiceCost(httpCall, config) {
+    if (!config.usage_path) {
+        return { step: httpCall.stepName, cost: 0, usage: 'no usage data', warning: 'no usage data' };
+    }
+    const usage = extractValue(httpCall.output, config.usage_path);
+    if (config.input_field && config.output_field) {
+        const usageObj = usage;
+        const inputTokens = usageObj?.[config.input_field] ?? 0;
+        const outputTokens = usageObj?.[config.output_field] ?? 0;
+        const inputCost = tokenCost(inputTokens, config.input_per_million ?? 0);
+        const outputCost = tokenCost(outputTokens, config.output_per_million ?? 0);
+        return {
+            step: httpCall.stepName,
+            cost: inputCost + outputCost,
+            usage: `${(inputTokens + outputTokens).toLocaleString('en-US')} tokens`
+        };
+    }
+    const tokens = typeof usage === 'number' ? usage : 0;
+    if (tokens === 0) {
+        return { step: httpCall.stepName, cost: 0, usage: 'no usage data', warning: 'no usage data' };
+    }
+    const cost = tokenCost(tokens, config.per_million ?? 0);
+    return { step: httpCall.stepName, cost, usage: `${tokens.toLocaleString('en-US')} tokens` };
+}
+function resolveUnitEndpoint(url, httpCall, config) {
+    if (!config.endpoints) {
+        return { units: 0, endpoint: 'unknown' };
+    }
+    for (const [endpointName, endpointConfig] of Object.entries(config.endpoints)) {
+        if (!url.includes(endpointConfig.pattern)) {
+            continue;
+        }
+        if (endpointConfig.units_per_request) {
+            return { units: endpointConfig.units_per_request, endpoint: endpointName };
+        }
+        if (endpointConfig.units_per_line) {
+            const body = httpCall.output?.body;
+            if (typeof body === 'string') {
+                const lines = body.split('\n').filter((l) => l.trim() && !l.startsWith('ERROR'));
+                const units = Math.max(0, lines.length - 1) * endpointConfig.units_per_line;
+                return { units, endpoint: endpointName };
+            }
+        }
+        return { units: 0, endpoint: endpointName };
+    }
+    return { units: 0, endpoint: 'unknown' };
+}
+function calculateUnitServiceCost(httpCall, config) {
+    const { units, endpoint } = resolveUnitEndpoint(httpCall.url, httpCall, config);
+    const cost = units * (config.price_per_unit || 0);
+    return {
+        step: httpCall.stepName,
+        cost,
+        usage: `${units.toLocaleString('en-US')} units`,
+        endpoint
+    };
+}
+function calculateRequestServiceCost(httpCall, config) {
+    if (config.models && config.model_path) {
+        const model = extractValue(httpCall.input, config.model_path);
+        const price = (model && config.models[model]) || config.default_price || 0;
+        return { step: httpCall.stepName, cost: price, usage: '1 request', model };
+    }
+    if (config.endpoints) {
+        for (const [endpointName, endpointConfig] of Object.entries(config.endpoints)) {
+            if (httpCall.url.includes(endpointConfig.pattern)) {
+                if (endpointConfig.price !== undefined) {
+                    return {
+                        step: httpCall.stepName,
+                        cost: endpointConfig.price,
+                        usage: '1 request',
+                        endpoint: endpointName
+                    };
+                }
+                if (endpointConfig.price_per_item && endpointConfig.items_path) {
+                    const items = extractValue(httpCall.input, endpointConfig.items_path);
+                    const count = Array.isArray(items) ? items.length : 0;
+                    return {
+                        step: httpCall.stepName,
+                        cost: count * endpointConfig.price_per_item,
+                        usage: `${count} items`,
+                        endpoint: endpointName
+                    };
+                }
+            }
+        }
+    }
+    return { step: httpCall.stepName, cost: 0, usage: 'unknown endpoint', warning: 'unknown endpoint' };
+}
+function calculateResponseCostService(httpCall, config) {
+    const cost = extractValue(httpCall, config.cost_path);
+    if (typeof cost === 'number' && cost > 0) {
+        const costDollars = extractValue(httpCall, 'output.body.costDollars');
+        const model = extractValue(httpCall, 'output.body.model');
+        const numSearches = costDollars?.numSearches ?? 0;
+        const numPages = costDollars?.numPages ?? 0;
+        return {
+            step: httpCall.stepName,
+            cost,
+            usage: `${numSearches} searches, ${Math.round(numPages)} pages`,
+            model: model || 'unknown',
+            details: costDollars
+        };
+    }
+    if (config.fallback_models) {
+        const model = extractValue(httpCall, 'input.body.model') ||
+            extractValue(httpCall, 'output.body.model') ||
+            'unknown';
+        const fallbackPrice = config.fallback_models[model];
+        if (fallbackPrice) {
+            return {
+                step: httpCall.stepName,
+                cost: fallbackPrice,
+                usage: '1 request (estimated)',
+                model,
+                warning: 'using fallback estimate'
+            };
+        }
+        if (config.default_fallback) {
+            return {
+                step: httpCall.stepName,
+                cost: config.default_fallback,
+                usage: '1 request (estimated)',
+                model: 'unknown',
+                warning: 'using default estimate'
+            };
+        }
+    }
+    return { step: httpCall.stepName, cost: 0, usage: 'no cost data', warning: 'no cost data' };
+}
+export function calculateServiceCost(httpCall, serviceInfo) {
+    const { config } = serviceInfo;
+    switch (config.type) {
+        case 'token':
+            return calculateTokenServiceCost(httpCall, config);
+        case 'unit':
+            return calculateUnitServiceCost(httpCall, config);
+        case 'request':
+            return calculateRequestServiceCost(httpCall, config);
+        case 'response_cost':
+            return calculateResponseCostService(httpCall, config);
+        default:
+            return { step: httpCall.stepName, cost: 0, usage: 'unknown type', warning: 'unknown type' };
+    }
+}
+function findModelPricing(model, models) {
+    if (models[model]) {
+        return { pricing: models[model], matchedKey: model };
+    }
+    const prefixMatch = Object.entries(models).find(([key]) => model.startsWith(key));
+    return prefixMatch ?
+        { pricing: prefixMatch[1], matchedKey: prefixMatch[0] } :
+        { pricing: undefined, matchedKey: undefined };
+}
+function aggregateLLMCosts(llmCalls, config) {
+    const unknownModels = new Set();
+    const results = [];
+    const totals = { inputTokens: 0, outputTokens: 0, cachedTokens: 0, reasoningTokens: 0, cost: 0 };
+    for (const call of llmCalls) {
+        const { pricing, matchedKey } = findModelPricing(call.model, config.models ?? {});
+        const { cost, warning } = calculateLLMCallCost(call.usage, pricing);
+        const prefixWarning = (pricing && matchedKey !== call.model) ?
+            `priced as ${matchedKey}` :
+            undefined;
+        if (!pricing) {
+            unknownModels.add(call.model);
+        }
+        results.push({
+            step: call.stepName,
+            model: call.model,
+            input: call.usage.inputTokens ?? 0,
+            output: call.usage.outputTokens ?? 0,
+            cached: call.usage.cachedInputTokens ?? 0,
+            reasoning: call.usage.reasoningTokens ?? 0,
+            cost,
+            warning: warning ?? prefixWarning
+        });
+        totals.inputTokens += call.usage.inputTokens ?? 0;
+        totals.outputTokens += call.usage.outputTokens ?? 0;
+        totals.cachedTokens += call.usage.cachedInputTokens ?? 0;
+        totals.reasoningTokens += call.usage.reasoningTokens ?? 0;
+        totals.cost += cost;
+    }
+    return {
+        results,
+        totalInputTokens: totals.inputTokens,
+        totalOutputTokens: totals.outputTokens,
+        totalCachedTokens: totals.cachedTokens,
+        totalReasoningTokens: totals.reasoningTokens,
+        llmTotalCost: totals.cost,
+        unknownModels: [...unknownModels]
+    };
+}
+export function calculateCost(trace, config, traceFile = '') {
+    const llmCalls = findLLMCalls(trace);
+    const httpCalls = findHTTPCalls(trace);
+    const serviceResults = {};
+    for (const call of httpCalls) {
+        if (call.status && call.status >= 400) {
+            continue;
+        }
+        const serviceInfo = identifyService(call, config.services);
+        if (!serviceInfo) {
+            continue;
+        }
+        if (serviceInfo.config.type === 'response_cost') {
+            const hasCostData = extractValue(call, serviceInfo.config.cost_path);
+            const isBillableMethod = serviceInfo.config.billable_method &&
+                call.method === serviceInfo.config.billable_method;
+            if (!hasCostData && !isBillableMethod) {
+                continue;
+            }
+        }
+        const result = calculateServiceCost(call, serviceInfo);
+        if (!serviceResults[serviceInfo.serviceName]) {
+            serviceResults[serviceInfo.serviceName] = {
+                serviceName: serviceInfo.serviceName,
+                calls: [],
+                totalCost: 0
+            };
+        }
+        serviceResults[serviceInfo.serviceName].calls.push(result);
+        serviceResults[serviceInfo.serviceName].totalCost += result.cost;
+    }
+    const { results: llmResults, totalInputTokens, totalOutputTokens, totalCachedTokens, totalReasoningTokens, llmTotalCost, unknownModels } = aggregateLLMCosts(llmCalls, config);
+    const serviceTotalCost = Object.values(serviceResults).reduce((sum, s) => sum + s.totalCost, 0);
+    const totalCost = llmTotalCost + serviceTotalCost;
+    const durationMs = trace.endedAt && trace.startedAt ? trace.endedAt - trace.startedAt : null;
+    return {
+        traceFile,
+        workflowName: trace.name || 'unknown',
+        durationMs,
+        llmCalls: llmResults,
+        llmTotalCost,
+        totalInputTokens,
+        totalOutputTokens,
+        totalCachedTokens,
+        totalReasoningTokens,
+        unknownModels,
+        services: Object.values(serviceResults),
+        serviceTotalCost,
+        totalCost
+    };
+}

package/dist/services/cost_calculator.spec.d.ts

@@ -0,0 +1 @@
+export {};