@kaelio/ktx 0.5.0 → 0.7.0

package/dist/context/ingest/page-triage/page-triage.service.test.js

@@ -1,311 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { PageTriageService } from './page-triage.service.js';
-describe('PageTriageService', () => {
-    let stagedDir;
-    let repository;
-    let service;
-    let triageSettings;
-    let promptService;
-    let adapter;
-    let llmRuntime;
-    beforeEach(async () => {
-        stagedDir = await mkdtemp(join(tmpdir(), 'page-triage-'));
-        await mkdir(join(stagedDir, 'pages', 'page-1'), { recursive: true });
-        await writeFile(join(stagedDir, 'pages', 'page-1', 'metadata.json'), JSON.stringify({
-            objectType: 'page',
-            id: 'page-1',
-            title: 'Support Handoff',
-            path: 'Company / Support Handoff',
-            url: null,
-            parentId: null,
-            databaseId: null,
-            dataSourceId: null,
-            lastEditedAt: '2026-04-29T12:00:00.000Z',
-            lastEditedBy: null,
-            properties: { Status: 'Approved' },
-        }), 'utf-8');
-        await writeFile(join(stagedDir, 'pages', 'page-1', 'page.md'), '# Support Handoff\n\nSupport handoffs require a named customer owner.\n', 'utf-8');
-        repository = {
-            setDocumentTriageLane: vi.fn().mockResolvedValue(1),
-            listDocumentChunksForLightExtraction: vi.fn().mockResolvedValue([
-                {
-                    chunkId: '00000000-0000-0000-0000-000000000101',
-                    headingPath: ['Support Handoff'],
-                    ordinal: 0,
-                    content: 'Support handoffs require a named customer owner.',
-                    stableCitationKey: 'notion:page-1:support-handoff',
-                    citation: { source: 'notion', pageId: 'page-1' },
-                    rawPath: 'pages/page-1/page.md',
-                    title: 'Support Handoff',
-                    path: 'Company / Support Handoff',
-                    url: null,
-                    lastEditedAt: new Date('2026-04-29T12:00:00.000Z'),
-                },
-            ]),
-            insertCandidate: vi
-                .fn()
-                .mockImplementation((input) => Promise.resolve({ candidate_key: input.candidateKey, promotion_score: input.promotionScore })),
-        };
-        triageSettings = {
-            enabled: true,
-            maxConcurrency: 2,
-            lightExtractionEnabled: true,
-            classifierModel: null,
-            lightExtractionMaxCandidates: 3,
-        };
-        adapter = {
-            triageSupported: true,
-            getTriageSignals: vi.fn().mockResolvedValue({ objectType: 'page', propertyHints: { Status: 'Approved' } }),
-        };
-        promptService = {
-            loadPrompt: vi
-                .fn()
-                .mockImplementation((name) => Promise.resolve(`prompt:${name}`)),
-        };
-        llmRuntime = {
-            generateText: vi.fn(),
-            generateObject: vi.fn(),
-            runAgentLoop: vi.fn(),
-        };
-        service = new PageTriageService({
-            store: repository,
-            llmRuntime: llmRuntime,
-            settings: triageSettings,
-            promptService: promptService,
-        });
-    });
-    afterEach(async () => {
-        await rm(stagedDir, { recursive: true, force: true });
-    });
-    it('writes light-lane candidates and keeps the page out of full WorkUnits', async () => {
-        llmRuntime.generateText
-            .mockResolvedValueOnce(JSON.stringify({ lane: 'light', reason: 'short durable policy' }))
-            .mockResolvedValueOnce(JSON.stringify({
-            candidates: [
-                {
-                    candidateKey: 'support-handoff-owner',
-                    topic: 'Support Handoff',
-                    assertion: 'Support handoffs require a named customer owner.',
-                    rationale: 'The staged Support Handoff page states the owner rule.',
-                    evidenceChunkIds: ['00000000-0000-0000-0000-000000000101'],
-                    suggestedPageKey: 'support-handoff',
-                    actionHint: 'create',
-                    durabilityScore: 3,
-                    authorityScore: 2,
-                    reuseScore: 3,
-                    noveltyScore: 2,
-                    riskScore: 0,
-                },
-            ],
-        }));
-        const result = await service.triageRun({
-            stagedDir,
-            runId: 'run-1',
-            connectionId: 'conn-1',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            jobId: 'job-1',
-            diffSet: {
-                added: ['pages/page-1/metadata.json', 'pages/page-1/page.md'],
-                modified: [],
-                deleted: [],
-                unchanged: [],
-            },
-            adapter: adapter,
-        });
-        expect(result.enabled).toBe(true);
-        expect(result.report).toEqual({
-            pageCount: 1,
-            skip: 0,
-            light: 1,
-            full: 0,
-            classifierFailures: 0,
-            lightExtractionFailures: 0,
-        });
-        expect(result.fullRawPaths.has('pages/page-1/page.md')).toBe(false);
-        expect(adapter.getTriageSignals).toHaveBeenCalledWith(stagedDir, 'page-1');
-        expect(llmRuntime.generateText).toHaveBeenCalledWith(expect.objectContaining({ role: 'triage' }));
-        expect(repository.setDocumentTriageLane).toHaveBeenCalledWith('run-1', 'pages/page-1/page.md', 'light');
-        expect(repository.insertCandidate).toHaveBeenCalledWith(expect.objectContaining({
-            runId: 'run-1',
-            candidateKey: 'support-handoff-owner',
-            lane: 'light',
-            promotionScore: 10,
-        }));
-    });
-    it('does not classify named reusable sales scripts as skip', async () => {
-        await writeFile(join(stagedDir, 'pages', 'page-1', 'metadata.json'), JSON.stringify({
-            objectType: 'page',
-            id: 'page-1',
-            title: 'Cold Call Script',
-            path: 'Sales / Cold Call Script',
-            url: null,
-            parentId: null,
-            databaseId: null,
-            dataSourceId: null,
-            lastEditedAt: '2026-04-29T12:00:00.000Z',
-            lastEditedBy: null,
-            properties: { Team: 'Sales' },
-        }), 'utf-8');
-        await writeFile(join(stagedDir, 'pages', 'page-1', 'page.md'), [
-            '# Cold Call Script',
-            '',
-            'Reusable outbound sequence:',
-            '',
-            '- Ask about current customer success expansion workflow.',
-            '- Position KTX as AI search visibility for CS teams.',
-            '- Close with a discovery call request.',
-        ].join('\n'), 'utf-8');
-        promptService.loadPrompt.mockImplementation((name) => {
-            if (name === 'skills/page_triage_classifier') {
-                return Promise.resolve([
-                    'Reusable templates and scripts are durable knowledge regardless of subject matter.',
-                    'Date-titled standups are still skip; named templates and scripts are not.',
-                ].join('\n'));
-            }
-            return Promise.resolve(`prompt:${name}`);
-        });
-        llmRuntime.generateText
-            .mockImplementationOnce((args) => {
-            const systemText = args.system;
-            const userText = args.prompt;
-            expect(systemText).toContain('Reusable templates and scripts are durable knowledge regardless of subject matter.');
-            expect(systemText).toContain('Date-titled standups are still skip; named templates and scripts are not.');
-            expect(userText).toContain('Cold Call Script');
-            expect(userText).not.toContain('Reusable templates and scripts are durable knowledge');
-            return JSON.stringify({ lane: 'light', reason: 'reusable sales script' });
-        })
-            .mockResolvedValueOnce(JSON.stringify({
-            candidates: [
-                {
-                    candidateKey: 'cold-call-script',
-                    topic: 'Cold Call Script',
-                    assertion: 'Cold call outreach should position KTX around AI search visibility for CS teams.',
-                    rationale: 'The script gives a reusable outbound call sequence and positioning language.',
-                    evidenceChunkIds: ['00000000-0000-0000-0000-000000000101'],
-                    suggestedPageKey: 'cold-call-script',
-                    actionHint: 'create',
-                    durabilityScore: 3,
-                    authorityScore: 2,
-                    reuseScore: 3,
-                    noveltyScore: 2,
-                    riskScore: 0,
-                },
-            ],
-        }));
-        const result = await service.triageRun({
-            stagedDir,
-            runId: 'run-1',
-            connectionId: 'conn-1',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            jobId: 'job-1',
-            diffSet: {
-                added: ['pages/page-1/metadata.json', 'pages/page-1/page.md'],
-                modified: [],
-                deleted: [],
-                unchanged: [],
-            },
-            adapter: adapter,
-        });
-        expect(result.report).toMatchObject({ pageCount: 1, skip: 0, light: 1, full: 0 });
-        expect(repository.setDocumentTriageLane).toHaveBeenCalledWith('run-1', 'pages/page-1/page.md', 'light');
-    });
-    it('triages Notion data-source row pages without reading data-source metadata as page markdown', async () => {
-        triageSettings.lightExtractionEnabled = false;
-        await mkdir(join(stagedDir, 'data-sources', 'ds-1', 'rows', 'row-1'), { recursive: true });
-        await writeFile(join(stagedDir, 'data-sources', 'ds-1', 'metadata.json'), JSON.stringify({
-            objectType: 'data_source',
-            id: 'ds-1',
-            title: 'Product Docs',
-            path: 'Product Docs',
-        }), 'utf-8');
-        await writeFile(join(stagedDir, 'data-sources', 'ds-1', 'rows', 'row-1', 'metadata.json'), JSON.stringify({
-            objectType: 'data_source_row',
-            id: 'row-1',
-            title: 'Launch Policy',
-            path: 'Product Docs / Launch Policy',
-            dataSourceId: 'ds-1',
-        }), 'utf-8');
-        await writeFile(join(stagedDir, 'data-sources', 'ds-1', 'rows', 'row-1', 'page.md'), '# Launch Policy\n\nLaunches require a customer-facing rollback owner.\n', 'utf-8');
-        llmRuntime.generateText.mockResolvedValue(JSON.stringify({ lane: 'full', reason: 'durable policy page' }));
-        const result = await service.triageRun({
-            stagedDir,
-            runId: 'run-1',
-            connectionId: 'conn-1',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            jobId: 'job-1',
-            diffSet: {
-                added: [
-                    'pages/page-1/metadata.json',
-                    'pages/page-1/page.md',
-                    'data-sources/ds-1/metadata.json',
-                    'data-sources/ds-1/rows/row-1/metadata.json',
-                    'data-sources/ds-1/rows/row-1/page.md',
-                ],
-                modified: [],
-                deleted: [],
-                unchanged: [],
-            },
-            adapter: adapter,
-        });
-        expect(result.report).toMatchObject({ pageCount: 2, skip: 0, light: 0, full: 2 });
-        expect([...result.fullRawPaths].sort()).toEqual(expect.arrayContaining(['data-sources/ds-1/rows/row-1/page.md', 'pages/page-1/page.md']));
-        expect(result.fullRawPaths.has('data-sources/ds-1/metadata.json')).toBe(false);
-        expect(repository.setDocumentTriageLane).toHaveBeenCalledWith('run-1', 'data-sources/ds-1/rows/row-1/page.md', 'full');
-    });
-    it('falls back to full when classifier output is malformed', async () => {
-        llmRuntime.generateText.mockResolvedValueOnce('not-json');
-        const result = await service.triageRun({
-            stagedDir,
-            runId: 'run-1',
-            connectionId: 'conn-1',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            jobId: 'job-1',
-            diffSet: { added: ['pages/page-1/page.md'], modified: [], deleted: [], unchanged: [] },
-            adapter: adapter,
-        });
-        expect(result.report).toMatchObject({ pageCount: 1, skip: 0, light: 0, full: 1, classifierFailures: 1 });
-        expect(result.fullRawPaths.has('pages/page-1/page.md')).toBe(true);
-        expect(repository.setDocumentTriageLane).toHaveBeenCalledWith('run-1', 'pages/page-1/page.md', 'full');
-    });
-    it('promotes a light page to full when light extraction fails', async () => {
-        llmRuntime.generateText
-            .mockResolvedValueOnce(JSON.stringify({ lane: 'light', reason: 'short durable policy' }))
-            .mockRejectedValueOnce(new Error('provider unavailable'));
-        const result = await service.triageRun({
-            stagedDir,
-            runId: 'run-1',
-            connectionId: 'conn-1',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            jobId: 'job-1',
-            diffSet: { added: ['pages/page-1/page.md'], modified: [], deleted: [], unchanged: [] },
-            adapter: adapter,
-        });
-        expect(result.report).toMatchObject({ pageCount: 1, skip: 0, light: 0, full: 1, lightExtractionFailures: 1 });
-        expect(result.fullRawPaths.has('pages/page-1/page.md')).toBe(true);
-        expect(repository.setDocumentTriageLane).toHaveBeenLastCalledWith('run-1', 'pages/page-1/page.md', 'full');
-    });
-    it('short-circuits when triage is disabled', async () => {
-        triageSettings.enabled = false;
-        const result = await service.triageRun({
-            stagedDir,
-            runId: 'run-1',
-            connectionId: 'conn-1',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            jobId: 'job-1',
-            diffSet: { added: ['pages/page-1/page.md'], modified: [], deleted: [], unchanged: [] },
-            adapter: adapter,
-        });
-        expect(result).toEqual({ enabled: false, report: undefined, fullRawPaths: new Set(), warnings: [] });
-        expect(llmRuntime.generateText).not.toHaveBeenCalled();
-        expect(repository.setDocumentTriageLane).not.toHaveBeenCalled();
-    });
-});

package/dist/context/ingest/raw-sources-paths.test.d.ts

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

package/dist/context/ingest/raw-sources-paths.test.js

@@ -1,18 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildSyncId, provenanceMarker, rawSourcesDirForSync, rawSourcesRoot } from './raw-sources-paths.js';
-describe('raw-sources paths', () => {
-    it('buildSyncId uses timestamp + jobId', () => {
-        const id = buildSyncId(new Date('2026-04-22T14:30:00Z'), 'job-abc');
-        expect(id).toBe('2026-04-22-143000-job-abc');
-    });
-    it('rawSourcesDirForSync composes the canonical path', () => {
-        const path = rawSourcesDirForSync('c1', 'fake', 's1');
-        expect(path).toBe('raw-sources/c1/fake/s1');
-    });
-    it('rawSourcesRoot is stable', () => {
-        expect(rawSourcesRoot).toBe('raw-sources');
-    });
-    it('provenanceMarker produces the documented HTML-comment shape', () => {
-        expect(provenanceMarker('raw-sources/c1/fake/s1/a.yml', 15, 28)).toBe('<!-- from: raw-sources/c1/fake/s1/a.yml#L15-28 -->');
-    });
-});

package/dist/context/ingest/repo-fetch.test.d.ts

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

package/dist/context/ingest/repo-fetch.test.js

@@ -1,168 +0,0 @@
-import { access, mkdir, mkdtemp, readFile, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { makeLocalGitRepo } from '../test/make-local-git-repo.js';
-const FIXTURE_ROOT = join(__dirname, '../../test/fixtures/lookml/single-model');
-async function loadRepoFetch() {
-    return await import('./repo-fetch.js');
-}
-describe('repo-fetch', () => {
-    let tmpRoot;
-    beforeEach(async () => {
-        tmpRoot = await mkdtemp(join(tmpdir(), 'repo-fetch-'));
-        vi.resetModules();
-        vi.doUnmock('./git-env.js');
-    });
-    afterEach(async () => {
-        vi.restoreAllMocks();
-        vi.resetModules();
-        vi.doUnmock('./git-env.js');
-        await rm(tmpRoot, { recursive: true, force: true });
-    });
-    it('builds authenticated URLs for GitHub, GitLab, generic hosts, empty tokens, and file URLs', async () => {
-        const { buildAuthenticatedUrl } = await loadRepoFetch();
-        expect(buildAuthenticatedUrl('https://github.com/acme/repo.git', null)).toBe('https://github.com/acme/repo.git');
-        expect(buildAuthenticatedUrl('file:///tmp/repo', 'tok')).toBe('file:///tmp/repo');
-        expect(buildAuthenticatedUrl('https://github.com/acme/repo.git', 'tok')).toBe('https://x-token-auth:tok@github.com/acme/repo.git');
-        expect(buildAuthenticatedUrl('https://gitlab.com/acme/repo.git', 'tok')).toBe('https://oauth2:tok@gitlab.com/acme/repo.git');
-        expect(buildAuthenticatedUrl('https://git.example.com/acme/repo.git', 'tok')).toBe('https://token:tok@git.example.com/acme/repo.git');
-    });
-    it('sanitizes both URL password patterns and literal token text', async () => {
-        const { sanitizeRepoError } = await loadRepoFetch();
-        const message = sanitizeRepoError(new Error('failed https://token:supersecret@git.example.com/acme/repo.git because supersecret expired'), // pragma: allowlist secret
-        'supersecret');
-        expect(message).toContain('https://token:***@git.example.com/acme/repo.git');
-        expect(message).not.toContain('supersecret');
-    });
-    it('validates required and URL-shaped repository configuration', async () => {
-        const { RepoConfigError, validateRepoConfig } = await loadRepoFetch();
-        expect(() => validateRepoConfig({ repoUrl: '' })).toThrow(RepoConfigError);
-        expect(() => validateRepoConfig({ repoUrl: 'not a url' })).toThrow(RepoConfigError);
-        expect(() => validateRepoConfig({ repoUrl: 'file:///tmp/repo' })).not.toThrow();
-    });
-    it('clones a local repo and returns the full 40-character commit hash', async () => {
-        const { cloneOrPull } = await loadRepoFetch();
-        const repo = await makeLocalGitRepo(FIXTURE_ROOT, join(tmpRoot, 'origin'));
-        const cacheDir = join(tmpRoot, 'cache', 'conn-1');
-        const result = await cloneOrPull({
-            repoUrl: repo.repoUrl,
-            cacheDir,
-            branch: 'main',
-        });
-        expect(result.commitHash).toMatch(/^[0-9a-f]{40}$/);
-        await expect(readFile(join(cacheDir, 'orders.model.lkml'), 'utf-8')).resolves.toMatch(/connection:/);
-    });
-    it('pulls an existing cache and returns the new origin commit hash', async () => {
-        const { cloneOrPull } = await loadRepoFetch();
-        const repo = await makeLocalGitRepo(FIXTURE_ROOT, join(tmpRoot, 'origin'));
-        const cacheDir = join(tmpRoot, 'cache', 'conn-pull');
-        const first = await cloneOrPull({ repoUrl: repo.repoUrl, cacheDir, branch: 'main' });
-        await repo.writeFile('views/orders.view.lkml', 'view: orders { sql_table_name: public.orders_v2 ;; }\n');
-        const secondCommit = await repo.commit('bump lookml view');
-        const second = await cloneOrPull({ repoUrl: repo.repoUrl, cacheDir, branch: 'main' });
-        expect(second.commitHash).toBe(secondCommit);
-        expect(second.commitHash).not.toBe(first.commitHash);
-        await expect(readFile(join(cacheDir, 'views', 'orders.view.lkml'), 'utf-8')).resolves.toMatch(/orders_v2/);
-    });
-    it('falls back to a fresh clone when the existing cache diverges locally', async () => {
-        const { cloneOrPull } = await loadRepoFetch();
-        const { createSimpleGit } = await import('./git-env.js');
-        const repo = await makeLocalGitRepo(FIXTURE_ROOT, join(tmpRoot, 'origin'));
-        const cacheDir = join(tmpRoot, 'cache', 'conn-diverged');
-        await cloneOrPull({ repoUrl: repo.repoUrl, cacheDir, branch: 'main' });
-        const cacheGit = createSimpleGit(cacheDir);
-        await cacheGit.addConfig('user.email', 'test@ktx.local');
-        await cacheGit.addConfig('user.name', 'KTX Test');
-        await writeFile(join(cacheDir, 'local-only.txt'), 'local commit\n', 'utf-8');
-        await cacheGit.add('.');
-        await cacheGit.commit('local-only divergent commit');
-        await repo.writeFile('views/orders.view.lkml', 'view: orders { sql_table_name: public.orders_remote ;; }\n');
-        const originCommit = await repo.commit('remote commit');
-        const result = await cloneOrPull({ repoUrl: repo.repoUrl, cacheDir, branch: 'main' });
-        expect(result.commitHash).toBe(originCommit);
-        await expect(access(join(cacheDir, 'local-only.txt'))).rejects.toThrow();
-        await expect(readFile(join(cacheDir, 'views', 'orders.view.lkml'), 'utf-8')).resolves.toMatch(/orders_remote/);
-    });
-    it('falls back to a fresh clone when the cache has a corrupt .git directory', async () => {
-        const { cloneOrPull } = await loadRepoFetch();
-        const repo = await makeLocalGitRepo(FIXTURE_ROOT, join(tmpRoot, 'origin'));
-        const cacheDir = join(tmpRoot, 'cache', 'conn-corrupt');
-        await mkdir(join(cacheDir, '.git'), { recursive: true });
-        await writeFile(join(cacheDir, '.git', 'HEAD'), 'garbage\n', 'utf-8');
-        const result = await cloneOrPull({ repoUrl: repo.repoUrl, cacheDir, branch: 'main' });
-        expect(result.commitHash).toMatch(/^[0-9a-f]{40}$/);
-        await expect(readFile(join(cacheDir, 'orders.model.lkml'), 'utf-8')).resolves.toMatch(/connection:/);
-    });
-    it('returns a sanitized RepoFetchError when fresh clone fails', async () => {
-        const { RepoFetchError, cloneOrPull } = await loadRepoFetch();
-        const repo = await makeLocalGitRepo(FIXTURE_ROOT, join(tmpRoot, 'origin'));
-        await expect(cloneOrPull({
-            repoUrl: repo.repoUrl,
-            cacheDir: join(tmpRoot, 'cache', 'missing-branch'),
-            branch: 'missing',
-            authToken: 'supersecret-token',
-        })).rejects.toThrow(RepoFetchError);
-        await expect(cloneOrPull({
-            repoUrl: repo.repoUrl,
-            cacheDir: join(tmpRoot, 'cache', 'missing-branch-2'),
-            branch: 'missing',
-            authToken: 'supersecret-token',
-        })).rejects.toThrow(expect.objectContaining({ message: expect.not.stringContaining('supersecret-token') }));
-    });
-    it('testRepoConnection returns ok true for a local repo and ok false for a missing local repo', async () => {
-        const { testRepoConnection } = await loadRepoFetch();
-        const repo = await makeLocalGitRepo(FIXTURE_ROOT, join(tmpRoot, 'origin'));
-        await expect(testRepoConnection({ repoUrl: repo.repoUrl })).resolves.toEqual({ ok: true });
-        const failed = await testRepoConnection({ repoUrl: `file://${join(tmpRoot, 'does-not-exist')}` });
-        expect(failed.ok).toBe(false);
-        if (!failed.ok) {
-            expect(failed.error).toEqual(expect.any(String));
-        }
-    });
-    it('cleans up non-existent and existing repository directories idempotently', async () => {
-        const { cleanupRepoDir } = await loadRepoFetch();
-        const existing = join(tmpRoot, 'cache', 'to-clean');
-        await mkdir(join(existing, '.git'), { recursive: true });
-        await cleanupRepoDir(existing);
-        await cleanupRepoDir(existing);
-        await expect(access(existing)).rejects.toThrow();
-    });
-    it('sets the remote URL on every pull so token rotation and token removal update cached .git/config', async () => {
-        const cacheDir = join(tmpRoot, 'cache', 'auth-refresh');
-        await mkdir(join(cacheDir, '.git'), { recursive: true });
-        const worktreeGit = {
-            remote: vi.fn(async () => undefined),
-            fetch: vi.fn(async () => undefined),
-            checkout: vi.fn(async () => undefined),
-            pull: vi.fn(async () => undefined),
-            log: vi.fn(async () => ({ latest: { hash: 'a'.repeat(40) } })),
-        };
-        const rootGit = {
-            clone: vi.fn(async () => undefined),
-        };
-        vi.doMock('./git-env.js', () => ({
-            createSimpleGit: vi.fn((baseDir) => (baseDir ? worktreeGit : rootGit)),
-        }));
-        const { cloneOrPull } = await loadRepoFetch();
-        await cloneOrPull({
-            repoUrl: 'https://github.com/acme/repo.git',
-            authToken: 'new-token',
-            cacheDir,
-            branch: 'main',
-        });
-        await cloneOrPull({
-            repoUrl: 'https://github.com/acme/repo.git',
-            authToken: null,
-            cacheDir,
-            branch: 'main',
-        });
-        expect(worktreeGit.remote).toHaveBeenCalledWith([
-            'set-url',
-            'origin',
-            'https://x-token-auth:new-token@github.com/acme/repo.git', // pragma: allowlist secret
-        ]);
-        expect(worktreeGit.remote).toHaveBeenCalledWith(['set-url', 'origin', 'https://github.com/acme/repo.git']);
-        expect(rootGit.clone).not.toHaveBeenCalled();
-    });
-});

package/dist/context/ingest/report-snapshot.test.d.ts

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