@kaelio/ktx 0.5.0 → 0.6.0

package/dist/context/connections/local-query-executor.test.js

@@ -1,48 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createDefaultLocalQueryExecutor } from './local-query-executor.js';
-describe('createDefaultLocalQueryExecutor', () => {
-    it('dispatches postgres and sqlite drivers to their executors', async () => {
-        const postgres = {
-            execute: vi.fn(async () => ({
-                headers: ['pg'],
-                rows: [[1]],
-                totalRows: 1,
-                command: 'SELECT',
-                rowCount: 1,
-            })),
-        };
-        const sqlite = {
-            execute: vi.fn(async () => ({
-                headers: ['sqlite'],
-                rows: [[2]],
-                totalRows: 1,
-                command: 'SELECT',
-                rowCount: 1,
-            })),
-        };
-        const executor = createDefaultLocalQueryExecutor({ postgres, sqlite });
-        await expect(executor.execute({
-            connectionId: 'pg',
-            connection: { driver: 'postgres' },
-            sql: 'select 1',
-        })).resolves.toMatchObject({ headers: ['pg'] });
-        await expect(executor.execute({
-            connectionId: 'local',
-            connection: { driver: 'sqlite' },
-            sql: 'select 1',
-        })).resolves.toMatchObject({ headers: ['sqlite'] });
-        expect(postgres.execute).toHaveBeenCalledTimes(1);
-        expect(sqlite.execute).toHaveBeenCalledTimes(1);
-    });
-    it('rejects unsupported local execution drivers', async () => {
-        const executor = createDefaultLocalQueryExecutor({
-            postgres: { execute: vi.fn() },
-            sqlite: { execute: vi.fn() },
-        });
-        await expect(executor.execute({
-            connectionId: 'warehouse',
-            connection: { driver: 'snowflake' },
-            sql: 'select 1',
-        })).rejects.toThrow('No local query executor is configured for driver "snowflake".');
-    });
-});

package/dist/context/connections/local-warehouse-descriptor.test.d.ts

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

package/dist/context/connections/local-warehouse-descriptor.test.js

@@ -1,53 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { localConnectionInfoFromConfig, localConnectionToWarehouseDescriptor, localConnectionTypeForConfig, } from './local-warehouse-descriptor.js';
-describe('localConnectionToWarehouseDescriptor', () => {
-    it('maps local Postgres URLs to canonical warehouse descriptors', () => {
-        expect(localConnectionToWarehouseDescriptor('warehouse', {
-            driver: 'postgres',
-            url: 'postgresql://readonly@db.example.test/analytics',
-        })).toMatchObject({
-            id: 'warehouse',
-            connection_type: 'POSTGRESQL',
-            host: 'db.example.test',
-            database: 'analytics',
-        });
-    });
-    it('maps BigQuery project and dataset from explicit fields', () => {
-        expect(localConnectionToWarehouseDescriptor('bq', {
-            driver: 'bigquery',
-            project_id: 'acme',
-            dataset_id: 'warehouse',
-        })).toMatchObject({
-            id: 'bq',
-            connection_type: 'BIGQUERY',
-            project_id: 'acme',
-            dataset_id: 'warehouse',
-        });
-    });
-    it('returns null for non-warehouse adapters', () => {
-        expect(localConnectionToWarehouseDescriptor('looker', {
-            driver: 'looker',
-            base_url: 'https://looker.example.com',
-            client_id: 'client',
-        })).toBeNull();
-    });
-});
-describe('local connection info helpers', () => {
-    it('returns canonical warehouse connection types for local catalogs', () => {
-        expect(localConnectionTypeForConfig('warehouse', { driver: 'postgres' })).toBe('POSTGRESQL');
-        expect(localConnectionTypeForConfig('bq', { driver: 'bigquery', project_id: 'acme' })).toBe('BIGQUERY');
-        expect(localConnectionTypeForConfig('snowflake', { driver: 'snowflake' })).toBe('SNOWFLAKE');
-    });
-    it('keeps non-warehouse adapter labels for display-only local connection surfaces', () => {
-        expect(localConnectionTypeForConfig('prod-metabase', { driver: 'metabase', api_url: 'https://metabase.example.com' })).toBe('metabase');
-        expect(localConnectionTypeForConfig('missing-driver', {})).toBe('unknown');
-    });
-    it('builds nullable local connection info records', () => {
-        expect(localConnectionInfoFromConfig('warehouse', { driver: 'postgres' })).toEqual({
-            id: 'warehouse',
-            name: 'warehouse',
-            connectionType: 'POSTGRESQL',
-        });
-        expect(localConnectionInfoFromConfig('missing', undefined)).toBeNull();
-    });
-});

package/dist/context/connections/notion-config.test.d.ts

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

package/dist/context/connections/notion-config.test.js

@@ -1,121 +0,0 @@
-import { mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { notionConnectionToPullConfig, parseNotionConnectionConfig, redactNotionConnectionConfig, resolveNotionAuthToken, } from './notion-config.js';
-describe('standalone Notion connection config', () => {
-    let tempDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-notion-config-'));
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('parses selected-root Notion config with safe defaults', () => {
-        const parsed = parseNotionConnectionConfig({
-            driver: 'notion',
-            auth_token_ref: 'env:NOTION_TOKEN',
-            crawl_mode: 'selected_roots',
-            root_page_ids: ['page-1'],
-        });
-        expect(parsed).toEqual({
-            driver: 'notion',
-            auth_token: null,
-            auth_token_ref: 'env:NOTION_TOKEN',
-            crawl_mode: 'selected_roots',
-            root_page_ids: ['page-1'],
-            root_database_ids: [],
-            root_data_source_ids: [],
-            max_pages_per_run: 1000,
-            max_knowledge_creates_per_run: 25,
-            max_knowledge_updates_per_run: 20,
-        });
-        expect(parsed).not.toHaveProperty('last_successful_cursor');
-    });
-    it('parses inline Notion auth tokens without requiring auth_token_ref', () => {
-        const parsed = parseNotionConnectionConfig({
-            driver: 'notion',
-            auth_token: '  ntn_inline_token  ',
-            crawl_mode: 'selected_roots',
-            root_page_ids: ['page-1'],
-        });
-        expect(parsed).toMatchObject({
-            driver: 'notion',
-            auth_token: 'ntn_inline_token',
-            auth_token_ref: null,
-            crawl_mode: 'selected_roots',
-            root_page_ids: ['page-1'],
-        });
-    });
-    it('redacts token references from display output', () => {
-        expect(redactNotionConnectionConfig(parseNotionConnectionConfig({
-            driver: 'notion',
-            auth_token_ref: 'file:/Users/example/.config/notion-token',
-            crawl_mode: 'all_accessible',
-            max_pages_per_run: 80,
-        }))).toEqual({
-            driver: 'notion',
-            hasAuthToken: true,
-            crawlMode: 'all_accessible',
-            rootPageIds: [],
-            rootDatabaseIds: [],
-            rootDataSourceIds: [],
-            maxPagesPerRun: 80,
-            maxKnowledgeCreatesPerRun: 25,
-            maxKnowledgeUpdatesPerRun: 20,
-            warning: 'Anything accessible to this Notion integration can become organization knowledge.',
-        });
-    });
-    it('requires at least one selected root in selected_roots mode', () => {
-        expect(() => parseNotionConnectionConfig({
-            driver: 'notion',
-            auth_token_ref: 'env:NOTION_TOKEN',
-            crawl_mode: 'selected_roots',
-        })).toThrow('selected_roots requires at least one root page, database, or data source id');
-    });
-    it('resolves env and file token references without exposing the reference in errors', async () => {
-        const tokenPath = join(tempDir, 'notion-token.txt');
-        await writeFile(tokenPath, 'ntn_file_token\n', 'utf-8');
-        await expect(resolveNotionAuthToken('env:NOTION_TOKEN', {
-            env: { NOTION_TOKEN: 'ntn_env_token' },
-        })).resolves.toBe('ntn_env_token');
-        await expect(resolveNotionAuthToken(`file:${tokenPath}`)).resolves.toBe('ntn_file_token');
-        await expect(resolveNotionAuthToken('env:MISSING_NOTION_TOKEN', { env: {} })).rejects.toThrow('Notion token environment variable MISSING_NOTION_TOKEN is not set');
-    });
-    it('converts standalone config into adapter pull config', async () => {
-        const pullConfig = await notionConnectionToPullConfig(parseNotionConnectionConfig({
-            driver: 'notion',
-            auth_token_ref: 'env:NOTION_TOKEN',
-            crawl_mode: 'all_accessible',
-            max_pages_per_run: 12,
-            max_knowledge_creates_per_run: 2,
-            max_knowledge_updates_per_run: 7,
-            last_successful_cursor: '{"phase":"all_accessible_pages","cursor":"cursor-1"}',
-        }), { env: { NOTION_TOKEN: 'ntn_env_token' } });
-        expect(pullConfig).toEqual({
-            authToken: 'ntn_env_token',
-            crawlMode: 'all_accessible',
-            rootPageIds: [],
-            rootDatabaseIds: [],
-            rootDataSourceIds: [],
-            maxPagesPerRun: 12,
-            maxKnowledgeCreatesPerRun: 2,
-            maxKnowledgeUpdatesPerRun: 7,
-            lastSuccessfulCursor: null,
-        });
-    });
-    it('uses inline Notion auth_token when building adapter pull config', async () => {
-        const pullConfig = await notionConnectionToPullConfig(parseNotionConnectionConfig({
-            driver: 'notion',
-            auth_token: 'ntn_inline_token',
-            auth_token_ref: 'env:STALE_NOTION_TOKEN',
-            crawl_mode: 'all_accessible',
-        }), {
-            env: {},
-            readTextFile: async () => {
-                throw new Error('readTextFile should not be called for inline auth_token');
-            },
-        });
-        expect(pullConfig.authToken).toBe('ntn_inline_token');
-    });
-});

package/dist/context/connections/postgres-query-executor.test.d.ts

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

package/dist/context/connections/postgres-query-executor.test.js

@@ -1,91 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createPostgresQueryExecutor } from './postgres-query-executor.js';
-function makeClient() {
-    const calls = [];
-    const client = {
-        connect: vi.fn(async () => undefined),
-        query: vi.fn(async (input) => {
-            calls.push(input);
-            if (input === 'BEGIN READ ONLY') {
-                return { rows: [], fields: [], rowCount: null, command: 'BEGIN' };
-            }
-            if (input === 'COMMIT') {
-                return { rows: [], fields: [], rowCount: null, command: 'COMMIT' };
-            }
-            return {
-                rows: [
-                    ['paid', 2],
-                    ['open', 1],
-                ],
-                fields: [{ name: 'status' }, { name: 'order_count' }],
-                rowCount: 2,
-                command: 'SELECT',
-            };
-        }),
-        end: vi.fn(async () => undefined),
-    };
-    return { client, calls };
-}
-describe('createPostgresQueryExecutor', () => {
-    it('runs a read-only transaction in array row mode and closes the client', async () => {
-        const { client, calls } = makeClient();
-        const executor = createPostgresQueryExecutor({
-            clientFactory: vi.fn(() => client),
-        });
-        const result = await executor.execute({
-            connectionId: 'warehouse',
-            connection: { driver: 'postgres', url: 'postgres://example/db' },
-            sql: 'select status, count(*) as order_count from public.orders group by status',
-            maxRows: 50,
-        });
-        expect(client.connect).toHaveBeenCalledTimes(1);
-        expect(calls[0]).toBe('BEGIN READ ONLY');
-        expect(calls[1]).toEqual({
-            text: 'select * from (select status, count(*) as order_count from public.orders group by status) as ktx_query_result limit 50',
-            rowMode: 'array',
-        });
-        expect(calls[2]).toBe('COMMIT');
-        expect(client.end).toHaveBeenCalledTimes(1);
-        expect(result).toEqual({
-            headers: ['status', 'order_count'],
-            rows: [
-                ['paid', 2],
-                ['open', 1],
-            ],
-            totalRows: 2,
-            command: 'SELECT',
-            rowCount: 2,
-        });
-    });
-    it('rolls back and closes the client when query execution fails', async () => {
-        const client = {
-            connect: vi.fn(async () => undefined),
-            query: vi.fn(async (input) => {
-                if (input === 'BEGIN READ ONLY' || input === 'ROLLBACK') {
-                    return { rows: [], fields: [], rowCount: null, command: String(input) };
-                }
-                throw new Error('syntax error');
-            }),
-            end: vi.fn(async () => undefined),
-        };
-        const executor = createPostgresQueryExecutor({
-            clientFactory: vi.fn(() => client),
-        });
-        await expect(executor.execute({
-            connectionId: 'warehouse',
-            connection: { driver: 'postgres', url: 'postgres://example/db' },
-            sql: 'select * from broken',
-            maxRows: 10,
-        })).rejects.toThrow('syntax error');
-        expect(client.query).toHaveBeenCalledWith('ROLLBACK');
-        expect(client.end).toHaveBeenCalledTimes(1);
-    });
-    it('requires a Postgres url', async () => {
-        const executor = createPostgresQueryExecutor({ clientFactory: vi.fn() });
-        await expect(executor.execute({
-            connectionId: 'warehouse',
-            connection: { driver: 'postgres' },
-            sql: 'select 1',
-        })).rejects.toThrow('Local Postgres execution requires connections.warehouse.url');
-    });
-});

package/dist/context/connections/read-only-sql.test.d.ts

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

package/dist/context/connections/read-only-sql.test.js

@@ -1,20 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { assertReadOnlySql, limitSqlForExecution } from './read-only-sql.js';
-describe('assertReadOnlySql', () => {
-    it('allows select and with queries', () => {
-        expect(assertReadOnlySql('select * from orders')).toBe('select * from orders');
-        expect(assertReadOnlySql('with paid as (select * from orders) select * from paid')).toContain('with paid');
-    });
-    it('rejects mutating statements before opening a database connection', () => {
-        expect(() => assertReadOnlySql('delete from orders')).toThrow('Only read-only SELECT/WITH queries can be executed locally');
-        expect(() => assertReadOnlySql('create table x(id int)')).toThrow('Only read-only SELECT/WITH queries can be executed locally');
-    });
-});
-describe('limitSqlForExecution', () => {
-    it('wraps compiled SQL and strips trailing semicolons', () => {
-        expect(limitSqlForExecution('select * from public.orders; ', 25)).toBe('select * from (select * from public.orders) as ktx_query_result limit 25');
-    });
-    it('returns the trimmed SQL when no maxRows value is provided', () => {
-        expect(limitSqlForExecution('select * from orders; ', undefined)).toBe('select * from orders');
-    });
-});

package/dist/context/connections/sqlite-query-executor.test.d.ts

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

package/dist/context/connections/sqlite-query-executor.test.js

@@ -1,113 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import Database from 'better-sqlite3';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { createSqliteQueryExecutor, sqliteDatabasePathFromConnection } from './sqlite-query-executor.js';
-describe('createSqliteQueryExecutor', () => {
-    let tempDir;
-    let dbPath;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-sqlite-query-'));
-        dbPath = join(tempDir, 'warehouse.db');
-        const db = new Database(dbPath);
-        db.exec(`
-      CREATE TABLE orders (
-        id INTEGER PRIMARY KEY,
-        status TEXT NOT NULL,
-        amount INTEGER NOT NULL
-      );
-      INSERT INTO orders (status, amount) VALUES
-        ('paid', 20),
-        ('paid', 30),
-        ('open', 10);
-    `);
-        db.close();
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('executes read-only SELECT SQL against a relative SQLite path', async () => {
-        const executor = createSqliteQueryExecutor();
-        const result = await executor.execute({
-            connectionId: 'warehouse',
-            projectDir: tempDir,
-            connection: { driver: 'sqlite', path: 'warehouse.db' },
-            sql: 'select status, count(*) as order_count from orders group by status order by status',
-            maxRows: 10,
-        });
-        expect(result).toEqual({
-            headers: ['status', 'order_count'],
-            rows: [
-                ['open', 1],
-                ['paid', 2],
-            ],
-            totalRows: 2,
-            command: 'SELECT',
-            rowCount: 2,
-        });
-    });
-    it('supports file urls for SQLite database paths', async () => {
-        expect(sqliteDatabasePathFromConnection({
-            connectionId: 'warehouse',
-            projectDir: tempDir,
-            connection: { driver: 'sqlite', url: `file://${dbPath}` },
-            sql: 'select 1',
-        })).toBe(dbPath);
-    });
-    it('resolves file references for SQLite path fields', async () => {
-        const pointerPath = join(tempDir, 'sqlite-path.txt');
-        writeFileSync(pointerPath, dbPath, 'utf-8');
-        expect(sqliteDatabasePathFromConnection({
-            connectionId: 'warehouse',
-            projectDir: tempDir,
-            connection: { driver: 'sqlite', path: `file:${pointerPath}` },
-            sql: 'select 1',
-        })).toBe(dbPath);
-    });
-    it('resolves env references for SQLite database urls', async () => {
-        const originalDatabaseUrl = process.env.KTX_SQLITE_TEST_URL;
-        process.env.KTX_SQLITE_TEST_URL = `sqlite:${dbPath}`;
-        try {
-            expect(sqliteDatabasePathFromConnection({
-                connectionId: 'warehouse',
-                projectDir: tempDir,
-                connection: { driver: 'sqlite', url: 'env:KTX_SQLITE_TEST_URL' },
-                sql: 'select 1',
-            })).toBe(dbPath);
-        }
-        finally {
-            if (originalDatabaseUrl === undefined) {
-                delete process.env.KTX_SQLITE_TEST_URL;
-            }
-            else {
-                process.env.KTX_SQLITE_TEST_URL = originalDatabaseUrl;
-            }
-        }
-    });
-    it('rejects mutating SQL before opening the database', async () => {
-        const executor = createSqliteQueryExecutor();
-        await expect(executor.execute({
-            connectionId: 'warehouse',
-            projectDir: tempDir,
-            connection: { driver: 'sqlite', path: 'warehouse.db' },
-            sql: 'delete from orders',
-        })).rejects.toThrow('Only read-only SELECT/WITH queries can be executed locally');
-    });
-    it('requires a SQLite driver and a database path', async () => {
-        const executor = createSqliteQueryExecutor();
-        await expect(executor.execute({
-            connectionId: 'warehouse',
-            projectDir: tempDir,
-            connection: { driver: 'postgres', path: 'warehouse.db' },
-            sql: 'select 1',
-        })).rejects.toThrow('Local SQLite execution cannot run driver "postgres"');
-        await expect(executor.execute({
-            connectionId: 'warehouse',
-            projectDir: tempDir,
-            connection: { driver: 'sqlite' },
-            sql: 'select 1',
-        })).rejects.toThrow('Local SQLite execution requires connections.warehouse.path or connections.warehouse.url');
-    });
-});

package/dist/context/core/config-reference.test.d.ts

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

package/dist/context/core/config-reference.test.js

@@ -1,27 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { describe, expect, it } from 'vitest';
-import { resolveKtxConfigReference, resolveKtxHomePath } from './config-reference.js';
-describe('KTX config references', () => {
-    it('resolves env references without returning empty values', () => {
-        expect(resolveKtxConfigReference('env:AI_GATEWAY_API_KEY', { AI_GATEWAY_API_KEY: ' gateway-key ' })).toBe('gateway-key');
-        expect(resolveKtxConfigReference('env:AI_GATEWAY_API_KEY', { AI_GATEWAY_API_KEY: '   ' })).toBeUndefined();
-        expect(resolveKtxConfigReference('env:AI_GATEWAY_API_KEY', {})).toBeUndefined();
-    });
-    it('resolves file references and trims file content', async () => {
-        const dir = join(tmpdir(), `ktx-config-reference-${process.pid}`);
-        await mkdir(dir, { recursive: true });
-        const keyPath = join(dir, 'gateway-key.txt');
-        await writeFile(keyPath, 'file-gateway-key\n', 'utf8');
-        expect(resolveKtxConfigReference(`file:${keyPath}`, {})).toBe('file-gateway-key');
-    });
-    it('returns literal values unchanged after trimming blank-only values', () => {
-        expect(resolveKtxConfigReference('provider/model', {})).toBe('provider/model');
-        expect(resolveKtxConfigReference('  ', {})).toBeUndefined();
-        expect(resolveKtxConfigReference(undefined, {})).toBeUndefined();
-    });
-    it('resolves home-prefixed paths', () => {
-        expect(resolveKtxHomePath('~/ktx/key.txt')).toContain('/ktx/key.txt');
-    });
-});

package/dist/context/core/git.service.assert-worktree-clean.test.d.ts

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

package/dist/context/core/git.service.assert-worktree-clean.test.js

@@ -1,62 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createSimpleGit } from './git-env.js';
-import { GitService } from './git.service.js';
-describe('GitService.assertWorktreeClean', () => {
-    let workdir;
-    let git;
-    let gitService;
-    beforeEach(async () => {
-        workdir = await mkdtemp(join(tmpdir(), 'gitsvc-clean-'));
-        git = createSimpleGit(workdir);
-        await git.init();
-        await git.addConfig('user.email', 't@test');
-        await git.addConfig('user.name', 'Test');
-        await writeFile(join(workdir, 'init'), 'init');
-        await git.add('.');
-        await git.commit('init');
-        const coreConfig = {
-            storage: { configDir: workdir, homeDir: workdir },
-            git: { userName: 'Test', userEmail: 't@test' },
-        };
-        gitService = new GitService(coreConfig);
-        gitService.git = git;
-        gitService.configDir = workdir;
-    });
-    afterEach(async () => rm(workdir, { recursive: true, force: true }));
-    it('does not throw on a clean worktree', async () => {
-        await expect(gitService.assertWorktreeClean()).resolves.toBeUndefined();
-    });
-    it('throws when MERGE_HEAD exists', async () => {
-        await writeFile(join(workdir, '.git', 'MERGE_HEAD'), 'deadbeef\n');
-        await expect(gitService.assertWorktreeClean()).rejects.toThrow(/MERGE_HEAD/);
-    });
-    it('throws when CHERRY_PICK_HEAD exists', async () => {
-        await writeFile(join(workdir, '.git', 'CHERRY_PICK_HEAD'), 'deadbeef\n');
-        await expect(gitService.assertWorktreeClean()).rejects.toThrow(/CHERRY_PICK_HEAD/);
-    });
-    it('throws when REVERT_HEAD exists', async () => {
-        await writeFile(join(workdir, '.git', 'REVERT_HEAD'), 'deadbeef\n');
-        await expect(gitService.assertWorktreeClean()).rejects.toThrow(/REVERT_HEAD/);
-    });
-    it('throws when sequencer/todo exists (interrupted multi-commit revert/cherry-pick)', async () => {
-        await mkdir(join(workdir, '.git', 'sequencer'), { recursive: true });
-        await writeFile(join(workdir, '.git', 'sequencer', 'todo'), 'pick deadbeef foo\n');
-        await expect(gitService.assertWorktreeClean()).rejects.toThrow(/sequencer/);
-    });
-    it('throws when the index has unmerged paths', async () => {
-        await git.checkoutLocalBranch('a');
-        await writeFile(join(workdir, 'shared'), 'A version');
-        await git.add('.');
-        await git.commit('a');
-        await git.checkout('master').catch(() => git.checkout('main'));
-        await git.checkoutLocalBranch('b');
-        await writeFile(join(workdir, 'shared'), 'B version');
-        await git.add('.');
-        await git.commit('b');
-        await git.raw(['merge', 'a']).catch(() => undefined);
-        await expect(gitService.assertWorktreeClean()).rejects.toThrow();
-    });
-});

package/dist/context/core/git.service.delete-directories.test.d.ts

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

package/dist/context/core/git.service.delete-directories.test.js

@@ -1,61 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { mkdir, mkdtemp, readdir, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { createSimpleGit } from './git-env.js';
-import { GitService } from './git.service.js';
-describe('GitService.deleteDirectories', () => {
-    let workdir;
-    let git;
-    let gitService;
-    beforeEach(async () => {
-        workdir = await mkdtemp(join(tmpdir(), 'gitsvc-dd-'));
-        git = createSimpleGit(workdir);
-        await git.init();
-        await git.addConfig('user.email', 't@test');
-        await git.addConfig('user.name', 'Test');
-        await writeFile(join(workdir, 'keep'), 'k');
-        await git.add('.');
-        await git.commit('init');
-        const coreConfig = {
-            storage: { configDir: workdir, homeDir: workdir },
-            git: { userName: 'Test', userEmail: 't@test' },
-        };
-        gitService = new GitService(coreConfig);
-        gitService.git = git;
-        gitService.configDir = workdir;
-    });
-    afterEach(async () => rm(workdir, { recursive: true, force: true }));
-    it('removes multiple directories in a single commit', async () => {
-        for (const name of ['a', 'b', 'c']) {
-            await mkdir(join(workdir, name), { recursive: true });
-            await writeFile(join(workdir, name, 'f.txt'), name);
-        }
-        await git.add('.');
-        await git.commit('seed 3 dirs');
-        const beforeCommits = (await git.log()).total;
-        const result = await gitService.deleteDirectories(['a', 'b'], 'gc: drop a+b', 'System User', 'system@example.com');
-        expect(result.commitHash).toBeTruthy();
-        const entries = await readdir(workdir);
-        expect(entries).not.toContain('a');
-        expect(entries).not.toContain('b');
-        expect(entries).toContain('c');
-        const afterCommits = (await git.log()).total;
-        expect(afterCommits).toBe(beforeCommits + 1);
-    });
-    it('no-ops and returns a null hash when the input list is empty', async () => {
-        const result = await gitService.deleteDirectories([], 'empty', 'X', 'x@example.com');
-        expect(result.commitHash).toBe('');
-        expect(result.created).toBe(false);
-    });
-    it('ignores paths that have already been deleted — commits only the remaining ones', async () => {
-        await mkdir(join(workdir, 'stale'), { recursive: true });
-        await writeFile(join(workdir, 'stale', 'x'), 'x');
-        await git.add('.');
-        await git.commit('seed stale');
-        const result = await gitService.deleteDirectories(['stale', 'missing'], 'gc: drop stale + missing', 'System User', 'system@example.com');
-        expect(result.commitHash).toBeTruthy();
-        const entries = await readdir(workdir);
-        expect(entries).not.toContain('stale');
-    });
-});

package/dist/context/core/git.service.patch.test.d.ts

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