@rigour-labs/core 6.7.10 → 6.8.1-rc.1

package/dist/semantic/project-facts.test.js

@@ -1,45 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { ProjectFacts } from './project-facts.js';
-let root;
-afterEach(() => { if (root)
-    fs.rmSync(root, { recursive: true, force: true }); root = undefined; });
-function write(files) {
-    root = fs.mkdtempSync(path.join(os.tmpdir(), 'project-facts-'));
-    for (const [name, text] of Object.entries(files)) {
-        fs.mkdirSync(path.dirname(path.join(root, name)), { recursive: true });
-        fs.writeFileSync(path.join(root, name), text);
-    }
-    return root;
-}
-describe('ProjectFacts', () => {
-    it('reads the nearest package.json, so each monorepo package is judged by its own', () => {
-        const dir = write({
-            'package.json': JSON.stringify({ name: 'root', devDependencies: { vite: '^5.0.0' } }),
-            'packages/ui/package.json': JSON.stringify({ name: '@x/ui', peerDependencies: { 'solid-js': '^1.8.0' } }),
-            'packages/ui/src/a.tsx': '',
-        });
-        const facts = new ProjectFacts(dir);
-        expect(facts.declares('packages/ui/src/a.tsx', 'solid-js')).toBe(true);
-        expect(facts.declares('packages/ui/src/a.tsx', 'vite')).toBe(false);
-        expect(facts.majorVersion('packages/ui/src/a.tsx', 'solid-js')).toBe(1);
-        expect(facts.packageName('packages/ui/src/a.tsx')).toBe('@x/ui');
-        expect(facts.packageDir('packages/ui/src/a.tsx')).toBe(path.join(dir, 'packages/ui'));
-    });
-    it('never reads a manifest above cwd', () => {
-        const dir = write({ 'package.json': JSON.stringify({ dependencies: { react: '^19.0.0' } }), 'app/src/a.tsx': '' });
-        const facts = new ProjectFacts(path.join(dir, 'app'));
-        expect(facts.dependencies('src/a.tsx').size).toBe(0);
-        expect(facts.packageDir('src/a.tsx')).toBeUndefined();
-    });
-    it('resolves compiler options through tsconfig extends', () => {
-        const dir = write({
-            'tsconfig.base.json': JSON.stringify({ compilerOptions: { stripInternal: true } }),
-            'pkg/tsconfig.json': JSON.stringify({ extends: '../tsconfig.base.json' }),
-            'pkg/src/a.ts': '',
-        });
-        expect(new ProjectFacts(dir).compilerOptions('pkg/src/a.ts').stripInternal).toBe(true);
-    });
-});

package/dist/semantic/sites/call-sites.test.d.ts

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

package/dist/semantic/sites/call-sites.test.js

@@ -1,46 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { exportCallSites } from './export.js';
-let dir;
-afterEach(() => { if (dir)
-    fs.rmSync(dir, { recursive: true, force: true }); dir = undefined; });
-function sites(code) {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'call-sites-'));
-    fs.writeFileSync(path.join(dir, 'main.ts'), code);
-    return exportCallSites(dir, ['main.ts']).map(s => [s.function, s.callee, s.ordinal, s.handledBy]);
-}
-const DECLS = 'declare function a(): Promise<number>;\ndeclare function b(): Promise<number>;\n';
-describe('findCallSites', () => {
-    it('reports awaited calls and says how each handles failure', () => {
-        expect(sites(`${DECLS}
-export async function load() {
-  const x = await a();
-  try { await b(); } catch { return 0; }
-  const y = await a().catch(() => 0);
-  return x + y;
-}`)).toEqual([
-            ['load', 'a', 0, null],
-            ['load', 'b', 0, 'try'],
-            ['load', 'a', 1, 'call'],
-        ]);
-    });
-    it('treats each element of Promise.all as a site, and allSettled as handled', () => {
-        expect(sites(`${DECLS}
-export async function both() {
-  const [x, y] = await Promise.all([a(), b()]);
-  const settled = await Promise.allSettled([a()]);
-  return [x, y, settled];
-}`)).toEqual([
-            ['both', 'a', 0, null],
-            ['both', 'b', 0, null],
-            ['both', 'a', 1, 'all-settled'],
-        ]);
-    });
-    it('counts a callee that catches and returns as handled', () => {
-        expect(sites(`${DECLS}
-async function safeA() { try { return await a(); } catch { return 0; } }
-export async function use() { return await safeA(); }`)).toContainEqual(['use', 'safeA', 0, 'call']);
-    });
-});

package/dist/services/adaptive-thresholds.test.d.ts

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

package/dist/services/adaptive-thresholds.test.js

@@ -1,53 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { recordGateRun, getQualityTrend, clearAdaptiveHistory, } from './adaptive-thresholds.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-describe('AdaptiveThresholds', () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'adaptive-test-'));
-    });
-    afterEach(() => {
-        clearAdaptiveHistory(testDir);
-        fs.rmSync(testDir, { recursive: true, force: true });
-    });
-    describe('historical tracking', () => {
-        it('should record gate runs', () => {
-            recordGateRun(testDir, 5, 2, 10);
-            recordGateRun(testDir, 6, 1, 5);
-            const historyPath = path.join(testDir, '.rigour', 'adaptive-history.json');
-            expect(fs.existsSync(historyPath)).toBe(true);
-            const history = JSON.parse(fs.readFileSync(historyPath, 'utf-8'));
-            expect(history.runs).toHaveLength(2);
-        });
-        it('should return stable trend for new projects', () => {
-            const trend = getQualityTrend(testDir);
-            expect(trend).toBe('stable');
-        });
-        it('should detect improving trend', () => {
-            // Baseline: 15 runs with high failures (with variance for valid std dev)
-            for (let i = 0; i < 15; i++) {
-                recordGateRun(testDir, 3, 5, 15 + (i % 5) * 3); // 15,18,21,24,27 repeating
-            }
-            // Recent: 5 runs with very low failures (clear improvement)
-            for (let i = 0; i < 5; i++) {
-                recordGateRun(testDir, 7, 0, 1);
-            }
-            const trend = getQualityTrend(testDir);
-            expect(trend).toBe('improving');
-        });
-        it('should detect degrading trend', () => {
-            // Baseline: 15 runs with low failures (with variance for valid std dev)
-            for (let i = 0; i < 15; i++) {
-                recordGateRun(testDir, 7, 1, 1 + (i % 3)); // 1,2,3 repeating
-            }
-            // Recent: 5 runs with high failures (clear degradation)
-            for (let i = 0; i < 5; i++) {
-                recordGateRun(testDir, 3, 5, 25);
-            }
-            const trend = getQualityTrend(testDir);
-            expect(trend).toBe('degrading');
-        });
-    });
-});

package/dist/services/agent-history.test.d.ts

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

package/dist/services/agent-history.test.js

@@ -1,69 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildAgentRuns, normalizeAgentEvent, normalizeAgentEvents } from './agent-history.js';
-describe('agent history', () => {
-    it('normalizes incomplete historical records without dropping them', () => {
-        const event = normalizeAgentEvent({ type: 'tool_error', arguments: { files: ['src/a.ts'] } });
-        expect(event.agentId).toBe('unknown-agent');
-        expect(event.outcome).toBe('error');
-        expect(event.files).toEqual(['src/a.ts']);
-    });
-    it('groups events into stable runs and retains outcomes', () => {
-        const events = [
-            normalizeAgentEvent({ id: '1', sessionId: 's1', agentId: 'a1', timestamp: '2026-01-01T00:00:00Z', tool: 'read' }),
-            normalizeAgentEvent({ id: '2', sessionId: 's1', agentId: 'a1', timestamp: '2026-01-01T00:01:00Z', type: 'completed', files: ['src/a.ts'] }),
-        ];
-        expect(buildAgentRuns(events)).toMatchObject([{ id: 's1', eventCount: 2, status: 'success', files: ['src/a.ts'] }]);
-    });
-    it('normalizes guidance safely and builds an honest impact receipt', () => {
-        const events = [normalizeAgentEvent({
-                id: 'response-1', requestId: 'request-1', agentId: 'agent-1', timestamp: '2026-01-01T00:00:00Z',
-                type: 'tool_response', status: 'success',
-                guidance: {
-                    kind: 'context-scope',
-                    recommendation: 'Read only the two evidence-backed files.',
-                    patternRefs: [{ id: 'p1', label: 'withTransaction' }, { bad: true }],
-                    lessonRefs: [{ id: 'l1', label: 'Bound retries' }],
-                    selectedFiles: ['src/a.ts', 42],
-                    excludedFileCount: 18,
-                },
-                telemetry: {
-                    candidateTokens: 2400,
-                    returnedTokens: 400,
-                    candidateFiles: 20,
-                    returnedFiles: 2,
-                    cacheStatus: 'exact-hit',
-                    classification: 'measured estimate',
-                },
-            })];
-        expect(events[0].guidance?.selectedFiles).toEqual(['src/a.ts']);
-        expect(buildAgentRuns(events)[0].impact).toMatchObject({
-            guidanceCount: 1,
-            knowledgeItems: 2,
-            avoidedTokens: 2000,
-            excludedFiles: 18,
-            cacheHits: 1,
-        });
-    });
-    it('ignores malformed guidance rather than breaking legacy history', () => {
-        const event = normalizeAgentEvent({ guidance: { kind: 'context-scope', recommendation: 42 }, telemetry: 'bad' });
-        expect(event.guidance).toBeUndefined();
-        expect(event.telemetry).toBeUndefined();
-    });
-});
-describe('normalizeAgentEvents', () => {
-    it('carries request identity into the matching response', () => {
-        const events = normalizeAgentEvents([
-            {
-                type: 'tool_call', requestId: 'request-1', tool: 'rigour_checkpoint',
-                timestamp: '2026-09-10T00:00:00Z',
-                arguments: { agentId: 'agent-a', taskId: 'task-a', filesChanged: ['src/a.ts'] },
-            },
-            {
-                type: 'tool_response', requestId: 'request-1', tool: 'rigour_checkpoint', status: 'success',
-                timestamp: '2026-09-10T00:00:01Z',
-            },
-        ]);
-        expect(events[1]).toMatchObject({ agentId: 'agent-a', taskId: 'task-a', files: ['src/a.ts'] });
-        expect(buildAgentRuns(events)).toHaveLength(1);
-    });
-});

package/dist/services/context-scope-summary.test.d.ts

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

package/dist/services/context-scope-summary.test.js

@@ -1,17 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { getContextScopeSummary } from './context-telemetry-service.js';
-let root;
-beforeEach(() => { root = fs.mkdtempSync(path.join(os.tmpdir(), 'scope-summary-')); });
-afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
-describe('getContextScopeSummary', () => {
-    it('counts rule files and skips a rules directory such as .clinerules/', async () => {
-        fs.mkdirSync(path.join(root, '.clinerules'));
-        fs.writeFileSync(path.join(root, '.clinerules', 'rigour.md'), 'rules');
-        fs.writeFileSync(path.join(root, 'CLAUDE.md'), 'Use small PRs.');
-        const summary = await getContextScopeSummary(root);
-        expect(summary.alwaysOnRuleTokens).toBeGreaterThan(0);
-    });
-});

package/dist/services/context-telemetry-service.test.d.ts

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

package/dist/services/context-telemetry-service.test.js

@@ -1,182 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import path from 'path';
-import os from 'os';
-import fs from 'fs-extra';
-vi.mock('../storage/db.js', () => ({
-    isSQLiteAvailable: () => false,
-    openDatabase: async () => null,
-    DB_PATH: '/tmp/rigour-test.db',
-    RIGOUR_DIR: '/tmp/.rigour',
-}));
-import { getTaskContextStats, getTaskCostStats, getCacheStats, importCursorUsageCsv, importCursorUsageJson, getContextScopeSummary, getCheckpointSummary, estimateTokenCount, } from './context-telemetry-service.js';
-import { recordContextEvent, recordCheckpointMetric } from '../storage/context-telemetry.js';
-describe('context-telemetry-service', () => {
-    const testCwd = path.join(os.tmpdir(), `rigour-ctx-service-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    const taskId = `task-${Date.now()}`;
-    beforeEach(async () => {
-        await fs.ensureDir(path.join(testCwd, '.rigour'));
-    });
-    afterEach(async () => {
-        await fs.remove(testCwd);
-    });
-    it('returns zeroed stats when no telemetry exists for task', async () => {
-        const stats = await getTaskContextStats(taskId, testCwd);
-        expect(stats.retrievals).toBe(0);
-        expect(stats.candidateTokens).toBe(0);
-        expect(stats.potentialAvoidedTokens).toBe(0);
-        expect(stats.isEstimated).toBe(true);
-    });
-    it('calculates avoided context from recorded events', async () => {
-        await recordContextEvent({
-            taskId,
-            toolName: 'rigour_check_pattern',
-            cacheStatus: 'exact-hit',
-            candidateTokens: 10000,
-            returnedTokens: 2000,
-            deduplicatedTokens: 3000,
-        }, testCwd);
-        const stats = await getTaskContextStats(taskId, testCwd);
-        expect(stats.retrievals).toBe(1);
-        expect(stats.potentialAvoidedTokens).toBe(8000);
-        expect(stats.repeatedReadsPrevented).toBeGreaterThan(0);
-        expect(stats.deduplicatedTokens).toBe(3000);
-        expect(stats.isEstimated).toBe(false);
-    });
-    it('aggregates cache performance from events', async () => {
-        const cacheTaskId = `${taskId}-cache`;
-        await recordContextEvent({
-            taskId: cacheTaskId,
-            toolName: 'rigour_recall',
-            cacheStatus: 'exact-hit',
-            candidateTokens: 1000,
-            returnedTokens: 200,
-        }, testCwd);
-        await recordContextEvent({
-            taskId: cacheTaskId,
-            toolName: 'rigour_context_explain',
-            cacheStatus: 'miss',
-            candidateTokens: 500,
-            returnedTokens: 500,
-        }, testCwd);
-        const events = await import('../storage/context-telemetry.js').then(m => m.getContextEvents(cacheTaskId, testCwd));
-        const cache = await getCacheStats(testCwd);
-        const taskHits = events.filter(e => e.cacheStatus === 'exact-hit').length;
-        const taskMisses = events.filter(e => e.cacheStatus === 'miss').length;
-        expect(taskHits).toBe(1);
-        expect(taskMisses).toBe(1);
-        expect(cache.hitRate).toBe(0.5);
-        expect(cache.isEstimated).toBe(false);
-    });
-    it('imports CSV usage and marks cost stats as observed', async () => {
-        const csv = `Date,Model,Input Tokens,Output Tokens,Cost
-2026-08-05,claude-3-5-sonnet,510000,62000,4.83`;
-        const imported = await importCursorUsageCsv(csv, testCwd);
-        expect(imported).toBe(1);
-        const cost = await getTaskCostStats('cursor-imported', testCwd);
-        expect(cost.actual.inputTokens).toBe(510000);
-        expect(cost.actual.costUsd).toBe(4.83);
-        expect(cost.actual.isEstimated).toBe(false);
-        expect(cost.actual.classification).toBe('observed');
-    });
-    it('deduplicates CSV rows on re-import', async () => {
-        const csv = `Date,Model,Input Tokens,Output Tokens,Cost
-2026-08-05,claude-3-5-sonnet,1000,100,1.00`;
-        expect(await importCursorUsageCsv(csv, testCwd)).toBe(1);
-        expect(await importCursorUsageCsv(csv, testCwd)).toBe(0);
-    });
-    it('imports JSON usage records', async () => {
-        const jsonTaskId = `${taskId}-json-${Math.random().toString(36).slice(2)}`;
-        const imported = await importCursorUsageJson([{
-                taskId: jsonTaskId,
-                inputTokens: 2500,
-                outputTokens: 300,
-                observedCostUsd: 0.42,
-                model: 'gpt-4o',
-            }], testCwd);
-        expect(imported).toBe(1);
-        const cost = await getTaskCostStats(jsonTaskId, testCwd);
-        expect(cost.actual.inputTokens).toBe(2500);
-    });
-    it('imports Admin API JSON events with chargedCents and dedupes against sync IDs', async () => {
-        const adminEvent = {
-            timestamp: '1750979225854',
-            conversationId: 'conv-dedupe',
-            model: 'composer-2.5-standard',
-            chargedCents: 42.5,
-            tokenUsage: { inputTokens: 100, outputTokens: 50 },
-        };
-        expect(await importCursorUsageJson([adminEvent], testCwd)).toBe(1);
-        expect(await importCursorUsageJson([adminEvent], testCwd)).toBe(0);
-        const cost = await getTaskCostStats('conv-dedupe', testCwd);
-        expect(cost.actual.costUsd).toBeCloseTo(0.425, 3);
-        expect(cost.actual.isEstimated).toBe(false);
-    });
-    it('summarizes agent scope overlap from session file', async () => {
-        await fs.writeJson(path.join(testCwd, '.rigour', 'agent-session.json'), {
-            agents: [
-                { agentId: 'agent-a', taskScope: ['src/api/**'] },
-                { agentId: 'agent-b', taskScope: ['src/api/**', 'tests/**'] },
-            ],
-        });
-        const scope = await getContextScopeSummary(testCwd);
-        expect(scope.activeAgentCount).toBe(2);
-        expect(scope.overlappingScopesResolved).toBeGreaterThan(0);
-    });
-    it('estimates governance rule token overhead from AGENTS.md', async () => {
-        await fs.writeFile(path.join(testCwd, 'AGENTS.md'), '# Agent rules\n'.repeat(40));
-        const scope = await getContextScopeSummary(testCwd);
-        expect(scope.alwaysOnRuleTokens).toBe(estimateTokenCount('# Agent rules\n'.repeat(40)));
-    });
-    it('aggregates checkpoint compression metrics', async () => {
-        const cpTaskId = `${taskId}-cp`;
-        await recordCheckpointMetric({
-            checkpointId: `checkpoint:${cpTaskId}:a1:phase`,
-            taskId: cpTaskId,
-            agentId: 'a1',
-            rawStateTokens: 10000,
-            checkpointTokens: 500,
-            replayTokensAvoided: 9500,
-        }, testCwd);
-        const summary = await getCheckpointSummary(cpTaskId, testCwd);
-        expect(summary.checkpointCount).toBe(1);
-        expect(summary.rawStateTokens).toBe(10000);
-        expect(summary.compressionRatio).toBe(20);
-        expect(summary.replayTokensAvoided).toBe(9500);
-    });
-    it('marks observed cost from usages and estimates avoided cost by model', async () => {
-        const jsonTaskId = `${taskId}-composer-${Math.random().toString(36).slice(2)}`;
-        await importCursorUsageJson([{
-                id: `json-composer-${jsonTaskId}`,
-                taskId: jsonTaskId,
-                inputTokens: 2_000_000,
-                outputTokens: 0,
-                observedCostUsd: 1.25,
-                model: 'composer-2.5-standard',
-                source: 'cursor-admin-api',
-            }], testCwd);
-        await recordContextEvent({
-            taskId: jsonTaskId,
-            toolName: 'rigour_context_scope',
-            cacheStatus: 'miss',
-            candidateTokens: 3_000_000,
-            returnedTokens: 1_000_000,
-        }, testCwd);
-        const cost = await getTaskCostStats(jsonTaskId, testCwd);
-        expect(cost.actual.isEstimated).toBe(false);
-        expect(cost.actual.costUsd).toBe(1.25);
-        expect(cost.estimated.isEstimated).toBe(true);
-        expect(cost.estimated.inputPricePerMillionUsd).toBe(0.5);
-        expect(cost.estimated.estimatedCostAvoidedUsd).toBeGreaterThan(0);
-    });
-    it('does not combine retrieval and checkpoint counterfactuals', async () => {
-        const id = `${taskId}-separate-${Math.random().toString(36).slice(2)}`;
-        await recordContextEvent({ taskId: id, toolName: 'rigour_context_scope', cacheStatus: 'miss', candidateTokens: 5000, returnedTokens: 1000 }, testCwd);
-        await recordCheckpointMetric({ checkpointId: `${id}-cp`, taskId: id, agentId: 'a1', rawStateTokens: 9000, checkpointTokens: 1000, replayTokensAvoided: 8000 }, testCwd);
-        const cost = await getTaskCostStats(id, testCwd);
-        expect(cost.estimated.retrievalAvoidedTokens).toBe(4000);
-        expect(cost.estimated.checkpointReplayAvoidedTokens).toBe(8000);
-        expect(cost.estimated.potentialContextAvoided).toBe(4000);
-        expect(cost.estimated.categoriesAreAdditive).toBe(false);
-        expect(cost.estimated.retrievalAvoidedCostRangeUsd?.max).toBeGreaterThan(cost.estimated.retrievalAvoidedCostRangeUsd?.min ?? 0);
-    });
-});

package/dist/services/cursor-usage-sync.test.d.ts

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

package/dist/services/cursor-usage-sync.test.js

@@ -1,173 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import path from 'path';
-import os from 'os';
-import fs from 'fs-extra';
-vi.mock('../storage/db.js', () => ({
-    isSQLiteAvailable: () => false,
-    openDatabase: async () => null,
-    DB_PATH: '/tmp/rigour-test.db',
-    RIGOUR_DIR: '/tmp/.rigour',
-}));
-import { fetchCursorUsageFromAdminApi, syncCursorUsageFromAdminApi, getTaskCostStats, } from './context-telemetry-service.js';
-import { getModelUsages } from '../storage/context-telemetry.js';
-import { centsToUsd, normalizeCursorUsageEvent } from './cursor-usage-normalizer.js';
-import { CURSOR_FILTERED_USAGE_URL } from './cursor-usage-client.js';
-function buildUsageEvent(overrides = {}) {
-    return {
-        timestamp: '1750979225854',
-        userEmail: 'dev@example.com',
-        conversationId: 'conv-1',
-        model: 'composer-2.5-standard',
-        isTokenBasedCall: true,
-        tokenUsage: {
-            inputTokens: 100,
-            outputTokens: 50,
-            cacheWriteTokens: 10,
-            cacheReadTokens: 20,
-            totalCents: 12.5,
-        },
-        chargedCents: 15.25,
-        ...overrides,
-    };
-}
-describe('cursor admin usage sync', () => {
-    const testCwd = path.join(os.tmpdir(), `rigour-cursor-sync-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    const apiKey = 'test-cursor-admin-key';
-    beforeEach(async () => {
-        await fs.ensureDir(path.join(testCwd, '.rigour'));
-    });
-    afterEach(async () => {
-        await fs.remove(testCwd);
-        vi.restoreAllMocks();
-    });
-    it('imports a single-page response with basic auth header', async () => {
-        const fetchImpl = vi.fn(async (_url, init) => ({
-            ok: true,
-            status: 200,
-            json: async () => ({
-                usageEvents: [buildUsageEvent()],
-                pagination: { hasNextPage: false, currentPage: 1 },
-            }),
-        }));
-        const imported = await fetchCursorUsageFromAdminApi({
-            cwd: testCwd,
-            apiKey,
-            fetchImpl,
-        });
-        expect(imported).toBe(1);
-        expect(fetchImpl).toHaveBeenCalledTimes(1);
-        const [, init] = fetchImpl.mock.calls[0];
-        expect(init.method).toBe('POST');
-        expect(init.headers.Authorization).toBe(`Basic ${Buffer.from(`${apiKey}:`, 'utf8').toString('base64')}`);
-        expect(init.headers['Content-Type']).toBe('application/json');
-        const body = JSON.parse(init.body);
-        expect(body.pageSize).toBeGreaterThan(0);
-        expect(body.startDate).toBeLessThan(body.endDate);
-    });
-    it('paginates until hasNextPage is false', async () => {
-        let page = 0;
-        const fetchImpl = vi.fn(async () => {
-            page += 1;
-            return {
-                ok: true,
-                status: 200,
-                json: async () => ({
-                    usageEvents: [buildUsageEvent({ conversationId: `conv-${page}` })],
-                    pagination: { hasNextPage: page < 2, currentPage: page },
-                }),
-            };
-        });
-        const result = await syncCursorUsageFromAdminApi({ cwd: testCwd, apiKey, fetchImpl });
-        expect(result.importedCount).toBe(2);
-        expect(result.totalEvents).toBe(2);
-        expect(fetchImpl).toHaveBeenCalledTimes(2);
-    });
-    it('converts cents to USD and stores token fields', async () => {
-        const normalized = normalizeCursorUsageEvent(buildUsageEvent());
-        expect(normalized?.usage.observedCostUsd).toBe(centsToUsd(15.25));
-        expect(normalized?.usage.inputTokens).toBe(100);
-        expect(normalized?.usage.outputTokens).toBe(50);
-        expect(normalized?.usage.cachedInputTokens).toBe(20);
-        expect(normalized?.usage.cacheWriteTokens).toBe(10);
-        expect(normalized?.usage.source).toBe('cursor-admin-api');
-    });
-    it('deduplicates repeated syncs', async () => {
-        const fetchImpl = vi.fn(async () => ({
-            ok: true,
-            status: 200,
-            json: async () => ({
-                usageEvents: [buildUsageEvent()],
-                pagination: { hasNextPage: false },
-            }),
-        }));
-        const first = await fetchCursorUsageFromAdminApi({ cwd: testCwd, apiKey, fetchImpl });
-        const second = await fetchCursorUsageFromAdminApi({ cwd: testCwd, apiKey, fetchImpl });
-        expect(first).toBe(1);
-        expect(second).toBe(0);
-        const usages = await getModelUsages(undefined, testCwd);
-        expect(usages.filter(u => u.source === 'cursor-admin-api')).toHaveLength(1);
-    });
-    it('surfaces actionable non-2xx errors without exposing the API key', async () => {
-        const fetchImpl = vi.fn(async () => ({
-            ok: false,
-            status: 401,
-            text: async () => `Unauthorized for key ${apiKey}`,
-        }));
-        await expect(fetchCursorUsageFromAdminApi({ cwd: testCwd, apiKey, fetchImpl })).rejects.toThrow(/401/);
-        await expect(fetchCursorUsageFromAdminApi({ cwd: testCwd, apiKey, fetchImpl })).rejects.not.toThrow(apiKey);
-    });
-    it('skips malformed events and handles partial fields', async () => {
-        const fetchImpl = vi.fn(async () => ({
-            ok: true,
-            status: 200,
-            json: async () => ({
-                usageEvents: [
-                    null,
-                    { model: 'composer-2.5-fast', chargedCents: 5 },
-                    buildUsageEvent(),
-                ],
-                pagination: { hasNextPage: false },
-            }),
-        }));
-        const imported = await fetchCursorUsageFromAdminApi({ cwd: testCwd, apiKey, fetchImpl });
-        expect(imported).toBe(2);
-    });
-    it('marks observed cost stats from imported admin API events', async () => {
-        const fetchImpl = vi.fn(async () => ({
-            ok: true,
-            status: 200,
-            json: async () => ({
-                usageEvents: [buildUsageEvent({ conversationId: 'cost-task' })],
-                pagination: { hasNextPage: false },
-            }),
-        }));
-        await fetchCursorUsageFromAdminApi({ cwd: testCwd, apiKey, fetchImpl });
-        const cost = await getTaskCostStats('cost-task', testCwd);
-        expect(cost.actual.isEstimated).toBe(false);
-        expect(cost.actual.costUsd).toBeGreaterThan(0);
-        expect(cost.actual.pricingBasis).toBe('observed-cursor-charged-cents');
-    });
-    it('targets the filtered usage events endpoint', () => {
-        expect(CURSOR_FILTERED_USAGE_URL).toBe('https://api.cursor.com/teams/filtered-usage-events');
-    });
-    it('errors when pagination exceeds the defensive page limit', async () => {
-        let page = 0;
-        const fetchImpl = vi.fn(async () => {
-            page += 1;
-            return {
-                ok: true,
-                status: 200,
-                json: async () => ({
-                    usageEvents: [buildUsageEvent({ conversationId: `conv-page-${page}` })],
-                    pagination: { hasNextPage: true, currentPage: page },
-                }),
-            };
-        });
-        await expect(fetchCursorUsageFromAdminApi({
-            cwd: testCwd,
-            apiKey,
-            fetchImpl,
-            maxPages: 2,
-        })).rejects.toThrow(/truncated after 2 pages/);
-    });
-});

package/dist/services/engineering-knowledge-graph.test.d.ts

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