@outputai/cli 0.1.2-dev.0 → 0.1.2

package/dist/services/coding_agents.spec.js

@@ -1,256 +0,0 @@
-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-claude-plugins'
-                        }
-                    }
-                },
-                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-claude-plugins'], '/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-claude-plugins' }
-                    }
-                },
-                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

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

package/dist/services/copy_assets.spec.js

@@ -1,22 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,359 +0,0 @@
-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

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