@cspeach/cli 0.6.4 → 0.6.5

package/dist/tools/__tests__/sap-write-extras.test.js

@@ -1,573 +0,0 @@
-/**
- * Tests for the 8 new tools added in Phase 3-Lite A.5 + A.6:
- *
- * A.5 (sap-write.ts): sap_lock, sap_unlock, sap_service_binding_publish,
- *                     sap_message_maintain (STUB), sap_number_range_intervals (STUB)
- * A.6 (snapshot.ts):  sap_snapshot_list, sap_snapshot_read, sap_snapshot_cleanup
- *
- * B.1 (sap-write.ts): sap_update_method — diff-preview gate (4 tests)
- *
- * B.2 (sap-write.ts): sap_set_source safety confirmation — 2 tests
- *                     sap_delete_object safety confirmation — 2 tests
- *
- * Pattern: partial mock as `{ method: vi.fn() } as unknown as AdtClient`.
- * STUB tools: assert is_error + not_implemented envelope; assert no AdtClient
- *             method was called.
- * Each tool gets 2 tests = 16 tests total (A.5 + A.6) + 4 new (B.1) = 20 + 4 (B.2) = 24.
- */
-import '../sap-write.js'; // triggers registration side-effect
-import '../snapshot.js'; // triggers registration side-effect
-import { getTool } from '../index.js';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { CancelledByUserError } from '../update-method-intercept.js';
-// ---------------------------------------------------------------------------
-// Mock @cspeach/sap-client snapshots namespace
-// ---------------------------------------------------------------------------
-const mockSnapshotsList = vi.hoisted(() => vi.fn());
-const mockSnapshotsRead = vi.hoisted(() => vi.fn());
-const mockSnapshotsCleanup = vi.hoisted(() => vi.fn());
-// preserve `take` stub so autoSnapshot in sap-write.ts doesn't fail
-const mockSnapshotsTake = vi.hoisted(() => vi.fn());
-vi.mock('@cspeach/sap-client', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        snapshots: {
-            take: mockSnapshotsTake,
-            list: mockSnapshotsList,
-            read: mockSnapshotsRead,
-            cleanup: mockSnapshotsCleanup,
-        },
-    };
-});
-// ---------------------------------------------------------------------------
-// B.1: Mock verifyAndSpendApprovalId to bypass JWT check
-// ---------------------------------------------------------------------------
-const mockVerifyAndSpend = vi.hoisted(() => vi.fn());
-vi.mock('../../approvals/jwt.js', () => ({
-    verifyAndSpendApprovalId: mockVerifyAndSpend,
-    mintApprovalId: vi.fn(),
-}));
-// ---------------------------------------------------------------------------
-// B.1: Mock interceptUpdateMethod so we can control its behaviour
-// ---------------------------------------------------------------------------
-const mockInterceptUpdateMethod = vi.hoisted(() => vi.fn());
-vi.mock('../update-method-intercept.js', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        interceptUpdateMethod: mockInterceptUpdateMethod,
-    };
-});
-// ---------------------------------------------------------------------------
-// B.1: Mock session pending helpers so WAL doesn't hit the filesystem
-// ---------------------------------------------------------------------------
-vi.mock('../../session/pending.js', () => ({
-    appendPending: vi.fn().mockResolvedValue(undefined),
-    finalizeToolCall: vi.fn().mockResolvedValue(undefined),
-    hasUnfinishedMutations: vi.fn().mockReturnValue(false),
-}));
-// ---------------------------------------------------------------------------
-// B.1: Mock verify helper — syntax-check gate used after write
-// ---------------------------------------------------------------------------
-vi.mock('../verify.js', () => ({
-    verifySyntax: vi.fn().mockResolvedValue({ ok: true, errors: [], warnings: [] }),
-    verifyActive: vi.fn().mockResolvedValue({ active: true }),
-}));
-// ---------------------------------------------------------------------------
-// B.2: Mock safety-confirm and safety-mode-state
-// ---------------------------------------------------------------------------
-const mockIsSafetyConfirmEnabled = vi.hoisted(() => vi.fn());
-vi.mock('../../repl/safety-mode-state.js', () => ({
-    isSafetyConfirmEnabled: mockIsSafetyConfirmEnabled,
-}));
-const mockPresentSafetyConfirmation = vi.hoisted(() => vi.fn());
-vi.mock('../../repl/safety-confirm.js', () => ({
-    presentSafetyConfirmation: mockPresentSafetyConfirmation,
-}));
-// ---------------------------------------------------------------------------
-// Helper: build a minimal ToolContext stub
-// ---------------------------------------------------------------------------
-function makeCtx(adt, extras) {
-    return {
-        adt: adt,
-        sapAlias: 'dev',
-        session: { toolCalls: [] },
-        cwd: '.',
-        ...extras,
-    };
-}
-beforeEach(() => {
-    vi.clearAllMocks();
-    // Default: approval always succeeds
-    mockVerifyAndSpend.mockResolvedValue({ ok: true, payload: {} });
-    // Default: snapshot take is a no-op
-    mockSnapshotsTake.mockResolvedValue({ id: 'snap1' });
-    // Default: safety mode OFF so existing tests are unaffected
-    mockIsSafetyConfirmEnabled.mockReturnValue(false);
-});
-// ---------------------------------------------------------------------------
-// A.5.1 sap_lock
-// ---------------------------------------------------------------------------
-describe('sap_lock', () => {
-    it('calls lock(type, name) and returns JSON result', async () => {
-        const fakeResult = { lockHandle: 'abc123', status: 'locked' };
-        const adt = { lock: vi.fn().mockResolvedValue(fakeResult) };
-        const tool = getTool('sap_lock');
-        const result = await tool.handler({ type: 'CLAS', name: 'ZCL_FOO' }, makeCtx(adt));
-        expect(adt.lock).toHaveBeenCalledWith('CLAS', 'ZCL_FOO');
-        expect(JSON.parse(result.content)).toEqual(fakeResult);
-    });
-    it('propagates error when lock throws', async () => {
-        const adt = { lock: vi.fn().mockRejectedValue(new Error('already locked')) };
-        const tool = getTool('sap_lock');
-        await expect(tool.handler({ type: 'CLAS', name: 'ZCL_FOO' }, makeCtx(adt))).rejects.toThrow('already locked');
-    });
-});
-// ---------------------------------------------------------------------------
-// A.5.2 sap_unlock
-// ---------------------------------------------------------------------------
-describe('sap_unlock', () => {
-    it('calls unlock(type, name, lockHandle) and returns ok status', async () => {
-        const adt = { unlock: vi.fn().mockResolvedValue(undefined) };
-        const tool = getTool('sap_unlock');
-        const result = await tool.handler({ type: 'CLAS', name: 'ZCL_FOO', lockHandle: 'abc123' }, makeCtx(adt));
-        expect(adt.unlock).toHaveBeenCalledWith('CLAS', 'ZCL_FOO', 'abc123');
-        expect(JSON.parse(result.content)).toEqual({ status: 'ok' });
-    });
-    it('propagates error when unlock throws', async () => {
-        const adt = { unlock: vi.fn().mockRejectedValue(new Error('invalid lock handle')) };
-        const tool = getTool('sap_unlock');
-        await expect(tool.handler({ type: 'CLAS', name: 'ZCL_FOO', lockHandle: 'bad' }, makeCtx(adt))).rejects.toThrow('invalid lock handle');
-    });
-});
-// ---------------------------------------------------------------------------
-// A.5.3 sap_service_binding_publish
-// ---------------------------------------------------------------------------
-describe('sap_service_binding_publish', () => {
-    it('calls serviceBindingPublish(name) and returns JSON result', async () => {
-        const fakeResult = { status: 200 };
-        const adt = { serviceBindingPublish: vi.fn().mockResolvedValue(fakeResult) };
-        const tool = getTool('sap_service_binding_publish');
-        const result = await tool.handler({ name: 'ZSALES_UI_V4' }, makeCtx(adt));
-        expect(adt.serviceBindingPublish).toHaveBeenCalledWith('ZSALES_UI_V4');
-        expect(JSON.parse(result.content)).toEqual(fakeResult);
-    });
-    it('propagates error when serviceBindingPublish throws', async () => {
-        const adt = {
-            serviceBindingPublish: vi.fn().mockRejectedValue(new Error('ADT 404')),
-        };
-        const tool = getTool('sap_service_binding_publish');
-        await expect(tool.handler({ name: 'ZMISSING_UI_V4' }, makeCtx(adt))).rejects.toThrow('ADT 404');
-    });
-});
-// ---------------------------------------------------------------------------
-// A.5.4 sap_message_maintain (STUB)
-// ---------------------------------------------------------------------------
-describe('sap_message_maintain', () => {
-    it('returns not_implemented envelope for fully-populated args and is_error: true', async () => {
-        // STUB: no ADT method is called — do NOT set up any adt mock method
-        const adt = { messageMaintain: vi.fn() };
-        const tool = getTool('sap_message_maintain');
-        const result = await tool.handler({
-            messageClass: 'ZMSG_SALES',
-            messageNumber: '001',
-            messageText: 'Order &1 created',
-            messageType: 'S',
-        }, makeCtx(adt));
-        expect(result.is_error).toBe(true);
-        const parsed = JSON.parse(result.content);
-        expect(parsed.error).toBe('not_implemented');
-        expect(parsed.detail).toBeTruthy();
-        // Critical: STUB must not call any AdtClient method
-        expect(adt.messageMaintain).not.toHaveBeenCalled();
-    });
-    it('returns same not_implemented envelope for minimally-populated args', async () => {
-        const adt = { messageMaintain: vi.fn() };
-        const tool = getTool('sap_message_maintain');
-        const result = await tool.handler({ messageClass: 'ZMSG', messageNumber: '001', messageText: 'x' }, makeCtx(adt));
-        expect(result.is_error).toBe(true);
-        expect(JSON.parse(result.content).error).toBe('not_implemented');
-        expect(adt.messageMaintain).not.toHaveBeenCalled();
-    });
-});
-// ---------------------------------------------------------------------------
-// A.5.5 sap_number_range_intervals (STUB)
-// ---------------------------------------------------------------------------
-describe('sap_number_range_intervals', () => {
-    it('returns not_implemented envelope for fully-populated args and is_error: true', async () => {
-        const adt = { numberRangeIntervals: vi.fn() };
-        const tool = getTool('sap_number_range_intervals');
-        const result = await tool.handler({
-            nrObject: 'ZNROB_SALES',
-            subobject: '',
-            intervals: [{ from: '0000000001', to: '0000009999', ext: false }],
-        }, makeCtx(adt));
-        expect(result.is_error).toBe(true);
-        const parsed = JSON.parse(result.content);
-        expect(parsed.error).toBe('not_implemented');
-        expect(parsed.detail).toBeTruthy();
-        expect(adt.numberRangeIntervals).not.toHaveBeenCalled();
-    });
-    it('returns same not_implemented envelope for minimally-populated args', async () => {
-        const adt = { numberRangeIntervals: vi.fn() };
-        const tool = getTool('sap_number_range_intervals');
-        const result = await tool.handler({ nrObject: 'ZNROB_SALES' }, makeCtx(adt));
-        expect(result.is_error).toBe(true);
-        expect(JSON.parse(result.content).error).toBe('not_implemented');
-        expect(adt.numberRangeIntervals).not.toHaveBeenCalled();
-    });
-});
-// ---------------------------------------------------------------------------
-// A.6.1 sap_snapshot_list
-// ---------------------------------------------------------------------------
-describe('sap_snapshot_list', () => {
-    it('calls snapshots.list with type and name when provided', async () => {
-        const fakeEntries = [{ id: 'snap1', type: 'CLAS', name: 'ZCL_FOO' }];
-        mockSnapshotsList.mockResolvedValue(fakeEntries);
-        const tool = getTool('sap_snapshot_list');
-        const result = await tool.handler({ type: 'CLAS', name: 'ZCL_FOO' }, makeCtx({}));
-        expect(mockSnapshotsList).toHaveBeenCalledWith('CLAS', 'ZCL_FOO');
-        expect(JSON.parse(result.content)).toEqual(fakeEntries);
-    });
-    it('propagates error when snapshots.list throws', async () => {
-        mockSnapshotsList.mockRejectedValue(new Error('snapshot dir not found'));
-        const tool = getTool('sap_snapshot_list');
-        await expect(tool.handler({}, makeCtx({}))).rejects.toThrow('snapshot dir not found');
-    });
-});
-// ---------------------------------------------------------------------------
-// A.6.2 sap_snapshot_read
-// ---------------------------------------------------------------------------
-describe('sap_snapshot_read', () => {
-    it('calls snapshots.read and returns raw source as content', async () => {
-        const fakeSource = 'CLASS ZCL_FOO DEFINITION.\nENDCLASS.';
-        mockSnapshotsRead.mockResolvedValue(fakeSource);
-        const tool = getTool('sap_snapshot_read');
-        const result = await tool.handler({ type: 'CLAS', name: 'ZCL_FOO', snapshotId: 'snap1.abap' }, makeCtx({}));
-        expect(mockSnapshotsRead).toHaveBeenCalledWith('CLAS', 'ZCL_FOO', 'snap1.abap');
-        // sap_snapshot_read returns raw text (not stringified)
-        expect(result.content).toBe(fakeSource);
-    });
-    it('propagates error when snapshots.read throws', async () => {
-        mockSnapshotsRead.mockRejectedValue(new Error('snapshot not found'));
-        const tool = getTool('sap_snapshot_read');
-        await expect(tool.handler({ type: 'CLAS', name: 'ZCL_FOO', snapshotId: 'missing.abap' }, makeCtx({}))).rejects.toThrow('snapshot not found');
-    });
-});
-// ---------------------------------------------------------------------------
-// A.6.3 sap_snapshot_cleanup
-// ---------------------------------------------------------------------------
-describe('sap_snapshot_cleanup', () => {
-    it('calls snapshots.cleanup with retentionHours and returns deleted count', async () => {
-        mockSnapshotsCleanup.mockResolvedValue(7);
-        const tool = getTool('sap_snapshot_cleanup');
-        const result = await tool.handler({ retentionHours: 48 }, makeCtx({}));
-        expect(mockSnapshotsCleanup).toHaveBeenCalledWith(48);
-        expect(JSON.parse(result.content)).toEqual({ deleted: 7 });
-    });
-    it('propagates error when snapshots.cleanup throws', async () => {
-        mockSnapshotsCleanup.mockRejectedValue(new Error('permission denied'));
-        const tool = getTool('sap_snapshot_cleanup');
-        await expect(tool.handler({}, makeCtx({}))).rejects.toThrow('permission denied');
-    });
-});
-// ---------------------------------------------------------------------------
-// B.1 sap_update_method — diff-preview gate (Rule 7a)
-//
-// Mocking strategy:
-//   - verifyAndSpendApprovalId: mocked globally above (returns ok:true by default)
-//   - interceptUpdateMethod: mocked globally above (we control resolve/throw per test)
-//   - autoSnapshot: relies on ctx.adt.getSource + snapshots.take (both mocked)
-//   - appendPending / finalizeToolCall: mocked globally above
-//   - verifySyntax: mocked globally above (returns ok:true by default)
-// ---------------------------------------------------------------------------
-// Minimal class source used by autoSnapshot's ctx.adt.getSource call.
-const SAMPLE_CLASS_SOURCE = `CLASS zcl_demo DEFINITION PUBLIC FINAL CREATE PUBLIC.
-  PUBLIC SECTION.
-    METHODS do_work.
-ENDCLASS.
-
-CLASS zcl_demo IMPLEMENTATION.
-  METHOD do_work.
-    RETURN.
-  ENDMETHOD.
-ENDCLASS.`;
-describe('sap_update_method', () => {
-    // B.1 test 1 — Happy path: confirmed preview → updateMethod called once
-    it('calls updateMethod when interceptUpdateMethod confirms (previewHook resolves confirmed)', async () => {
-        const mockUpdateMethod = vi.fn().mockResolvedValue({ status: 'ok' });
-        const mockGetSource = vi.fn().mockResolvedValue(SAMPLE_CLASS_SOURCE);
-        // interceptUpdateMethod resolves (confirmed) → flow continues to write
-        mockInterceptUpdateMethod.mockResolvedValue(undefined);
-        const previewHook = vi.fn().mockResolvedValue({ confirmed: true });
-        const adt = { updateMethod: mockUpdateMethod, getSource: mockGetSource };
-        const tool = getTool('sap_update_method');
-        const result = await tool.handler({
-            class_name: 'ZCL_DEMO',
-            method_name: 'do_work',
-            method_source: '  DATA lv_x TYPE i.\n  lv_x = 42.',
-            transport: 'SXXK999999',
-            approval_id: 'dummy-jwt',
-        }, makeCtx(adt, { previewHook }));
-        expect(mockInterceptUpdateMethod).toHaveBeenCalledOnce();
-        const [minimalArg, callArg, hookArg] = mockInterceptUpdateMethod.mock.calls[0];
-        expect(typeof minimalArg.getSource).toBe('function');
-        expect(callArg.className).toBe('ZCL_DEMO');
-        expect(callArg.methodName).toBe('do_work');
-        expect(hookArg).toBe(previewHook);
-        expect(mockUpdateMethod).toHaveBeenCalledOnce();
-        expect(mockUpdateMethod).toHaveBeenCalledWith('ZCL_DEMO', 'do_work', '  DATA lv_x TYPE i.\n  lv_x = 42.', 'SXXK999999');
-        const parsed = JSON.parse(result.content);
-        expect(parsed.updated).toBe(true);
-        expect(result.is_error).toBeFalsy();
-    });
-    // B.1 test 2 — previewHook missing: handler returns preview_hook_unavailable; updateMethod NOT called
-    it('returns preview_hook_unavailable envelope when ctx.previewHook is undefined', async () => {
-        const mockUpdateMethod = vi.fn();
-        const mockGetSource = vi.fn().mockResolvedValue(SAMPLE_CLASS_SOURCE);
-        const adt = { updateMethod: mockUpdateMethod, getSource: mockGetSource };
-        const tool = getTool('sap_update_method');
-        const result = await tool.handler({
-            class_name: 'ZCL_DEMO',
-            method_name: 'do_work',
-            method_source: '  RETURN.',
-            approval_id: 'dummy-jwt',
-        }, makeCtx(adt));
-        expect(result.is_error).toBe(true);
-        const parsed = JSON.parse(result.content);
-        expect(parsed.error).toBe('preview_hook_unavailable');
-        expect(parsed.detail).toBeTruthy();
-        // Critical: updateMethod must NOT be called
-        expect(mockUpdateMethod).not.toHaveBeenCalled();
-        expect(mockInterceptUpdateMethod).not.toHaveBeenCalled();
-    });
-    // B.1 test 3 — User declines: CancelledByUserError thrown → cancelled_by_user envelope; updateMethod NOT called
-    it('returns cancelled_by_user envelope when interceptUpdateMethod throws CancelledByUserError', async () => {
-        const mockUpdateMethod = vi.fn();
-        const mockGetSource = vi.fn().mockResolvedValue(SAMPLE_CLASS_SOURCE);
-        const cancelledCall = {
-            className: 'ZCL_DEMO', methodName: 'do_work',
-            methodSource: '  RETURN.', transport: '',
-        };
-        mockInterceptUpdateMethod.mockRejectedValue(new CancelledByUserError(cancelledCall));
-        const previewHook = vi.fn().mockResolvedValue({ confirmed: false });
-        const adt = { updateMethod: mockUpdateMethod, getSource: mockGetSource };
-        const tool = getTool('sap_update_method');
-        const result = await tool.handler({
-            class_name: 'ZCL_DEMO',
-            method_name: 'do_work',
-            method_source: '  RETURN.',
-            approval_id: 'dummy-jwt',
-        }, makeCtx(adt, { previewHook }));
-        expect(result.is_error).toBe(true);
-        const parsed = JSON.parse(result.content);
-        expect(parsed.error).toBe('cancelled_by_user');
-        expect(parsed.detail).toBeTruthy();
-        // Critical: updateMethod must NOT be called
-        expect(mockUpdateMethod).not.toHaveBeenCalled();
-    });
-    // B.1 test 4 — getSource rejects (preview_failed path): handler returns preview_failed; updateMethod NOT called
-    it('returns preview_failed envelope when ctx.adt.getSource rejects inside interceptUpdateMethod', async () => {
-        const mockUpdateMethod = vi.fn();
-        // getSource rejects — interceptUpdateMethod will throw a plain Error (not CancelledByUserError)
-        mockInterceptUpdateMethod.mockRejectedValue(new Error('ADT 404 class not found'));
-        const previewHook = vi.fn();
-        const adt = { updateMethod: mockUpdateMethod, getSource: vi.fn().mockRejectedValue(new Error('ADT 404')) };
-        const tool = getTool('sap_update_method');
-        const result = await tool.handler({
-            class_name: 'ZCL_MISSING',
-            method_name: 'do_work',
-            method_source: '  RETURN.',
-            approval_id: 'dummy-jwt',
-        }, makeCtx(adt, { previewHook }));
-        expect(result.is_error).toBe(true);
-        const parsed = JSON.parse(result.content);
-        expect(parsed.error).toBe('preview_failed');
-        expect(parsed.detail).toContain('ADT 404');
-        // Critical: updateMethod must NOT be called
-        expect(mockUpdateMethod).not.toHaveBeenCalled();
-    });
-});
-// ---------------------------------------------------------------------------
-// B.2 sap_set_source — safety confirmation gate (Rule 7)
-// ---------------------------------------------------------------------------
-describe('sap_set_source safety confirmation', () => {
-    it('calls presentSafetyConfirmation with correct SafetyAction and proceeds when confirmed', async () => {
-        mockIsSafetyConfirmEnabled.mockReturnValue(true);
-        mockPresentSafetyConfirmation.mockResolvedValue({ confirmed: true });
-        // setSource returns a WriteResult — handler now checks writeStatus / error
-        // (regression fix: HTTP 4xx returns rather than throws). Success path = no
-        // error and writeStatus < 400. See memory/project_phase3_lite_regression.md.
-        const mockSetSource = vi.fn().mockResolvedValue({ writeStatus: 200 });
-        // autoSnapshot calls ctx.adt.getSource — provide a stub so the snapshot gate passes
-        const mockGetSource = vi.fn().mockResolvedValue('CLASS ZCL_MYCLASS DEFINITION.\nENDCLASS.\n');
-        const adt = { setSource: mockSetSource, getSource: mockGetSource };
-        const tool = getTool('sap_set_source');
-        const result = await tool.handler({
-            name: 'ZCL_MYCLASS',
-            type: 'CLAS',
-            source: 'CLASS ZCL_MYCLASS DEFINITION.\nENDCLASS.\n',
-            transport: 'DEVK900001',
-            approval_id: 'dummy-jwt',
-        }, makeCtx(adt));
-        // Safety confirmation must have been called with correct shape
-        expect(mockPresentSafetyConfirmation).toHaveBeenCalledOnce();
-        const action = mockPresentSafetyConfirmation.mock.calls[0][0];
-        expect(action.rule).toBe('RULE_7_SNAPSHOT_BEFORE_WRITE');
-        expect(action.op).toBe('set_source');
-        expect(action.object).toEqual({ type: 'CLAS', name: 'ZCL_MYCLASS' });
-        expect(action.what_will_happen).toBeTruthy();
-        expect(action.rollback_available).toBe(true);
-        expect(action.transport).toBe('DEVK900001');
-        // setSource must have been called (confirmed)
-        expect(mockSetSource).toHaveBeenCalledOnce();
-        const parsed = JSON.parse(result.content);
-        expect(parsed.written).toBe(true);
-        expect(result.is_error).toBeFalsy();
-    });
-    it('returns cancelled_by_user and does NOT call setSource when user declines', async () => {
-        mockIsSafetyConfirmEnabled.mockReturnValue(true);
-        mockPresentSafetyConfirmation.mockResolvedValue({ confirmed: false, reason: 'test decline' });
-        const mockSetSource = vi.fn();
-        // autoSnapshot calls ctx.adt.getSource — provide a stub so snapshot gate passes before Gate 3
-        const mockGetSource = vi.fn().mockResolvedValue('CLASS ZCL_MYCLASS DEFINITION.\nENDCLASS.\n');
-        const adt = { setSource: mockSetSource, getSource: mockGetSource };
-        const tool = getTool('sap_set_source');
-        const result = await tool.handler({
-            name: 'ZCL_MYCLASS',
-            type: 'CLAS',
-            source: 'CLASS ZCL_MYCLASS DEFINITION.\nENDCLASS.\n',
-            approval_id: 'dummy-jwt',
-        }, makeCtx(adt));
-        expect(result.is_error).toBe(true);
-        const parsed = JSON.parse(result.content);
-        expect(parsed.error).toBe('cancelled_by_user');
-        expect(parsed.reason).toBe('test decline');
-        // Critical: setSource must NOT be called
-        expect(mockSetSource).not.toHaveBeenCalled();
-    });
-});
-// ---------------------------------------------------------------------------
-// B.2 sap_delete_object — safety confirmation gate (Rule 7)
-// ---------------------------------------------------------------------------
-describe('sap_delete_object safety confirmation', () => {
-    it('calls presentSafetyConfirmation with correct SafetyAction and proceeds when confirmed', async () => {
-        mockIsSafetyConfirmEnabled.mockReturnValue(true);
-        mockPresentSafetyConfirmation.mockResolvedValue({ confirmed: true });
-        const mockDeleteObject = vi.fn().mockResolvedValue({ status: 200 });
-        // objectStructure called in post-check — return rejection (object gone)
-        const mockObjectStructure = vi.fn().mockRejectedValue(new Error('not found'));
-        const adt = { deleteObject: mockDeleteObject, objectStructure: mockObjectStructure };
-        const tool = getTool('sap_delete_object');
-        const result = await tool.handler({
-            name: 'ZCL_OLD',
-            type: 'CLAS',
-            transport: 'DEVK900002',
-            approval_id: 'dummy-jwt',
-        }, makeCtx(adt));
-        // Safety confirmation must have been called with correct shape
-        expect(mockPresentSafetyConfirmation).toHaveBeenCalledOnce();
-        const action = mockPresentSafetyConfirmation.mock.calls[0][0];
-        expect(action.rule).toBe('RULE_7_SNAPSHOT_BEFORE_WRITE');
-        expect(action.op).toBe('delete_object');
-        expect(action.object).toEqual({ type: 'CLAS', name: 'ZCL_OLD' });
-        expect(action.what_will_happen).toBeTruthy();
-        expect(action.rollback_available).toBe(true);
-        expect(action.transport).toBe('DEVK900002');
-        // deleteObject must have been called (confirmed)
-        expect(mockDeleteObject).toHaveBeenCalledOnce();
-        const parsed = JSON.parse(result.content);
-        expect(parsed.deleted).toBe(true);
-        expect(result.is_error).toBeFalsy();
-    });
-    it('returns cancelled_by_user and does NOT call deleteObject when user declines', async () => {
-        mockIsSafetyConfirmEnabled.mockReturnValue(true);
-        mockPresentSafetyConfirmation.mockResolvedValue({ confirmed: false, reason: 'no delete' });
-        const mockDeleteObject = vi.fn();
-        const adt = { deleteObject: mockDeleteObject };
-        const tool = getTool('sap_delete_object');
-        const result = await tool.handler({
-            name: 'ZCL_OLD',
-            type: 'CLAS',
-            approval_id: 'dummy-jwt',
-        }, makeCtx(adt));
-        expect(result.is_error).toBe(true);
-        const parsed = JSON.parse(result.content);
-        expect(parsed.error).toBe('cancelled_by_user');
-        expect(parsed.reason).toBe('no delete');
-        // Critical: deleteObject must NOT be called
-        expect(mockDeleteObject).not.toHaveBeenCalled();
-    });
-});
-// ---------------------------------------------------------------------------
-// Regression guard 2026-05-01 — handlers MUST check the AdtClient return value.
-// Phase 3-Lite shipped with sap_set_source / sap_update_method / sap_delete_object
-// silently reporting success when the underlying ADT REST call returned a 4xx
-// without throwing (the SDK only throws on catastrophic failure). The LLM
-// believed writes succeeded; SAP source was unchanged. Full diagnosis at
-// memory/project_phase3_lite_regression.md.
-// ---------------------------------------------------------------------------
-describe('regression: handlers surface AdtClient HTTP-level failures', () => {
-    it('sap_set_source returns is_error when AdtClient.setSource resolves with writeStatus >= 400', async () => {
-        mockIsSafetyConfirmEnabled.mockReturnValue(false);
-        const mockSetSource = vi.fn().mockResolvedValue({
-            writeStatus: 423,
-            error: 'Write failed with HTTP 423: locked',
-        });
-        const mockGetSource = vi.fn().mockResolvedValue('REPORT z. WRITE / 1.');
-        const adt = { setSource: mockSetSource, getSource: mockGetSource };
-        const tool = getTool('sap_set_source');
-        const result = await tool.handler({ name: 'Z_PROBE', type: 'PROG', source: 'REPORT z. WRITE / 2.', approval_id: 'dummy-jwt' }, makeCtx(adt));
-        expect(result.is_error).toBe(true);
-        const parsed = JSON.parse(result.content);
-        expect(parsed.error).toBe('write_failed');
-        expect(parsed.write_status).toBe(423);
-        expect(parsed.detail).toContain('423');
-        // setSource WAS called — the failure happened on the server side.
-        expect(mockSetSource).toHaveBeenCalledOnce();
-    });
-    it('sap_update_method returns is_error when AdtClient.updateMethod resolves with writeStatus >= 400', async () => {
-        // Need to mock interceptUpdateMethod (B.1 wiring) so the diff-preview gate proceeds.
-        mockInterceptUpdateMethod.mockResolvedValue(undefined);
-        const previewHook = vi.fn().mockResolvedValue({ confirmed: true });
-        const mockUpdateMethod = vi.fn().mockResolvedValue({
-            writeStatus: 412,
-            error: 'Write failed with HTTP 412: precondition failed',
-        });
-        const mockGetSource = vi.fn().mockResolvedValue('CLASS zcl. METHOD do. ENDMETHOD. ENDCLASS.');
-        const adt = {
-            updateMethod: mockUpdateMethod,
-            getSource: mockGetSource,
-        };
-        const tool = getTool('sap_update_method');
-        const result = await tool.handler({
-            class_name: 'ZCL_X',
-            method_name: 'do',
-            method_source: '  WRITE 1.',
-            transport: 'DEVK900003',
-            approval_id: 'dummy-jwt',
-        }, makeCtx(adt, { previewHook }));
-        expect(result.is_error).toBe(true);
-        const parsed = JSON.parse(result.content);
-        expect(parsed.error).toBe('update_failed');
-        expect(parsed.write_status).toBe(412);
-        expect(mockUpdateMethod).toHaveBeenCalledOnce();
-    });
-    it('sap_delete_object returns is_error when AdtClient.deleteObject resolves with status >= 400', async () => {
-        mockIsSafetyConfirmEnabled.mockReturnValue(false);
-        const mockDeleteObject = vi.fn().mockResolvedValue({
-            status: 403,
-            error: 'Delete forbidden — package locked',
-        });
-        const mockGetSource = vi.fn().mockResolvedValue('REPORT z.');
-        const adt = { deleteObject: mockDeleteObject, getSource: mockGetSource };
-        const tool = getTool('sap_delete_object');
-        const result = await tool.handler({ name: 'Z_PROBE', type: 'PROG', approval_id: 'dummy-jwt' }, makeCtx(adt));
-        expect(result.is_error).toBe(true);
-        const parsed = JSON.parse(result.content);
-        expect(parsed.error).toBe('delete_failed');
-        expect(parsed.status).toBe(403);
-        expect(mockDeleteObject).toHaveBeenCalledOnce();
-    });
-});

package/dist/tools/__tests__/schedule_create.test.js

@@ -1,85 +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 { scheduleCreateHandler, __setSchedulesDirForTests } from '../subagent/schedule_create.js';
-import { makeCtx } from './_helpers.js';
-let dir;
-const ctx = () => makeCtx(process.cwd());
-beforeEach(async () => {
-    dir = await fs.mkdtemp(path.join(os.tmpdir(), 'cspeach-schedules-'));
-    __setSchedulesDirForTests(dir);
-});
-afterEach(async () => {
-    __setSchedulesDirForTests(null); // restore default
-    await fs.rm(dir, { recursive: true, force: true, maxRetries: 5, retryDelay: 200 });
-});
-async function listJsonFiles() {
-    const entries = await fs.readdir(dir);
-    return entries.filter((e) => e.endsWith('.json'));
-}
-describe('schedule_create handler', () => {
-    it('persists a oneoff schedule with crypto.randomUUID filename', async () => {
-        const r = await scheduleCreateHandler({ kind: 'oneoff', when: '2099-06-01T10:00:00Z', command: 'echo hello' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        const files = await listJsonFiles();
-        expect(files).toHaveLength(1);
-        expect(files[0]).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.json$/i);
-        const body = JSON.parse(await fs.readFile(path.join(dir, files[0]), 'utf-8'));
-        expect(body.kind).toBe('oneoff');
-        expect(body.when).toBe('2099-06-01T10:00:00Z');
-        expect(body.command).toBe('echo hello');
-        expect(typeof body.id).toBe('string');
-        expect(typeof body.createdAt).toBe('string');
-    });
-    it('persists a cron schedule', async () => {
-        const r = await scheduleCreateHandler({ kind: 'cron', when: '0 9 * * 1-5', command: 'pnpm test' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        const files = await listJsonFiles();
-        const body = JSON.parse(await fs.readFile(path.join(dir, files[0]), 'utf-8'));
-        expect(body.kind).toBe('cron');
-        expect(body.when).toBe('0 9 * * 1-5');
-    });
-    it('rejects missing kind', async () => {
-        const r = await scheduleCreateHandler({ when: '2099-06-01T10:00:00Z', command: 'echo' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/kind/i);
-    });
-    it('rejects unknown kind', async () => {
-        const r = await scheduleCreateHandler({ kind: 'twice-monthly', when: '?', command: 'echo' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/kind/i);
-    });
-    it('rejects oneoff with a non-ISO `when`', async () => {
-        const r = await scheduleCreateHandler({ kind: 'oneoff', when: 'tomorrow at 10', command: 'echo' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/ISO/i);
-    });
-    it('rejects oneoff with a `when` in the past', async () => {
-        const r = await scheduleCreateHandler({ kind: 'oneoff', when: '2000-01-01T00:00:00Z', command: 'echo' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/past|future/i);
-    });
-    it('rejects calendar-invalid dates that Date.parse would silently roll forward (e.g. Feb 30)', async () => {
-        const r = await scheduleCreateHandler({ kind: 'oneoff', when: '2099-02-30T00:00:00Z', command: 'echo' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/calendar|valid|rolls/i);
-    });
-    it('rejects empty command', async () => {
-        const r = await scheduleCreateHandler({ kind: 'oneoff', when: '2099-06-01T10:00:00Z', command: '' }, ctx());
-        expect(r.is_error).toBe(true);
-        expect(r.content).toMatch(/command/i);
-    });
-    it('creates the schedules dir if missing', async () => {
-        const nested = path.join(dir, 'nested', 'dir');
-        __setSchedulesDirForTests(nested);
-        const r = await scheduleCreateHandler({ kind: 'oneoff', when: '2099-06-01T10:00:00Z', command: 'echo' }, ctx());
-        expect(r.is_error).toBeFalsy();
-        const stat = await fs.stat(nested);
-        expect(stat.isDirectory()).toBe(true);
-    });
-    it('mentions in the response that scheduled jobs are persisted but NOT yet executed', async () => {
-        const r = await scheduleCreateHandler({ kind: 'oneoff', when: '2099-06-01T10:00:00Z', command: 'echo' }, ctx());
-        expect(r.content).toMatch(/persisted|not yet executed|runner/i);
-    });
-});