@su-record/vibe 2.12.5 → 2.14.0

package/hooks/scripts/__tests__/loop-ledger.test.js

@@ -0,0 +1,321 @@
+/**
+ * loop-ledger 라이브러리 + CLI 테스트
+ *
+ * 커버리지:
+ * - appendLoopEvent round-trip
+ * - isStuck: 2회 연속 동일 hash → true
+ * - isStuck: 다른 hash → false
+ * - isStuck: 이력 없음 → false
+ * - fail-open: 손상된 jsonl 줄 무시
+ * - hashDiscoverOutput: 공백 정규화
+ * - CLI: start / end / check-stuck 서브커맨드
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+let tmpDir;
+beforeEach(() => {
+  tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'vibe-loop-ledger-test-'));
+});
+afterEach(() => {
+  try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
+});
+
+async function importLedger() {
+  const p = path.resolve(__dirname, '..', 'lib', 'loop-ledger.js');
+  return import(p);
+}
+
+const CLI = path.resolve(__dirname, '..', 'loop-ledger.js');
+
+function historyPath(dir) {
+  return path.join(dir, '.vibe', 'metrics', 'loop-history.jsonl');
+}
+
+// ─── appendLoopEvent round-trip ───────────────────────────────────────
+
+describe('loop-ledger: appendLoopEvent round-trip', () => {
+  it('start 이벤트를 append 하면 jsonl 파일에 기록된다', async () => {
+    const { appendLoopEvent } = await importLedger();
+    appendLoopEvent(tmpDir, { loop: 'nightly', event: 'start' });
+
+    const p = historyPath(tmpDir);
+    expect(fs.existsSync(p)).toBe(true);
+    const line = fs.readFileSync(p, 'utf-8').trim();
+    const obj = JSON.parse(line);
+    expect(obj.loop).toBe('nightly');
+    expect(obj.event).toBe('start');
+    expect(obj.ts).toBeDefined();
+  });
+
+  it('end 이벤트에 result, summary, discoverHash가 포함된다', async () => {
+    const { appendLoopEvent } = await importLedger();
+    appendLoopEvent(tmpDir, {
+      loop: 'nightly',
+      event: 'end',
+      result: 'ok',
+      summary: '3 items processed',
+      discoverHash: 'abc123',
+    });
+
+    const p = historyPath(tmpDir);
+    const line = fs.readFileSync(p, 'utf-8').trim();
+    const obj = JSON.parse(line);
+    expect(obj.event).toBe('end');
+    expect(obj.result).toBe('ok');
+    expect(obj.summary).toBe('3 items processed');
+    expect(obj.discoverHash).toBe('abc123');
+  });
+
+  it('여러 이벤트가 순서대로 append 된다', async () => {
+    const { appendLoopEvent } = await importLedger();
+    appendLoopEvent(tmpDir, { loop: 'loop-a', event: 'start' });
+    appendLoopEvent(tmpDir, { loop: 'loop-a', event: 'end', result: 'ok' });
+    appendLoopEvent(tmpDir, { loop: 'loop-b', event: 'start' });
+
+    const p = historyPath(tmpDir);
+    const lines = fs.readFileSync(p, 'utf-8').trim().split('\n');
+    expect(lines).toHaveLength(3);
+    expect(JSON.parse(lines[0]).loop).toBe('loop-a');
+    expect(JSON.parse(lines[1]).event).toBe('end');
+    expect(JSON.parse(lines[2]).loop).toBe('loop-b');
+  });
+
+  it('appendLoopEvent는 true를 반환한다', async () => {
+    const { appendLoopEvent } = await importLedger();
+    const result = appendLoopEvent(tmpDir, { loop: 'x', event: 'start' });
+    expect(result).toBe(true);
+  });
+});
+
+// ─── isStuck ──────────────────────────────────────────────────────────
+
+describe('loop-ledger: isStuck', () => {
+  it('이력 없으면 false', async () => {
+    const { isStuck } = await importLedger();
+    expect(isStuck(tmpDir, 'nightly', 'hash-abc')).toBe(false);
+  });
+
+  it('직전 discover 이벤트와 동일 hash → true (2회 연속 성립)', async () => {
+    const { appendLoopEvent, isStuck } = await importLedger();
+    // 이전 반복의 discover 이벤트 (같은 hash)
+    appendLoopEvent(tmpDir, {
+      loop: 'nightly',
+      event: 'discover',
+      discoverHash: 'hash-same',
+    });
+    // 신규 반복이 같은 hash를 갖고 오면 stuck
+    expect(isStuck(tmpDir, 'nightly', 'hash-same')).toBe(true);
+  });
+
+  it('직전 discover 이벤트와 다른 hash → false', async () => {
+    const { appendLoopEvent, isStuck } = await importLedger();
+    appendLoopEvent(tmpDir, {
+      loop: 'nightly',
+      event: 'discover',
+      discoverHash: 'hash-old',
+    });
+    expect(isStuck(tmpDir, 'nightly', 'hash-new')).toBe(false);
+  });
+
+  it('end 이벤트의 hash는 비교 대상이 아님 (discover만 본다)', async () => {
+    const { appendLoopEvent, isStuck } = await importLedger();
+    appendLoopEvent(tmpDir, {
+      loop: 'nightly',
+      event: 'end',
+      result: 'ok',
+      discoverHash: 'hash-same',
+    });
+    expect(isStuck(tmpDir, 'nightly', 'hash-same')).toBe(false);
+  });
+
+  it('다른 루프 이름의 이벤트는 영향 안 줌', async () => {
+    const { appendLoopEvent, isStuck } = await importLedger();
+    appendLoopEvent(tmpDir, {
+      loop: 'other-loop',
+      event: 'discover',
+      discoverHash: 'hash-same',
+    });
+    // 'nightly' 에 대한 이력 없음 → false
+    expect(isStuck(tmpDir, 'nightly', 'hash-same')).toBe(false);
+  });
+
+  it('start 이벤트만 있고 discover 없으면 false', async () => {
+    const { appendLoopEvent, isStuck } = await importLedger();
+    appendLoopEvent(tmpDir, { loop: 'nightly', event: 'start' });
+    expect(isStuck(tmpDir, 'nightly', 'hash-abc')).toBe(false);
+  });
+
+  it('discoverHash 가 빈 문자열이면 false', async () => {
+    const { appendLoopEvent, isStuck } = await importLedger();
+    appendLoopEvent(tmpDir, {
+      loop: 'nightly',
+      event: 'discover',
+      discoverHash: '',
+    });
+    expect(isStuck(tmpDir, 'nightly', '')).toBe(false);
+  });
+});
+
+// ─── fail-open: 손상된 jsonl 줄 ──────────────────────────────────────
+
+describe('loop-ledger: fail-open on corrupt jsonl', () => {
+  it('손상된 줄이 있어도 isStuck이 충돌하지 않고 false 반환', async () => {
+    const { appendLoopEvent, isStuck } = await importLedger();
+
+    // 정상 줄 + 손상 줄 + 정상 줄 혼합
+    const p = historyPath(tmpDir);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(
+      p,
+      [
+        JSON.stringify({ ts: '2026-01-01T00:00:00.000Z', loop: 'nightly', event: 'discover', discoverHash: 'abc' }),
+        'CORRUPTED LINE {{{',
+        JSON.stringify({ ts: '2026-01-01T01:00:00.000Z', loop: 'nightly', event: 'discover', discoverHash: 'xyz' }),
+      ].join('\n') + '\n',
+      'utf-8'
+    );
+
+    // 손상 줄은 건너뛰고, 가장 최근 discover 이벤트(최신)의 hash는 'xyz'
+    expect(isStuck(tmpDir, 'nightly', 'xyz')).toBe(true);
+    expect(isStuck(tmpDir, 'nightly', 'abc')).toBe(false);
+  });
+
+  it('appendLoopEvent: 전체 파일이 corrupt 여도 추가 후 정상 동작', async () => {
+    const { appendLoopEvent } = await importLedger();
+    const p = historyPath(tmpDir);
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, 'NOT JSON\n', 'utf-8');
+
+    const ok = appendLoopEvent(tmpDir, { loop: 'x', event: 'start' });
+    expect(ok).toBe(true);
+    const lines = fs.readFileSync(p, 'utf-8').split('\n').filter(Boolean);
+    // 손상 줄 + 새로 추가된 정상 줄
+    expect(lines.length).toBeGreaterThanOrEqual(2);
+    const last = JSON.parse(lines[lines.length - 1]);
+    expect(last.event).toBe('start');
+  });
+});
+
+// ─── hashDiscoverOutput ───────────────────────────────────────────────
+
+describe('loop-ledger: hashDiscoverOutput', () => {
+  it('동일 텍스트는 동일 해시를 반환한다', async () => {
+    const { hashDiscoverOutput } = await importLedger();
+    const h1 = hashDiscoverOutput('hello world');
+    const h2 = hashDiscoverOutput('hello world');
+    expect(h1).toBe(h2);
+  });
+
+  it('공백 정규화: 여분 공백/줄바꿈이 달라도 동일 해시', async () => {
+    const { hashDiscoverOutput } = await importLedger();
+    const h1 = hashDiscoverOutput('item a\nitem b');
+    const h2 = hashDiscoverOutput('item a  item b');
+    const h3 = hashDiscoverOutput('  item a item b  ');
+    expect(h1).toBe(h2);
+    expect(h2).toBe(h3);
+  });
+
+  it('다른 텍스트는 다른 해시', async () => {
+    const { hashDiscoverOutput } = await importLedger();
+    expect(hashDiscoverOutput('abc')).not.toBe(hashDiscoverOutput('xyz'));
+  });
+
+  it('sha256 hex 64자 반환', async () => {
+    const { hashDiscoverOutput } = await importLedger();
+    expect(hashDiscoverOutput('test')).toMatch(/^[0-9a-f]{64}$/);
+  });
+});
+
+// ─── CLI: start / end / check-stuck ─────────────────────────────────
+
+describe('loop-ledger CLI', () => {
+  it('start → exit 0, 확인 메시지 출력, jsonl 생성', () => {
+    const result = spawnSync('node', [CLI, 'start', 'nightly'], {
+      encoding: 'utf-8',
+      timeout: 5000,
+      env: { ...process.env, CLAUDE_PROJECT_DIR: tmpDir },
+    });
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('start recorded');
+    expect(result.stdout).toContain('nightly');
+    expect(fs.existsSync(historyPath(tmpDir))).toBe(true);
+  });
+
+  it('end → exit 0, jsonl에 end 이벤트 기록', () => {
+    const result = spawnSync('node', [CLI, 'end', 'nightly', 'ok', 'summary text'], {
+      encoding: 'utf-8',
+      timeout: 5000,
+      env: { ...process.env, CLAUDE_PROJECT_DIR: tmpDir },
+    });
+    expect(result.status).toBe(0);
+    expect(result.stdout).toContain('end recorded');
+
+    const line = fs.readFileSync(historyPath(tmpDir), 'utf-8').trim();
+    const obj = JSON.parse(line);
+    expect(obj.event).toBe('end');
+    expect(obj.result).toBe('ok');
+    expect(obj.summary).toBe('summary text');
+  });
+
+  it('check-stuck: 직전 discover hash와 동일 → stdout "stuck"', async () => {
+    const { appendLoopEvent } = await importLedger();
+    appendLoopEvent(tmpDir, {
+      loop: 'nightly',
+      event: 'discover',
+      discoverHash: 'deadbeef',
+    });
+
+    const result = spawnSync('node', [CLI, 'check-stuck', 'nightly', 'deadbeef'], {
+      encoding: 'utf-8',
+      timeout: 5000,
+      env: { ...process.env, CLAUDE_PROJECT_DIR: tmpDir },
+    });
+    expect(result.status).toBe(0);
+    expect(result.stdout.trim()).toBe('stuck');
+  });
+
+  it('check-stuck: 새 hash → stdout "ok"', async () => {
+    const { appendLoopEvent } = await importLedger();
+    appendLoopEvent(tmpDir, {
+      loop: 'nightly',
+      event: 'end',
+      result: 'ok',
+      discoverHash: 'old-hash',
+    });
+
+    const result = spawnSync('node', [CLI, 'check-stuck', 'nightly', 'new-hash'], {
+      encoding: 'utf-8',
+      timeout: 5000,
+      env: { ...process.env, CLAUDE_PROJECT_DIR: tmpDir },
+    });
+    expect(result.status).toBe(0);
+    expect(result.stdout.trim()).toBe('ok');
+  });
+
+  it('check-stuck: 이력 없으면 "ok"', () => {
+    const result = spawnSync('node', [CLI, 'check-stuck', 'nightly', 'anyhash'], {
+      encoding: 'utf-8',
+      timeout: 5000,
+      env: { ...process.env, CLAUDE_PROJECT_DIR: tmpDir },
+    });
+    expect(result.status).toBe(0);
+    expect(result.stdout.trim()).toBe('ok');
+  });
+
+  it('인수 없이 실행해도 exit 0 (fail-open)', () => {
+    const result = spawnSync('node', [CLI], {
+      encoding: 'utf-8',
+      timeout: 5000,
+      env: { ...process.env, CLAUDE_PROJECT_DIR: tmpDir },
+    });
+    expect(result.status).toBe(0);
+  });
+});

package/hooks/scripts/__tests__/post-edit-dispatcher.test.js

@@ -0,0 +1,139 @@
+/**
+ * post-edit-dispatcher 계약 테스트
+ *
+ * 검증 대상:
+ *   - findings 있음 → stdout에 JSON hookSpecificOutput 출력, exit 0
+ *   - findings 없음 → stdout 없음, exit 0
+ *   - 손상된 stdin에도 exit 0 (fail-open)
+ *   - additionalContext 형식 정확성
+ */
+import { describe, it, expect } from 'vitest';
+import { spawnSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import fs from 'fs';
+import os from 'os';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DISPATCHER = path.resolve(__dirname, '..', 'post-edit-dispatcher.js');
+
+/**
+ * 디스패처를 stdin 페이로드와 함께 실행.
+ * @param {object|string} payload
+ * @param {string} [projectDir]
+ * @returns {{ stdout: string, stderr: string, exitCode: number }}
+ */
+function runDispatcher(payload, projectDir) {
+  const input = typeof payload === 'string' ? payload : JSON.stringify(payload);
+  const env = {
+    ...process.env,
+    CLAUDE_PROJECT_DIR: projectDir || __dirname,
+  };
+  const result = spawnSync('node', [DISPATCHER], {
+    input,
+    encoding: 'utf-8',
+    timeout: 30000,
+    env,
+  });
+  return {
+    stdout: (result.stdout || '').trim(),
+    stderr: (result.stderr || '').trim(),
+    exitCode: result.status ?? 0,
+  };
+}
+
+describe('post-edit-dispatcher: 출력 형식', () => {
+  it('빈 페이로드 → exit 0, stdout 없음 (findings 없음)', () => {
+    const { stdout, exitCode } = runDispatcher({});
+    expect(exitCode).toBe(0);
+    expect(stdout).toBe('');
+  });
+
+  it('손상된 stdin(비JSON) → exit 0 (fail-open)', () => {
+    const { exitCode } = runDispatcher('not-json');
+    expect(exitCode).toBe(0);
+  });
+
+  it('존재하지 않는 파일 경로 → exit 0', () => {
+    const { exitCode } = runDispatcher({
+      tool_name: 'Edit',
+      tool_input: { file_path: '/nonexistent/__vibe_test__.xyz' },
+    });
+    expect(exitCode).toBe(0);
+  });
+});
+
+describe('post-edit-dispatcher: JSON hookSpecificOutput 형식', () => {
+  let tmpDir;
+  let tsFile;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'vibe-dispatcher-test-'));
+    tsFile = path.join(tmpDir, 'test-file.ts');
+  });
+
+  afterEach(() => {
+    try { fs.rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it('P1 이슈가 있는 TS 파일 → JSON hookSpecificOutput 출력', () => {
+    // any 타입이 포함된 TS 파일 생성
+    fs.writeFileSync(tsFile, 'function foo(x: any): any { return x; }\n', 'utf-8');
+
+    const { stdout, exitCode } = runDispatcher({
+      tool_name: 'Edit',
+      tool_input: { file_path: tsFile },
+    }, tmpDir);
+
+    expect(exitCode).toBe(0);
+    if (stdout) {
+      // stdout이 있으면 JSON hookSpecificOutput 형식이어야 함
+      let parsed;
+      try {
+        parsed = JSON.parse(stdout);
+      } catch {
+        // plain text일 수도 있음 (code-check 모듈 로드 실패 시)
+        return;
+      }
+      if (parsed.hookSpecificOutput) {
+        expect(parsed.hookSpecificOutput.hookEventName).toBe('PostToolUse');
+        expect(typeof parsed.hookSpecificOutput.additionalContext).toBe('string');
+        expect(parsed.hookSpecificOutput.additionalContext.length).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  it('findings 있으면 additionalContext에 요약 포함', () => {
+    fs.writeFileSync(tsFile, 'const x: any = 1;\n', 'utf-8');
+
+    const { stdout, exitCode } = runDispatcher({
+      tool_name: 'Edit',
+      tool_input: { file_path: tsFile },
+    }, tmpDir);
+
+    expect(exitCode).toBe(0);
+    if (stdout) {
+      try {
+        const parsed = JSON.parse(stdout);
+        if (parsed.hookSpecificOutput?.additionalContext) {
+          // any 탐지 관련 내용이 포함되어야 함
+          expect(parsed.hookSpecificOutput.additionalContext).toContain('any');
+        }
+      } catch { /* JSON 아닐 수 있음 */ }
+    }
+  });
+});
+
+describe('post-edit-dispatcher: additionalContext JSON 계약', () => {
+  it('JSON 구조가 올바른 hookSpecificOutput 스키마를 따름', () => {
+    // 직접 JSON 생성해 스키마 검증
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'PostToolUse',
+        additionalContext: 'P1 any-type line 1: x: any',
+      },
+    };
+    expect(output.hookSpecificOutput.hookEventName).toBe('PostToolUse');
+    expect(typeof output.hookSpecificOutput.additionalContext).toBe('string');
+  });
+});

package/hooks/scripts/__tests__/pre-tool-guard.test.js

@@ -1,4 +1,4 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { spawnSync } from 'child_process';
 import path from 'path';
 import { fileURLToPath } from 'url';
@@ -406,4 +406,118 @@ describe('pre-tool-guard', () => {
       expect(result.stdout).toContain('Editing sensitive file');
     });
   });
+
+  // ══════════════════════════════════════════════════
+  // REQ-012: 64KB 초과 대용량 페이로드 파싱
+  // hook-context.js readStdinSync가 EOF까지 읽는지 검증
+  // ══════════════════════════════════════════════════
+  describe('large stdin payload (REQ-012: >64KB)', () => {
+    it('should parse tool_name from payload larger than 64KB', () => {
+      // 80KB content field로 페이로드 크기를 64KB 이상으로 만든다
+      const largeContent = 'x'.repeat(80 * 1024);
+      const result = runGuardWithStdin({
+        tool_name: 'Write',
+        tool_input: {
+          file_path: 'src/output.ts',
+          content: largeContent,
+        },
+      });
+      // Write to safe path: no blocking, tool_name parsed correctly (exit 0)
+      expect(result.exitCode).toBe(0);
+    });
+
+    it('should correctly detect dangerous command in large Bash payload', () => {
+      const padding = 'a'.repeat(80 * 1024);
+      const result = runGuardWithStdin({
+        tool_name: 'Bash',
+        tool_input: { command: 'rm -rf /', _padding: padding },
+      });
+      expect(result.exitCode).toBe(2);
+      expect(result.stdout).toContain('BLOCKED');
+    });
+
+    it('should allow safe command in large Bash payload', () => {
+      const padding = 'b'.repeat(80 * 1024);
+      const result = runGuardWithStdin({
+        tool_name: 'Bash',
+        tool_input: { command: 'ls -la', _padding: padding },
+      });
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBe('');
+    });
+  });
+
+  // ══════════════════════════════════════════════════
+  // REQ-013: gh pr create Bash 경로 테스트 게이트
+  // pr-gate-runner 헬퍼를 mock하여 테스트러너 실행 없이 검증
+  // ══════════════════════════════════════════════════
+  describe('gh pr create gate (REQ-013)', () => {
+    it('should allow gh pr create when tests pass (argv mode)', () => {
+      // 테스트 환경에서는 package.json test 스크립트가 존재하지만
+      // 여기서는 실제 테스트를 실행하지 않도록 PROJECT_DIR을 빈 디렉토리로 설정
+      const tmpDir = path.join(path.dirname(fileURLToPath(import.meta.url)), '.vibe');
+      const result = spawnSync(
+        'node',
+        [SCRIPT, 'Bash', 'gh pr create --title "feat" --body "desc"'],
+        {
+          encoding: 'utf-8',
+          timeout: 10000,
+          // 빈 디렉토리 → detectTestCommand가 null 반환 → 통과
+          env: { ...process.env, CLAUDE_PROJECT_DIR: tmpDir },
+        }
+      );
+      const combined = `${result.stdout || ''}${result.stderr || ''}`.trim();
+      // 테스트 커맨드 없음 → PR 허용 (exit 0)
+      expect(result.status).toBe(0);
+      expect(combined).not.toContain('PR-GATE');
+    });
+
+    it('should detect gh pr create in stdin payload', () => {
+      const tmpDir = path.join(path.dirname(fileURLToPath(import.meta.url)), '.vibe');
+      const json = JSON.stringify({
+        tool_name: 'Bash',
+        tool_input: { command: 'gh pr create --title "feat" --body "body"' },
+      });
+      const result = spawnSync(
+        'node',
+        [SCRIPT],
+        {
+          input: json,
+          encoding: 'utf-8',
+          timeout: 10000,
+          env: { ...process.env, CLAUDE_PROJECT_DIR: tmpDir },
+        }
+      );
+      // 테스트 커맨드 없음 → exit 0
+      expect(result.status).toBe(0);
+    });
+
+    it('should NOT trigger gate for unrelated gh commands', () => {
+      const result = runGuard({ args: ['Bash', 'gh issue list'] });
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBe('');
+    });
+
+    it('should NOT trigger gate for gh pr view', () => {
+      const result = runGuard({ args: ['Bash', 'gh pr view 123'] });
+      expect(result.exitCode).toBe(0);
+      expect(result.stdout).toBe('');
+    });
+
+    it('should match gh pr create with flags before/after', () => {
+      // 플래그 포함 명령에도 정규식 매칭이 되어야 함
+      // (테스트 없는 PROJECT_DIR이므로 exit 0)
+      const tmpDir = path.join(path.dirname(fileURLToPath(import.meta.url)), '.vibe');
+      const result = spawnSync(
+        'node',
+        [SCRIPT, 'Bash', 'gh pr create -t "title" -b "body" --draft'],
+        {
+          encoding: 'utf-8',
+          timeout: 10000,
+          env: { ...process.env, CLAUDE_PROJECT_DIR: tmpDir },
+        }
+      );
+      expect(result.status).toBe(0);
+    });
+  });
 });