@su-record/vibe 2.12.5 → 2.14.0

package/hooks/scripts/__tests__/code-check-detectors.test.js

@@ -0,0 +1,155 @@
+/**
+ * code-check.js 정밀 탐지기 테스트
+ *
+ * 검증 대상:
+ *   - any 탐지: 단어 경계 기반 (false positive: 'company', 'anything' 등)
+ *   - any 탐지: `: any`, `as any`, `@ts-ignore`, `<any>` (true positive)
+ *   - console.log 정책: 경로별 허용/차단
+ *   - run-ledger verifyRequired round-trip + pass 시 clear
+ *   - auto-commit verifyRequired skip
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { fileURLToPath } from 'url';
+import path from 'path';
+import fs from 'fs';
+import os from 'os';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// ─── any 탐지 정규식 (code-check.js와 동일) ──────────────────────────────
+const P1_DETECTORS = [
+  /:\s*any\b/,
+  /\bas\s+any\b/,
+  /<any[\s,>]/,
+  /@ts-ignore\b/,
+];
+
+function detectsAny(line) {
+  return P1_DETECTORS.some(re => re.test(line));
+}
+
+describe('any 탐지: true positive', () => {
+  it(': any — 타입 어노테이션', () => {
+    expect(detectsAny('function foo(x: any): void {}')).toBe(true);
+  });
+
+  it(': any — 공백 포함', () => {
+    expect(detectsAny('const x:  any = 1;')).toBe(true);
+  });
+
+  it('as any — 타입 캐스트', () => {
+    expect(detectsAny('const y = x as any;')).toBe(true);
+  });
+
+  it('<any> — 제네릭', () => {
+    expect(detectsAny('const z = foo<any>();')).toBe(true);
+  });
+
+  it('<any, — 제네릭 다중 파라미터', () => {
+    expect(detectsAny('const m = new Map<any, string>();')).toBe(true);
+  });
+
+  it('@ts-ignore — 라인 직전', () => {
+    expect(detectsAny('// @ts-ignore')).toBe(true);
+  });
+
+  it('@ts-ignore — 인라인', () => {
+    expect(detectsAny('  @ts-ignore  ')).toBe(true);
+  });
+});
+
+describe('any 탐지: false negative (탐지 안 됨)', () => {
+  it('"company" 단어 포함 — 탐지 안 됨', () => {
+    expect(detectsAny('const company = "Acme";')).toBe(false);
+  });
+
+  it('"anything" 식별자 — 탐지 안 됨', () => {
+    expect(detectsAny('if (anything) return;')).toBe(false);
+  });
+
+  it('"manyThings" — 탐지 안 됨', () => {
+    expect(detectsAny('const manyThings = [];')).toBe(false);
+  });
+
+  it('"fantasy" — 탐지 안 됨', () => {
+    expect(detectsAny('const fantasy = "world";')).toBe(false);
+  });
+
+  it('문자열 리터럴 "any" — 정규식은 문자열 내부도 매칭할 수 있음 (알려진 한계, 문서화)', () => {
+    // NOTE: 현재 구현은 문자열 내 "any"를 완전히 제외하지 않음.
+    // 실제 코드에서 ": any" 패턴이 문자열로 존재하는 경우는 극히 드물어 허용.
+    // 이 테스트는 동작을 문서화하는 것이 목적.
+    const result = detectsAny('const msg = "type: any is bad";');
+    // 문자열 내 ": any" 도 탐지될 수 있음 — false positive지만 드문 케이스
+    expect(typeof result).toBe('boolean');
+  });
+});
+
+// ─── console.log 경로 정책 ────────────────────────────────────────────────
+describe('console.log 허용 경로 정책', () => {
+  // 허용 glob 패턴 (code-check.js 기본값과 동일)
+  const DEFAULT_ALLOW_GLOBS = [
+    'hooks/scripts/**',
+    'scripts/**',
+    '**/cli/**',
+    '**/*.test.*',
+    '**/*.spec.*',
+    '**/__tests__/**',
+  ];
+
+  function globToRegExp(glob) {
+    const normalized = glob.replace(/\\/g, '/');
+    let out = '';
+    for (let i = 0; i < normalized.length; i++) {
+      const c = normalized[i];
+      if (c === '*') {
+        if (normalized[i + 1] === '*') {
+          out += '.*';
+          i++;
+          if (normalized[i + 1] === '/') i++;
+        } else {
+          out += '[^/]*';
+        }
+      } else if (c === '?') {
+        out += '[^/]';
+      } else if ('.+^$()|{}[]\\'.includes(c)) {
+        out += '\\' + c;
+      } else {
+        out += c;
+      }
+    }
+    return new RegExp('^' + out + '$');
+  }
+
+  function isConsoleAllowed(relPath) {
+    return DEFAULT_ALLOW_GLOBS.some(g => globToRegExp(g).test(relPath));
+  }
+
+  it('hooks/scripts/auto-test.js → 허용', () => {
+    expect(isConsoleAllowed('hooks/scripts/auto-test.js')).toBe(true);
+  });
+
+  it('hooks/scripts/lib/run-ledger.js → 허용', () => {
+    expect(isConsoleAllowed('hooks/scripts/lib/run-ledger.js')).toBe(true);
+  });
+
+  it('src/cli/index.ts → 허용 (**/cli/**)', () => {
+    expect(isConsoleAllowed('src/cli/index.ts')).toBe(true);
+  });
+
+  it('src/tools/foo.test.ts → 허용 (**/*.test.*)', () => {
+    expect(isConsoleAllowed('src/tools/foo.test.ts')).toBe(true);
+  });
+
+  it('src/__tests__/bar.ts → 허용 (**/__tests__/**)', () => {
+    expect(isConsoleAllowed('src/__tests__/bar.ts')).toBe(true);
+  });
+
+  it('src/tools/convention/validateCodeQuality.ts → 차단', () => {
+    expect(isConsoleAllowed('src/tools/convention/validateCodeQuality.ts')).toBe(false);
+  });
+
+  it('src/infra/orchestrator/index.ts → 차단', () => {
+    expect(isConsoleAllowed('src/infra/orchestrator/index.ts')).toBe(false);
+  });
+});

package/hooks/scripts/__tests__/dispatcher-inprocess.test.js

@@ -0,0 +1,99 @@
+/**
+ * in-process 디스패처 외부 계약 테스트
+ *
+ * SPEC: .vibe/specs/hook-dispatcher-inprocess.md
+ * 디스패처를 Claude Code와 동일하게 CLI로 spawn하여 검증한다 —
+ * 내부 구현(in-process)이 아니라 외부 계약(exit code, stdout 주입)이 대상.
+ */
+import { describe, it, expect } from 'vitest';
+import { execFileSync } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PRE_DISPATCHER = path.resolve(__dirname, '..', 'pre-tool-dispatcher.js');
+const POST_DISPATCHER = path.resolve(__dirname, '..', 'post-edit-dispatcher.js');
+
+/**
+ * 디스패처를 stdin 페이로드와 함께 실행. { stdout, exitCode } 반환.
+ */
+function runDispatcher(script, args, payload) {
+  const input = typeof payload === 'string' ? payload : JSON.stringify(payload);
+  try {
+    const stdout = execFileSync('node', [script, ...args], {
+      encoding: 'utf-8',
+      input,
+      timeout: 15000,
+      // scope.json이 없는 격리된 cwd에서 실행 (scope-guard no-op 보장)
+      env: { ...process.env, CLAUDE_PROJECT_DIR: __dirname },
+    });
+    return { stdout: stdout.trim(), exitCode: 0 };
+  } catch (err) {
+    return { stdout: (err.stdout || '').trim(), exitCode: err.status };
+  }
+}
+
+describe('pre-tool-dispatcher (in-process)', () => {
+  it('AC-1: 위험 Bash 명령은 exit 2로 deny', () => {
+    const { exitCode } = runDispatcher(PRE_DISPATCHER, ['Bash'], {
+      tool_name: 'Bash',
+      tool_input: { command: 'rm -rf /' },
+    });
+    expect(exitCode).toBe(2);
+  });
+
+  it('AC-2: sentinel 경로 Edit은 exit 2 + stdout에 block JSON 주입', () => {
+    // 실제 sentinel 경로: src/infra/lib/evolution/ (autonomy/ 는 팬텀 경로였음)
+    const { stdout, exitCode } = runDispatcher(PRE_DISPATCHER, ['Edit'], {
+      tool_name: 'Edit',
+      tool_input: { file_path: 'src/infra/lib/evolution/GuardAnalyzer.ts', old_string: 'a', new_string: 'b' },
+    });
+    expect(exitCode).toBe(2);
+    expect(stdout).toContain('"decision":"block"');
+  });
+
+  it('AC-3: 안전한 Bash 명령은 exit 0', () => {
+    const { exitCode } = runDispatcher(PRE_DISPATCHER, ['Bash'], {
+      tool_name: 'Bash',
+      tool_input: { command: 'ls -la' },
+    });
+    expect(exitCode).toBe(0);
+  });
+
+  it('AC-3: 안전한 Edit은 exit 0 (scope.json 없음 → scope-guard no-op)', () => {
+    const { exitCode } = runDispatcher(PRE_DISPATCHER, ['Edit'], {
+      tool_name: 'Edit',
+      tool_input: { file_path: 'src/cli/index.ts', old_string: 'a', new_string: 'b' },
+    });
+    expect(exitCode).toBe(0);
+  });
+
+  it('AC-2 변형: 위험 명령이 sentinel 경로를 노리면 sentinel-guard가 차단', () => {
+    // 실제 sentinel 경로: src/infra/lib/evolution/
+    const { exitCode } = runDispatcher(PRE_DISPATCHER, ['Bash'], {
+      tool_name: 'Bash',
+      tool_input: { command: 'rm -rf src/infra/lib/evolution/' },
+    });
+    expect(exitCode).toBe(2);
+  });
+});
+
+describe('post-edit-dispatcher (in-process)', () => {
+  it('AC-4: 손상된 stdin(비JSON)에도 exit 0 (fail-open)', () => {
+    const { exitCode } = runDispatcher(POST_DISPATCHER, [], 'not-json');
+    expect(exitCode).toBe(0);
+  });
+
+  it('AC-4: 빈 페이로드에도 exit 0', () => {
+    const { exitCode } = runDispatcher(POST_DISPATCHER, [], {});
+    expect(exitCode).toBe(0);
+  });
+
+  it('존재하지 않는 파일 경로 페이로드에도 exit 0 (step 내부 격리)', () => {
+    const { exitCode } = runDispatcher(POST_DISPATCHER, [], {
+      tool_name: 'Edit',
+      tool_input: { file_path: '/nonexistent/__vibe_test__.xyz' },
+    });
+    expect(exitCode).toBe(0);
+  });
+});

package/hooks/scripts/__tests__/keyword-detector.test.js

@@ -27,28 +27,30 @@ function runDetector(text) {
 // ══════════════════════════════════════════════════
 describe('keyword-detector', () => {
   describe('ralph keyword', () => {
-    it('should detect ralph keyword', () => {
+    it('should detect ralph keyword and emit deprecation hint', () => {
       const result = runDetector('implement the login feature ralph');
-      expect(result.stdout).toContain('[RALPH MODE]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('deprecated');
       expect(result.stdout).toContain('persistence');
     });
 
     it('should detect ralph case-insensitively', () => {
       const result = runDetector('RALPH fix all the bugs');
-      expect(result.stdout).toContain('[RALPH MODE]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('deprecated');
     });
   });
 
   describe('ultrawork keyword', () => {
-    it('should detect ultrawork keyword', () => {
+    it('should detect ultrawork keyword and emit automationLevel banner', () => {
       const result = runDetector('ultrawork build the entire app');
-      expect(result.stdout).toContain('[ULTRAWORK MODE]');
+      expect(result.stdout).toContain('[ULTRAWORK]');
       expect(result.stdout).toContain('parallel');
     });
 
     it('should detect ulw alias', () => {
       const result = runDetector('ulw refactor the codebase');
-      expect(result.stdout).toContain('[ULTRAWORK MODE]');
+      expect(result.stdout).toContain('[ULTRAWORK]');
     });
 
     it('should detect Korean alias when word boundary matches', () => {
@@ -74,28 +76,32 @@ describe('keyword-detector', () => {
   // strict 키워드(일상어): 명령 끝 위치 또는 --flag 에서만 발동.
   // 일상 영어("please verify", "quick question")의 오탐을 막기 위함.
   describe('verify keyword (strict)', () => {
-    it('should detect verify at command tail', () => {
+    it('should detect verify at command tail and emit deprecation hint', () => {
       const result = runDetector('make the implementation correct, verify');
-      expect(result.stdout).toContain('[VERIFY MODE]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('deprecated');
       expect(result.stdout).toContain('verification');
     });
 
     it('should detect --verify flag', () => {
       const result = runDetector('fix the bug --verify');
-      expect(result.stdout).toContain('[VERIFY MODE]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('deprecated');
     });
   });
 
   describe('quick keyword (strict)', () => {
-    it('should detect quick at command tail', () => {
+    it('should detect quick at command tail and emit --max-iter 1 hint', () => {
       const result = runDetector('fix this typo quick');
-      expect(result.stdout).toContain('[QUICK MODE]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('--max-iter 1');
       expect(result.stdout).toContain('fast');
     });
 
     it('should detect --quick flag', () => {
       const result = runDetector('build the payment API --quick');
-      expect(result.stdout).toContain('[QUICK MODE]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('--max-iter 1');
     });
   });
 
@@ -140,17 +146,19 @@ describe('keyword-detector', () => {
   // Keyword combinations / synergies
   // ══════════════════════════════════════════════════
   describe('keyword combinations', () => {
-    it('should detect ralph+ultrawork synergy', () => {
+    it('should detect ralph+ultrawork synergy and emit deprecation hint', () => {
       const result = runDetector('ralph ultrawork build everything from scratch');
-      expect(result.stdout).toContain('[RALPH+ULTRAWORK]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('deprecated');
       expect(result.stdout).toContain('persistence');
       expect(result.stdout).toContain('parallel');
     });
 
-    it('should detect ralph+verify synergy', () => {
+    it('should detect ralph+verify synergy and emit deprecation hint', () => {
       // verify is strict → use --verify flag (ralph stays bare)
       const result = runDetector('ralph fix each step --verify');
-      expect(result.stdout).toContain('[RALPH+VERIFY]');
+      expect(result.stdout).toContain('[vibe]');
+      expect(result.stdout).toContain('deprecated');
     });
 
     it('should output both keywords when no synergy key matches sorted order', () => {
@@ -158,7 +166,7 @@ describe('keyword-detector', () => {
       // sorts keywords alphabetically → tries 'explore+ultrawork' which has no match.
       // So individual outputs are emitted instead. explore is strict → --explore.
       const result = runDetector('ultrawork analyze the entire project --explore');
-      expect(result.stdout).toContain('[ULTRAWORK MODE]');
+      expect(result.stdout).toContain('[ULTRAWORK]');
       expect(result.stdout).toContain('[EXPLORE MODE]');
       expect(result.stdout).toContain('[FLAGS]');
     });
@@ -224,7 +232,7 @@ describe('keyword-detector', () => {
     });
 
     it('should merge flags from multiple keywords', () => {
-      // quick is strict → place at command tail
+      // quick is strict → place at command tail; ralph stays bare
       const result = runDetector('ralph finish this quick');
       expect(result.stdout).toContain('[FLAGS]');
       expect(result.stdout).toContain('persistence');