@cspeach/cli 0.6.4 → 0.6.5

package/dist/agent/__tests__/turn-watchdog.test.js

@@ -1,126 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { loadWatchdogConfig, evaluateWatchdog, DEFAULT_WALL_BUDGET_MS, DEFAULT_TOKEN_BUDGET, } from '../turn-watchdog.js';
-describe('loadWatchdogConfig', () => {
-    it('uses defaults when no env vars set', () => {
-        const cfg = loadWatchdogConfig({});
-        expect(cfg.enabled).toBe(true);
-        expect(cfg.wallBudgetMs).toBe(DEFAULT_WALL_BUDGET_MS);
-        expect(cfg.tokenBudget).toBe(DEFAULT_TOKEN_BUDGET);
-    });
-    it('honours CSPEACH_TURN_WATCHDOG=off', () => {
-        expect(loadWatchdogConfig({ CSPEACH_TURN_WATCHDOG: 'off' }).enabled).toBe(false);
-        expect(loadWatchdogConfig({ CSPEACH_TURN_WATCHDOG: 'OFF' }).enabled).toBe(false);
-    });
-    it('parses CSPEACH_TURN_WALL_BUDGET_MS override', () => {
-        const cfg = loadWatchdogConfig({ CSPEACH_TURN_WALL_BUDGET_MS: '60000' });
-        expect(cfg.wallBudgetMs).toBe(60_000);
-    });
-    it('parses CSPEACH_TURN_TOKEN_BUDGET override', () => {
-        const cfg = loadWatchdogConfig({ CSPEACH_TURN_TOKEN_BUDGET: '5000' });
-        expect(cfg.tokenBudget).toBe(5_000);
-    });
-    it('falls back to default on malformed env (rejects 0, negative, NaN)', () => {
-        expect(loadWatchdogConfig({ CSPEACH_TURN_WALL_BUDGET_MS: '0' }).wallBudgetMs).toBe(DEFAULT_WALL_BUDGET_MS);
-        expect(loadWatchdogConfig({ CSPEACH_TURN_WALL_BUDGET_MS: '-1' }).wallBudgetMs).toBe(DEFAULT_WALL_BUDGET_MS);
-        expect(loadWatchdogConfig({ CSPEACH_TURN_TOKEN_BUDGET: 'whatever' }).tokenBudget).toBe(DEFAULT_TOKEN_BUDGET);
-    });
-});
-describe('evaluateWatchdog', () => {
-    const cfg = { enabled: true, wallBudgetMs: 20 * 60_000, tokenBudget: 100_000 };
-    const tStart = 1_000_000;
-    it('returns no-warn when both budgets unscathed', () => {
-        const d = evaluateWatchdog({
-            startedAt: tStart,
-            outputTokensThisTurn: 5_000,
-            config: cfg,
-            alreadyWarned: false,
-        }, tStart + 60_000); // 1 minute in
-        expect(d.shouldWarn).toBe(false);
-        expect(d.message).toBe('');
-    });
-    it('warns when wall-clock budget exceeded', () => {
-        const d = evaluateWatchdog({
-            startedAt: tStart,
-            outputTokensThisTurn: 1_000,
-            config: cfg,
-            alreadyWarned: false,
-        }, tStart + 21 * 60_000);
-        expect(d.shouldWarn).toBe(true);
-        expect(d.reason).toContain('21m elapsed');
-        expect(d.reason).toContain('limit 20m');
-        expect(d.message).toContain('CSPeach watchdog');
-        expect(d.message).toContain('checkpoint');
-        expect(d.message).toContain('summaris'); // 'summarise' or 'summarising'
-    });
-    it('warns when token budget exceeded', () => {
-        const d = evaluateWatchdog({
-            startedAt: tStart,
-            outputTokensThisTurn: 150_000,
-            config: cfg,
-            alreadyWarned: false,
-        }, tStart + 60_000);
-        expect(d.shouldWarn).toBe(true);
-        expect(d.reason).toContain('150K output tokens');
-        expect(d.reason).toContain('limit 100K');
-    });
-    it('reports both reasons when both budgets exceeded', () => {
-        const d = evaluateWatchdog({
-            startedAt: tStart,
-            outputTokensThisTurn: 200_000,
-            config: cfg,
-            alreadyWarned: false,
-        }, tStart + 30 * 60_000);
-        expect(d.shouldWarn).toBe(true);
-        expect(d.reason).toContain('30m elapsed');
-        expect(d.reason).toContain('200K output tokens');
-    });
-    it('does NOT warn twice in the same turn (alreadyWarned)', () => {
-        const d = evaluateWatchdog({
-            startedAt: tStart,
-            outputTokensThisTurn: 200_000,
-            config: cfg,
-            alreadyWarned: true,
-        }, tStart + 30 * 60_000);
-        expect(d.shouldWarn).toBe(false);
-    });
-    it('does NOT warn when watchdog disabled', () => {
-        const d = evaluateWatchdog({
-            startedAt: tStart,
-            outputTokensThisTurn: 999_999,
-            config: { ...cfg, enabled: false },
-            alreadyWarned: false,
-        }, tStart + 999 * 60_000);
-        expect(d.shouldWarn).toBe(false);
-    });
-    it('boundary: warns exactly at the threshold (>=)', () => {
-        const d = evaluateWatchdog({
-            startedAt: tStart,
-            outputTokensThisTurn: 100_000, // exactly at limit
-            config: cfg,
-            alreadyWarned: false,
-        }, tStart + 60_000);
-        expect(d.shouldWarn).toBe(true);
-    });
-    it('handles future startedAt (clamps to 0 elapsed) without crashing', () => {
-        const d = evaluateWatchdog({
-            startedAt: tStart + 1000,
-            outputTokensThisTurn: 5,
-            config: cfg,
-            alreadyWarned: false,
-        }, tStart);
-        expect(d.shouldWarn).toBe(false);
-    });
-    it('REGRESSION: 77-min ZDPR_PAYMENTS turn would have warned at 20min mark', () => {
-        // The lost session ran 77 minutes. With the watchdog active, the model
-        // would have been advised to wrap up at the 20-minute mark — well before
-        // the Anthropic stream timeout that ate the result.
-        const d = evaluateWatchdog({
-            startedAt: tStart,
-            outputTokensThisTurn: 50_000, // not yet token-busted
-            config: cfg,
-            alreadyWarned: false,
-        }, tStart + 20 * 60_000); // exactly at 20m
-        expect(d.shouldWarn).toBe(true);
-        expect(d.reason).toMatch(/elapsed/);
-    });
-});

package/dist/agent/providers/__tests__/ai-hub-provider.test.js

@@ -1,30 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-vi.mock('keytar', () => ({
-    default: { getPassword: vi.fn(), setPassword: vi.fn() },
-}));
-describe('ai-hub provider', () => {
-    it('requires ai_hub_base_url in config', async () => {
-        const { createAiHubProvider } = await import('../ai-hub-provider.js');
-        const cfg = { llm: { mode: 'ai-hub' }, proxy_url: '' };
-        expect(() => createAiHubProvider(cfg)).toThrow(/ai_hub_base_url/);
-    });
-    it('creates provider with configured URL + model alias', async () => {
-        const { createAiHubProvider } = await import('../ai-hub-provider.js');
-        const cfg = {
-            llm: { mode: 'ai-hub', ai_hub_base_url: 'https://proxy.example.com/v1', ai_hub_model_alias: 'anthropic--claude-opus-4-6' },
-            proxy_url: '',
-        };
-        const p = createAiHubProvider(cfg);
-        expect(p.name).toBe('sap-ai-hub');
-        expect(p.mode).toBe('ai-hub');
-    });
-    it('skillSource uses manifest', async () => {
-        const { createAiHubProvider } = await import('../ai-hub-provider.js');
-        const cfg = {
-            llm: { mode: 'ai-hub', ai_hub_base_url: 'https://p', ai_hub_model_alias: 'x' },
-            proxy_url: '',
-        };
-        const p = createAiHubProvider(cfg);
-        expect(p.skillSource.describe()).toMatch(/manifest/i);
-    });
-});

package/dist/agent/providers/__tests__/byok-provider.test.js

@@ -1,32 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-vi.mock('keytar', () => ({
-    default: {
-        getPassword: vi.fn().mockResolvedValue('sk-ant-test-key-123'),
-        setPassword: vi.fn(),
-    },
-}));
-describe('byok provider', () => {
-    it('name + mode set correctly', async () => {
-        const { createByokProvider } = await import('../byok-provider.js');
-        const cfg = { llm: { mode: 'byok' }, proxy_url: '' };
-        const p = createByokProvider(cfg);
-        expect(p.name).toBe('anthropic-byok');
-        expect(p.mode).toBe('byok');
-    });
-    it('healthCheck fails when no key in keychain', async () => {
-        const keytar = (await import('keytar')).default;
-        keytar.getPassword.mockResolvedValueOnce(null);
-        const { createByokProvider } = await import('../byok-provider.js');
-        const cfg = { llm: { mode: 'byok' }, proxy_url: '' };
-        const p = createByokProvider(cfg);
-        const h = await p.healthCheck();
-        expect(h.ok).toBe(false);
-        expect(h.message).toMatch(/keychain|key/i);
-    });
-    it('skillSource uses manifest', async () => {
-        const { createByokProvider } = await import('../byok-provider.js');
-        const cfg = { llm: { mode: 'byok' }, proxy_url: '' };
-        const p = createByokProvider(cfg);
-        expect(p.skillSource.describe()).toMatch(/manifest/i);
-    });
-});

package/dist/agent/providers/__tests__/factory.test.js

@@ -1,33 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-vi.mock('keytar', () => ({ default: { getPassword: vi.fn().mockResolvedValue('k'), setPassword: vi.fn() } }));
-describe('provider factory', () => {
-    it('returns managed provider for mode=managed', async () => {
-        const { createProviderForMode } = await import('../factory.js');
-        const cfg = { llm: { mode: 'managed' }, proxy_url: 'https://x' };
-        const p = createProviderForMode(cfg, async () => 'bearer');
-        expect(p.mode).toBe('managed');
-    });
-    it('returns byok provider for mode=byok', async () => {
-        const { createProviderForMode } = await import('../factory.js');
-        const cfg = { llm: { mode: 'byok' }, proxy_url: '' };
-        const p = createProviderForMode(cfg, async () => '');
-        expect(p.mode).toBe('byok');
-    });
-    it('returns ai-hub provider for mode=ai-hub', async () => {
-        const { createProviderForMode } = await import('../factory.js');
-        const cfg = { llm: { mode: 'ai-hub', ai_hub_base_url: 'https://p', ai_hub_model_alias: 'x' }, proxy_url: '' };
-        const p = createProviderForMode(cfg, async () => '');
-        expect(p.mode).toBe('ai-hub');
-    });
-    it('returns local provider for mode=local', async () => {
-        const { createProviderForMode } = await import('../factory.js');
-        const cfg = { llm: { mode: 'local', local_base_url: 'http://l', local_model: 'm' }, proxy_url: '' };
-        const p = createProviderForMode(cfg, async () => '');
-        expect(p.mode).toBe('local');
-    });
-    it('throws on invalid mode', async () => {
-        const { createProviderForMode } = await import('../factory.js');
-        const cfg = { llm: { mode: 'bogus' }, proxy_url: '' };
-        expect(() => createProviderForMode(cfg, async () => '')).toThrow(/mode/);
-    });
-});

package/dist/agent/providers/__tests__/local-provider.test.js

@@ -1,55 +0,0 @@
-import { describe, it, expect } from 'vitest';
-describe('local provider', () => {
-    it('requires local_base_url in config', async () => {
-        const { createLocalProvider } = await import('../local-provider.js');
-        const cfg = { llm: { mode: 'local' }, proxy_url: '' };
-        expect(() => createLocalProvider(cfg)).toThrow(/local_base_url/);
-    });
-    it('creates provider with configured URL + model', async () => {
-        const { createLocalProvider } = await import('../local-provider.js');
-        const cfg = {
-            llm: { mode: 'local', local_base_url: 'http://localhost:11434/v1', local_model: 'llama3.1:70b' },
-            proxy_url: '',
-        };
-        const p = createLocalProvider(cfg);
-        expect(p.name).toBe('local-openai-compat');
-        expect(p.mode).toBe('local');
-    });
-    it('skillSource uses bundled skills', async () => {
-        const { createLocalProvider } = await import('../local-provider.js');
-        const cfg = {
-            llm: { mode: 'local', local_base_url: 'http://l', local_model: 'm' },
-            proxy_url: '',
-        };
-        const p = createLocalProvider(cfg);
-        expect(p.skillSource.describe()).toMatch(/bundled/i);
-    });
-    it('createStream rejects params that include tools (Plan A scope: text-only)', async () => {
-        const { createLocalProvider } = await import('../local-provider.js');
-        const cfg = { llm: { mode: 'local', local_base_url: 'http://l', local_model: 'm' }, proxy_url: '' };
-        const p = createLocalProvider(cfg);
-        await expect(p.createStream({ model: 'm', max_tokens: 100, messages: [], tools: [{ name: 't', description: 'd', input_schema: {} }] }))
-            .rejects.toThrow(/tool calling.*not supported.*local mode/i);
-    });
-    it('adaptOpenAiStreamToAnthropic emits the canonical event sequence', async () => {
-        const { adaptOpenAiStreamToAnthropic } = await import('../local-provider.js');
-        async function* fakeOpenAIStream() {
-            yield { choices: [{ delta: { content: 'hello ' } }] };
-            yield { choices: [{ delta: { content: 'world' }, finish_reason: null }] };
-            yield { choices: [{ delta: {}, finish_reason: 'stop' }], usage: { prompt_tokens: 5, completion_tokens: 3 } };
-        }
-        const events = [];
-        for await (const ev of adaptOpenAiStreamToAnthropic(fakeOpenAIStream(), 'test-model'))
-            events.push(ev);
-        expect(events[0].type).toBe('message_start');
-        expect(events[0].message.model).toBe('test-model');
-        expect(events[1].type).toBe('content_block_start');
-        expect(events[1].index).toBe(0);
-        const deltas = events.filter(e => e.type === 'content_block_delta');
-        expect(deltas.map(d => d.delta.text).join('')).toBe('hello world');
-        expect(events[events.length - 3].type).toBe('content_block_stop');
-        expect(events[events.length - 2].type).toBe('message_delta');
-        expect(events[events.length - 2].usage.output_tokens).toBe(3);
-        expect(events[events.length - 1].type).toBe('message_stop');
-    });
-});

package/dist/approvals/__tests__/advisory-prompt.test.js

@@ -1,57 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-// Mock clipboardy
-vi.mock('clipboardy', () => ({
-    default: {
-        write: vi.fn().mockResolvedValue(undefined),
-    },
-}));
-// Mock readline/promises — feed keystrokes directly
-const mockRead = vi.fn();
-vi.mock('node:readline/promises', () => ({
-    default: {
-        createInterface: () => ({
-            question: mockRead,
-            close: vi.fn(),
-        }),
-    },
-    createInterface: () => ({
-        question: mockRead,
-        close: vi.fn(),
-    }),
-}));
-describe('promptAdvisory', () => {
-    beforeEach(() => {
-        mockRead.mockReset();
-    });
-    it('returns "applied" when user enters y', async () => {
-        mockRead.mockResolvedValueOnce('y');
-        const { promptAdvisory } = await import('../advisory-prompt.js');
-        const result = await promptAdvisory({ displayText: 'x', clipboardText: 'x' });
-        expect(result).toBe('applied');
-    });
-    it('returns "skipped" when user enters s', async () => {
-        mockRead.mockResolvedValueOnce('s');
-        const { promptAdvisory } = await import('../advisory-prompt.js');
-        expect(await promptAdvisory({ displayText: 'x', clipboardText: 'x' })).toBe('skipped');
-    });
-    it('returns "aborted" when user enters n', async () => {
-        mockRead.mockResolvedValueOnce('n');
-        const { promptAdvisory } = await import('../advisory-prompt.js');
-        expect(await promptAdvisory({ displayText: 'x', clipboardText: 'x' })).toBe('aborted');
-    });
-    it('copies to clipboard on c then re-prompts', async () => {
-        mockRead.mockResolvedValueOnce('c').mockResolvedValueOnce('y');
-        const clipboardy = (await import('clipboardy')).default;
-        const { promptAdvisory } = await import('../advisory-prompt.js');
-        const result = await promptAdvisory({ displayText: 'display', clipboardText: 'clip' });
-        expect(clipboardy.write).toHaveBeenCalledWith('clip');
-        expect(result).toBe('applied');
-    });
-    it('re-prompts on unrecognised input', async () => {
-        mockRead.mockResolvedValueOnce('q').mockResolvedValueOnce('y');
-        const { promptAdvisory } = await import('../advisory-prompt.js');
-        const result = await promptAdvisory({ displayText: 'x', clipboardText: 'x' });
-        expect(result).toBe('applied');
-        expect(mockRead).toHaveBeenCalledTimes(2);
-    });
-});

package/dist/approvals/__tests__/advisory-render.test.js

@@ -1,54 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { renderAdvisoryProposal } from '../advisory-render.js';
-describe('renderAdvisoryProposal', () => {
-    const args = {
-        summary: 'Create ZCL_FOO with one method',
-        risk: 'low',
-        transport: 'DEVK900123',
-        changes: [
-            {
-                op: 'create',
-                object: 'ZCL_FOO',
-                type: 'CLAS',
-                diff: 'CLASS zcl_foo DEFINITION.\n  PUBLIC SECTION.\n    METHODS hello.\nENDCLASS.',
-            },
-        ],
-    };
-    it('renders a header with the summary', () => {
-        const out = renderAdvisoryProposal(args);
-        expect(out.displayText).toContain('Create ZCL_FOO with one method');
-    });
-    it('renders each change with object + type + diff', () => {
-        const out = renderAdvisoryProposal(args);
-        expect(out.displayText).toContain('ZCL_FOO');
-        expect(out.displayText).toContain('CLAS');
-        expect(out.displayText).toContain('zcl_foo DEFINITION');
-    });
-    it('mentions the target transport', () => {
-        const out = renderAdvisoryProposal(args);
-        expect(out.displayText).toContain('DEVK900123');
-    });
-    it('provides a clipboard-friendly payload separate from display text', () => {
-        const out = renderAdvisoryProposal(args);
-        expect(out.clipboardText).toContain('zcl_foo DEFINITION');
-        // no ANSI escape codes — the ESC character (\x1b) should not appear
-        expect(out.clipboardText).not.toContain('\x1b[');
-    });
-    it('handles multiple changes', () => {
-        const multi = {
-            ...args,
-            changes: [
-                args.changes[0],
-                { op: 'activate', object: 'ZCL_FOO', type: 'CLAS' },
-            ],
-        };
-        const out = renderAdvisoryProposal(multi);
-        expect(out.displayText).toContain('Change 1');
-        expect(out.displayText).toContain('Change 2');
-    });
-    it('warns that no SAP write will occur', () => {
-        const out = renderAdvisoryProposal(args);
-        expect(out.displayText.toLowerCase()).toContain('advisory');
-        expect(out.displayText.toLowerCase()).toMatch(/no\s+(sap\s+)?write/);
-    });
-});

package/dist/auth/__tests__/auth-file.test.js

@@ -1,42 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { promises as fs } from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { readAuthFile, writeAuthFile, __setAuthFilePathForTests } from '../auth-file.js';
-let dir;
-let authPath;
-beforeEach(async () => {
-    dir = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-auth-'));
-    authPath = path.join(dir, 'auth.json');
-    __setAuthFilePathForTests(authPath);
-});
-afterEach(async () => {
-    __setAuthFilePathForTests(null);
-    await fs.rm(dir, { recursive: true, force: true });
-});
-describe('auth-file', () => {
-    it('readAuthFile returns null when file missing', async () => {
-        expect(await readAuthFile()).toBeNull();
-    });
-    it('writeAuthFile then readAuthFile round-trips', async () => {
-        await writeAuthFile({ apiKey: 'csp_live_abc', customerId: 'cust-1', byokAnthropicKey: null });
-        const r = await readAuthFile();
-        expect(r).toEqual({ apiKey: 'csp_live_abc', customerId: 'cust-1', byokAnthropicKey: null });
-    });
-    it('writeAuthFile sets 0600 permissions on POSIX', async () => {
-        if (process.platform === 'win32')
-            return; // chmod is a no-op on Windows ACLs
-        await writeAuthFile({ apiKey: 'csp_live_x', customerId: 'c', byokAnthropicKey: null });
-        const stat = await fs.stat(authPath);
-        expect(stat.mode & 0o777).toBe(0o600);
-    });
-    it('readAuthFile returns null on malformed JSON', async () => {
-        await fs.writeFile(authPath, 'not json', 'utf-8');
-        expect(await readAuthFile()).toBeNull();
-    });
-    it('writeAuthFile with byokAnthropicKey persists it', async () => {
-        await writeAuthFile({ apiKey: 'csp_live_x', customerId: 'c', byokAnthropicKey: 'sk-ant-byok-key' });
-        const r = await readAuthFile();
-        expect(r?.byokAnthropicKey).toBe('sk-ant-byok-key');
-    });
-});

package/dist/auth/__tests__/me.test.js

@@ -1,43 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { fetchMe } from '../me.js';
-const { fetchMock } = vi.hoisted(() => ({ fetchMock: vi.fn() }));
-vi.stubGlobal('fetch', fetchMock);
-beforeEach(() => { fetchMock.mockReset(); });
-describe('fetchMe', () => {
-    it('returns parsed profile on 200', async () => {
-        fetchMock.mockResolvedValueOnce(new Response(JSON.stringify({
-            email: 'c@a.com', plan: 'trial-managed', trial_mode: 'managed-capped',
-            trial_ends_at: '2099-01-01T00:00:00Z',
-            trial_token_cap_input: 200_000, trial_token_cap_output: 50_000,
-            usage_input_tokens: 47_000, usage_output_tokens: 8_000,
-            entitlements: { enabled_skills: ['abap-cca'], agent_mode: 'skill', enabled_features: [] },
-        }), { status: 200 }));
-        const r = await fetchMe({ proxyUrl: 'https://api.cspeach.dev', apiKey: 'csp_live_x' });
-        expect(r.ok).toBe(true);
-        if (r.ok) {
-            expect(r.profile.email).toBe('c@a.com');
-            expect(r.profile.usage_input_tokens).toBe(47_000);
-        }
-    });
-    it('returns 401 result without throwing', async () => {
-        fetchMock.mockResolvedValueOnce(new Response('{"error":"invalid_api_key"}', { status: 401 }));
-        const r = await fetchMe({ proxyUrl: 'https://api.cspeach.dev', apiKey: 'csp_live_bad' });
-        expect(r.ok).toBe(false);
-        if (!r.ok)
-            expect(r.status).toBe(401);
-    });
-    it('returns network result on fetch throw', async () => {
-        fetchMock.mockRejectedValueOnce(new Error('ECONNREFUSED'));
-        const r = await fetchMe({ proxyUrl: 'https://api.cspeach.dev', apiKey: 'csp_live_x' });
-        expect(r.ok).toBe(false);
-        if (!r.ok)
-            expect(r.status).toBe(0);
-    });
-    it('sends Authorization Bearer header', async () => {
-        fetchMock.mockResolvedValueOnce(new Response('{}', { status: 200 }));
-        await fetchMe({ proxyUrl: 'https://api.cspeach.dev', apiKey: 'csp_live_my_key' });
-        const call = fetchMock.mock.calls[0];
-        const opts = call[1];
-        expect(opts.headers.Authorization).toBe('Bearer csp_live_my_key');
-    });
-});

package/dist/classifier/__tests__/client.test.js

@@ -1,70 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { classify } from '../client.js';
-describe('client-side classifier', () => {
-    it('routes "generate a new class" to abap-generate', () => {
-        expect(classify('generate a new class ZCL_FOO')).toBe('abap-generate');
-    });
-    it('routes "review this code" to abap-review', () => {
-        expect(classify('review this abap code')).toBe('abap-review');
-    });
-    it('routes "explain this" to abap-explain', () => {
-        expect(classify('explain this abap code')).toBe('abap-explain');
-    });
-    it('returns undefined when no rule matches', () => {
-        expect(classify('sneeze a wombat')).toBeUndefined();
-    });
-    it('disambiguates test vs generate ("generate tests" routes to merged abap-test)', () => {
-        expect(classify('generate tests for ZCL_FOO')).toBe('abap-test');
-        expect(classify('generate a new class ZCL_FOO')).toBe('abap-generate');
-    });
-    it('disambiguates transport-analysis vs transport', () => {
-        expect(classify('transport analysis before release')).toBe('abap-transport-analysis');
-        expect(classify('transport create for ZCL_FOO')).toBe('abap-transport');
-    });
-    it('disambiguates upgrade-verify vs upgrade-fix vs upgrade-scan', () => {
-        expect(classify('verify upgrade remediation')).toBe('abap-upgrade-verify');
-        expect(classify('fix upgrade finding')).toBe('abap-upgrade-fix');
-        expect(classify('upgrade scan with readiness variant')).toBe('abap-upgrade-scan');
-    });
-    it('routes "extend ME21N" / "hook into MIGO" to abap-enhance (cluster F)', () => {
-        expect(classify('extend ME21N to validate vendors')).toBe('abap-enhance');
-        expect(classify('hook into MIGO to log goods receipts')).toBe('abap-enhance');
-        expect(classify('user exit for billing pricing')).toBe('abap-enhance');
-        expect(classify('extend SAP standard order processing')).toBe('abap-enhance');
-    });
-    it('routes "convert to Fiori" / "rebuild as RAP" to abap-modernize (cluster F)', () => {
-        expect(classify('convert this WRITE report to Fiori')).toBe('abap-modernize');
-        expect(classify('rebuild as RAP service')).toBe('abap-modernize');
-        expect(classify('convert FM to OData')).toBe('abap-modernize');
-    });
-    it('routes pipeline-framed dump prompts to abap-incident, not dump-analyze (cluster G)', () => {
-        expect(classify('ST22 to transport pipeline for the morning dump')).toBe('abap-incident');
-        expect(classify('dump to transport workflow')).toBe('abap-incident');
-        expect(classify('end to end dump fix and report')).toBe('abap-incident');
-        expect(classify('formal incident report after the dump')).toBe('abap-incident');
-    });
-    it('keeps single-pass dump prompts on abap-dump-analyze (cluster G regression check)', () => {
-        expect(classify('analyze this short dump')).toBe('abap-dump-analyze');
-        expect(classify('runtime error in ZSD_ORDER')).toBe('abap-dump-analyze');
-    });
-    it('routes pre-coding chain prompts to spec-gap / estimate (cluster H)', () => {
-        expect(classify('clarifying questions on this requirement')).toBe('abap-spec-gap');
-        expect(classify('gaps in the story we got')).toBe('abap-spec-gap');
-        expect(classify('size this ticket for me')).toBe('abap-estimate');
-        expect(classify('how many days to build this feature')).toBe('abap-estimate');
-    });
-    it('disambiguates rap / generate / data-model / segw (cluster I)', () => {
-        // rap precedes generate now — RAP-stack prompts win even when "generate" or "scaffold" is present
-        expect(classify('Generate a RAP service for sales orders')).toBe('abap-rap');
-        expect(classify('scaffold a CDS view + BDEF + service binding')).toBe('abap-rap');
-        // data-model catches "create a Z table" — used to fall through to generate
-        expect(classify('Create a Z_CUSTOMER table for the customer master')).toBe('abap-data-model');
-        expect(classify('I need a new domain Z_AMOUNT_TYPE with fixed values')).toBe('abap-data-model');
-        // generate keeps single-object prompts (no rap/data-model keywords)
-        expect(classify('generate a Z program to print open POs')).toBe('abap-generate');
-        expect(classify('create a new class ZCL_CUSTOMER')).toBe('abap-generate');
-        // segw catches DPC_EXT and ECC OData
-        expect(classify('Implement DPC_EXT for the GET_ENTITYSET method')).toBe('abap-segw');
-        expect(classify('build an OData service on ECC Gateway')).toBe('abap-segw');
-    });
-});

package/dist/commands/__tests__/config-set-write-mode.test.js

@@ -1,14 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { validateValue } from '../config-set.js';
-describe('config set write_mode', () => {
-    it('accepts auto, approval-gated, advisory-only', () => {
-        expect(validateValue('write_mode', 'auto')).toBe(true);
-        expect(validateValue('write_mode', 'approval-gated')).toBe(true);
-        expect(validateValue('write_mode', 'advisory-only')).toBe(true);
-    });
-    it('rejects unknown values', () => {
-        expect(validateValue('write_mode', 'yolo')).toBe(false);
-        expect(validateValue('write_mode', '')).toBe(false);
-        expect(validateValue('write_mode', 'approval_gated')).toBe(false); // underscore, not dash
-    });
-});