@su-record/vibe 2.12.5 → 2.13.0

package/hooks/scripts/__tests__/utils-npm-root.test.js

@@ -0,0 +1,98 @@
+/**
+ * utils.js — getGlobalNpmPath() 파일 캐시 테스트
+ *
+ * 검증 범위:
+ *  - L2 파일 캐시 히트 (TTL 내)
+ *  - L2 파일 캐시 만료 (TTL 초과)
+ *  - 캐시 파일 손상 시 fail-open (execSync 재실행)
+ *  - 캐시 파일 없음 시 execSync 실행 후 파일 저장
+ *
+ * 격리 전략: 각 테스트는 별도 임시 디렉토리를 캐시 경로로 사용한다.
+ * NPM_ROOT_CACHE_FILE 환경 변수를 통해 경로를 주입한다.
+ */
+import { describe, it, expect } from 'vitest';
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const UTILS_PATH = path.resolve(__dirname, '..', 'utils.js');
+
+function makeTempCacheFile() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'vibe-npm-root-test-'));
+  return path.join(dir, 'npm-root.json');
+}
+
+/**
+ * utils.js 의 getGlobalNpmPath() 를 별도 프로세스에서 실행.
+ * VIBE_NPM_ROOT_CACHE_FILE 환경 변수로 캐시 파일 경로를 주입한다.
+ */
+function runGetNpmRoot(cacheFilePath) {
+  return spawnSync('node', ['--input-type=module', '--eval',
+    `import { getGlobalNpmPath } from '${UTILS_PATH}';
+     process.stdout.write(getGlobalNpmPath() || '');`
+  ], {
+    encoding: 'utf-8',
+    timeout: 10000,
+    env: {
+      ...process.env,
+      VIBE_NPM_ROOT_CACHE_FILE: cacheFilePath,
+    },
+  });
+}
+
+describe('utils.js — getGlobalNpmPath() npm-root 파일 캐시', () => {
+  it('캐시 파일 없으면 execSync 실행 후 캐시 파일 생성', () => {
+    const cacheFile = makeTempCacheFile();
+    // 캐시 파일이 없는 상태에서 시작
+    expect(fs.existsSync(cacheFile)).toBe(false);
+
+    const result = runGetNpmRoot(cacheFile);
+    expect(result.status).toBe(0);
+    expect(result.stdout.trim()).toBeTruthy();
+
+    // 캐시 파일이 생성되어야 함
+    expect(fs.existsSync(cacheFile)).toBe(true);
+    const cached = JSON.parse(fs.readFileSync(cacheFile, 'utf-8'));
+    expect(cached.npmRoot).toBe(result.stdout.trim());
+    expect(typeof cached.savedAt).toBe('number');
+  });
+
+  it('유효한 캐시 파일이 있으면 execSync 없이 캐시값 반환', () => {
+    const cacheFile = makeTempCacheFile();
+    const fakeRoot = '/fake/npm/root/for/test';
+    // 유효한 캐시 미리 작성
+    fs.writeFileSync(cacheFile, JSON.stringify({ npmRoot: fakeRoot, savedAt: Date.now() }), { mode: 0o600 });
+
+    const result = runGetNpmRoot(cacheFile);
+    expect(result.status).toBe(0);
+    expect(result.stdout.trim()).toBe(fakeRoot);
+  });
+
+  it('TTL 초과 캐시는 무효화 — execSync 재실행', () => {
+    const cacheFile = makeTempCacheFile();
+    const staleRoot = '/stale/path/should/not/be/used';
+    const expiredAt = Date.now() - (25 * 60 * 60 * 1000); // 25시간 전
+    fs.writeFileSync(cacheFile, JSON.stringify({ npmRoot: staleRoot, savedAt: expiredAt }), { mode: 0o600 });
+
+    const result = runGetNpmRoot(cacheFile);
+    expect(result.status).toBe(0);
+    // stale 값이 아닌 실제 npm root 가 반환되어야 함
+    expect(result.stdout.trim()).not.toBe(staleRoot);
+    expect(result.stdout.trim()).toBeTruthy();
+  });
+
+  it('손상된 캐시 파일 — fail-open (execSync 실행)', () => {
+    const cacheFile = makeTempCacheFile();
+    fs.writeFileSync(cacheFile, '{ broken json :::');
+
+    const result = runGetNpmRoot(cacheFile);
+    expect(result.status).toBe(0);
+    expect(result.stdout.trim()).toBeTruthy(); // 실제 경로 반환
+    // 손상된 파일 때문에 프로세스가 crash 나지 않아야 함
+    const stderr = result.stderr || '';
+    expect(stderr).not.toMatch(/^Error:/m);
+  });
+});

package/hooks/scripts/auto-commit.js

@@ -13,12 +13,38 @@
  *   으로 롤백 가능. 최근 5개만 유지.
  */
 import { execSync } from 'child_process';
-import { PROJECT_DIR, readProjectConfig } from './utils.js';
+import { PROJECT_DIR, readProjectConfig, logHookDecision } from './utils.js';
+import { readLedger } from './lib/run-ledger.js';
 
 // Opt-in 가드 — 명시적으로 켜지 않았으면 아무것도 하지 않는다.
 const __autoCommitCfg = readProjectConfig();
 if (__autoCommitCfg?.hooks?.['auto-commit']?.enabled !== true) process.exit(0);
 
+// verify 게이트 — vibe.run 세션이 시작됐으면 verifyPassed가 true이고
+// verifyAt > runStarted 인 경우에만 커밋을 허용한다.
+const __ledger = readLedger(PROJECT_DIR);
+if (__ledger && __ledger.runStarted) {
+  const verifyOk = __ledger.verifyPassed === true
+    && __ledger.verifyAt
+    && __ledger.verifyAt > __ledger.runStarted;
+  if (!verifyOk) {
+    const reason = !__ledger.verifyPassed
+      ? 'vibe.verify not passed — run /vibe.verify before committing'
+      : 'verifyAt is not after runStarted — re-run /vibe.verify';
+    logHookDecision('auto-commit', 'git-commit', 'block', reason);
+    process.stderr.write(`[auto-commit] SKIP: ${reason}\n`);
+    process.exit(0);
+  }
+}
+
+// verifyRequired 게이트 — PostToolUse에서 P1 이슈가 발견되어 verify가 요구됨.
+if (__ledger && __ledger.verifyRequired === true) {
+  const reason = `P1 issue requires verification: ${__ledger.verifyRequiredReason || 'see code-check findings'}`;
+  logHookDecision('auto-commit', 'git-commit', 'block', reason);
+  process.stderr.write(`[auto-commit] SKIP: ${reason}\n`);
+  process.exit(0);
+}
+
 const PROTECTED_BRANCHES = ['main', 'master', 'develop', 'production'];
 const MAX_FILES_IN_MSG = 5;
 const MAX_CHECKPOINTS = 5;

package/hooks/scripts/auto-format.js

@@ -4,19 +4,33 @@
  * 프로젝트에 설치된 포매터를 감지하고 수정된 파일에 자동 실행.
  * Prettier(JS/TS), Black(Python), gofmt(Go) 지원.
  * 200ms 이내 완료 목표 — 단일 파일만 처리.
+ *
+ * 변경 감지: mtime 비교로 prettier가 실제 파일을 수정했는지 판단.
+ * 수정된 경우 finding을 반환 — 디스패처가 additionalContext에 포함시킨다.
  */
-import { execSync } from 'child_process';
-import { existsSync } from 'fs';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { existsSync, statSync } from 'fs';
 import path from 'path';
 import { PROJECT_DIR } from './utils.js';
+import { buildCliCtx, isDirectRun } from './lib/hook-context.js';
+
+// WHY async execFile (not execSync): in-process 디스패처에서 다른 step과
+// Promise.all로 병렬 실행되므로, 동기 실행은 이벤트 루프를 막아 체인을 직렬화시킨다.
+const execFileAsync = promisify(execFile);
 
 const CODE_EXT_RE = /\.(ts|tsx|js|jsx|mjs|cjs|css|scss|json|md|html|vue|svelte)$/;
 const PYTHON_EXT_RE = /\.py$/;
 const GO_EXT_RE = /\.go$/;
+const FORMAT_TIMEOUT_MS = 5000;
 
-function getFilePath() {
-  const input = JSON.parse(process.env.TOOL_INPUT || '{}');
-  return input.file_path || input.path || '';
+function getFilePath(ctx) {
+  try {
+    const input = JSON.parse(ctx.toolInput || '{}');
+    return input.file_path || input.path || '';
+  } catch {
+    return '';
+  }
 }
 
 // PATH 직접 스캔 — `which` execSync는 매 파일 저장마다 자식 프로세스를 동기
@@ -37,33 +51,84 @@ function hasPrettier() {
   return existsSync(path.join(PROJECT_DIR, 'node_modules', '.bin', 'prettier'));
 }
 
-function formatFile(filePath) {
+/**
+ * mtimeMs 읽기 — stat 실패 시 0 반환 (fail-open).
+ * @param {string} resolvedPath
+ * @returns {number}
+ */
+function getMtime(resolvedPath) {
+  try {
+    return statSync(resolvedPath).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * 파일 포맷 실행. 실제 변경이 발생했으면 finding 문자열을 반환.
+ * @param {string} filePath
+ * @returns {Promise<string|null>} finding or null
+ */
+async function formatFile(filePath) {
   const resolved = path.resolve(filePath);
-  if (!existsSync(resolved)) return;
+  if (!existsSync(resolved)) return null;
 
   try {
     if (CODE_EXT_RE.test(filePath) && hasPrettier()) {
-      execSync(`npx prettier --write "${resolved}"`, {
+      const mtimeBefore = getMtime(resolved);
+      await execFileAsync('npx', ['prettier', '--write', resolved], {
         cwd: PROJECT_DIR,
-        stdio: 'ignore',
-        timeout: 5000,
+        timeout: FORMAT_TIMEOUT_MS,
+        // Windows에서 npx는 npx.cmd — shell 없이는 execFile이 찾지 못함
+        shell: process.platform === 'win32',
       });
-      console.log(`[AUTO-FORMAT] prettier: ${path.basename(resolved)}`);
+      const mtimeAfter = getMtime(resolved);
+      if (mtimeAfter > mtimeBefore) {
+        return `auto-format reformatted ${path.basename(resolved)} — re-read before further edits to avoid stale old_string`;
+      }
     } else if (PYTHON_EXT_RE.test(filePath) && hasBin('black')) {
-      execSync(`black --quiet "${resolved}"`, { stdio: 'ignore', timeout: 5000 });
-      console.log(`[AUTO-FORMAT] black: ${path.basename(resolved)}`);
+      const mtimeBefore = getMtime(resolved);
+      await execFileAsync('black', ['--quiet', resolved], { timeout: FORMAT_TIMEOUT_MS });
+      const mtimeAfter = getMtime(resolved);
+      if (mtimeAfter > mtimeBefore) {
+        return `auto-format reformatted ${path.basename(resolved)} — re-read before further edits to avoid stale old_string`;
+      }
     } else if (GO_EXT_RE.test(filePath) && hasBin('gofmt')) {
-      execSync(`gofmt -w "${resolved}"`, { stdio: 'ignore', timeout: 5000 });
-      console.log(`[AUTO-FORMAT] gofmt: ${path.basename(resolved)}`);
+      const mtimeBefore = getMtime(resolved);
+      await execFileAsync('gofmt', ['-w', resolved], { timeout: FORMAT_TIMEOUT_MS });
+      const mtimeAfter = getMtime(resolved);
+      if (mtimeAfter > mtimeBefore) {
+        return `auto-format reformatted ${path.basename(resolved)} — re-read before further edits to avoid stale old_string`;
+      }
     }
   } catch {
     // Format failure should never block — silently continue
   }
+  return null;
+}
+
+/**
+ * in-process 진입점 — 포맷 실행. finding 문자열 배열 반환.
+ * @param {{ toolInput: string }} ctx
+ * @returns {Promise<{ exitCode: number, findings: string[] }>}
+ */
+export async function run(ctx) {
+  const findings = [];
+  try {
+    const filePath = getFilePath(ctx);
+    if (filePath) {
+      const finding = await formatFile(filePath);
+      if (finding) findings.push(finding);
+    }
+  } catch {
+    // Silent fail
+  }
+  return { exitCode: 0, findings };
 }
 
-try {
-  const filePath = getFilePath();
-  if (filePath) formatFile(filePath);
-} catch {
-  // Silent fail
+// standalone CLI 모드
+if (isDirectRun(import.meta.url)) {
+  const { exitCode, findings } = await run(buildCliCtx());
+  if (findings.length > 0) process.stdout.write(findings.join('\n') + '\n');
+  process.exit(exitCode);
 }

package/hooks/scripts/auto-test.js

@@ -3,20 +3,43 @@
  *
  * 수정된 파일에 대응하는 테스트 파일을 찾아 실행.
  * 실패 시 마지막 5줄만 출력해서 context window 오염 방지.
- * exit 0 항상 — 차단하지 않고 에이전트에게 결과만 전달.
+ *
+ * debounce 지원: autoTest.mode='debounce'(기본) | 'always' | 'off' via .vibe/config.json
+ *   debounce 모드: 동일 테스트 파일을 DEBOUNCE_COOLDOWN_MS(120s) 내에
+ *   소스 변경 없이 재실행 스킵.
+ *
+ * findings 반환 구조 (디스패처가 additionalContext에 주입).
  */
-import { execSync } from 'child_process';
-import { existsSync } from 'fs';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { createHash } from 'crypto';
 import path from 'path';
-import { PROJECT_DIR } from './utils.js';
+import { PROJECT_DIR, readProjectConfig } from './utils.js';
+import { buildCliCtx, isDirectRun } from './lib/hook-context.js';
+
+// WHY async execFile (not execSync): in-process 디스패처에서 다른 step과
+// Promise.all로 병렬 실행되므로, 60초 동기 실행은 체인 전체를 직렬화시킨다.
+const execFileAsync = promisify(execFile);
 
 const CODE_EXT_RE = /\.(ts|tsx|js|jsx)$/;
 const TEST_SUFFIXES = ['.test.', '.spec.'];
 const MAX_OUTPUT_LINES = 5;
+const TEST_TIMEOUT_MS = 60000;
 
-function getFilePath() {
-  const input = JSON.parse(process.env.TOOL_INPUT || '{}');
-  return input.file_path || input.path || '';
+/** debounce 쿨다운 — 동일 테스트 + 동일 소스 해시에 대해 스킵하는 시간(ms) */
+const DEBOUNCE_COOLDOWN_MS = 120_000;
+
+/** debounce 상태 파일 경로 */
+const DEBOUNCE_STATE_FILE = path.join(PROJECT_DIR, '.vibe', 'metrics', 'auto-test-state.json');
+
+function getFilePath(ctx) {
+  try {
+    const input = JSON.parse(ctx.toolInput || '{}');
+    return input.file_path || input.path || '';
+  } catch {
+    return '';
+  }
 }
 
 function isTestFile(filePath) {
@@ -46,36 +69,163 @@ function hasJest() {
   return existsSync(path.join(PROJECT_DIR, 'node_modules', '.bin', 'jest'));
 }
 
-try {
-  const filePath = getFilePath();
-  if (!filePath || !CODE_EXT_RE.test(filePath)) process.exit(0);
-
-  const testFile = isTestFile(filePath) ? filePath : findTestFile(filePath);
-  if (!testFile) process.exit(0);
-
-  const relPath = path.relative(PROJECT_DIR, testFile);
-  let cmd = '';
-  if (hasVitest()) {
-    cmd = `npx vitest run "${relPath}" --reporter=verbose`;
-  } else if (hasJest()) {
-    cmd = `npx jest "${relPath}" --no-coverage`;
-  } else {
-    process.exit(0);
+/**
+ * autoTest.mode 설정 읽기 — 기본 'debounce'.
+ * @returns {'debounce'|'always'|'off'}
+ */
+function getTestMode() {
+  try {
+    const cfg = readProjectConfig();
+    const mode = cfg?.autoTest?.mode;
+    if (mode === 'always' || mode === 'off' || mode === 'debounce') return mode;
+  } catch { /* ignore */ }
+  return 'debounce';
+}
+
+/**
+ * 파일 내용 SHA-256 해시 (앞 16자만 사용). 파일 없으면 빈 문자열.
+ * @param {string} filePath
+ * @returns {string}
+ */
+function fileHash(filePath) {
+  try {
+    const content = readFileSync(filePath, 'utf-8');
+    return createHash('sha256').update(content).digest('hex').slice(0, 16);
+  } catch {
+    return '';
   }
+}
+
+/**
+ * debounce 상태 파일 읽기. fail-open → 빈 객체.
+ * @returns {Record<string, { lastRun: number, srcHash: string }>}
+ */
+function readDebounceState() {
+  try {
+    if (existsSync(DEBOUNCE_STATE_FILE)) {
+      return JSON.parse(readFileSync(DEBOUNCE_STATE_FILE, 'utf-8'));
+    }
+  } catch { /* ignore */ }
+  return {};
+}
+
+/**
+ * debounce 상태 파일 쓰기. fail-open.
+ * @param {Record<string, { lastRun: number, srcHash: string }>} state
+ */
+function writeDebounceState(state) {
+  try {
+    mkdirSync(path.dirname(DEBOUNCE_STATE_FILE), { recursive: true });
+    writeFileSync(DEBOUNCE_STATE_FILE, JSON.stringify(state, null, 2), 'utf-8');
+  } catch { /* fail-open */ }
+}
+
+/**
+ * debounce 체크: testFile을 스킵해야 하면 true.
+ * @param {string} testFile — 절대 경로
+ * @param {string} srcFile — 절대 경로 (소스 파일, 테스트가 아닌 경우)
+ * @returns {boolean}
+ */
+function shouldSkipDebounce(testFile, srcFile) {
+  try {
+    const state = readDebounceState();
+    const entry = state[testFile];
+    if (!entry) return false;
+
+    const now = Date.now();
+    const elapsed = now - entry.lastRun;
+    if (elapsed > DEBOUNCE_COOLDOWN_MS) return false;
+
+    const currentHash = fileHash(srcFile);
+    if (currentHash !== entry.srcHash) return false;
+
+    return true; // 쿨다운 내 + 소스 미변경 → 스킵
+  } catch {
+    return false; // fail-open
+  }
+}
+
+/**
+ * debounce 상태 업데이트.
+ * @param {string} testFile
+ * @param {string} srcFile
+ */
+function updateDebounceState(testFile, srcFile) {
+  try {
+    const state = readDebounceState();
+    state[testFile] = {
+      lastRun: Date.now(),
+      srcHash: fileHash(srcFile),
+    };
+    writeDebounceState(state);
+  } catch { /* fail-open */ }
+}
+
+/**
+ * in-process 진입점 — 테스트 실행. findings 반환.
+ * @param {{ toolInput: string }} ctx
+ * @returns {Promise<{ exitCode: number, findings: string[] }>}
+ */
+export async function run(ctx) {
+  const findings = [];
+  try {
+    const filePath = getFilePath(ctx);
+    if (!filePath || !CODE_EXT_RE.test(filePath)) return { exitCode: 0, findings };
+
+    const mode = getTestMode();
+    if (mode === 'off') return { exitCode: 0, findings };
+
+    const srcFile = path.resolve(filePath);
+    const testFile = isTestFile(filePath) ? srcFile : findTestFile(srcFile);
+    if (!testFile) return { exitCode: 0, findings };
+
+    // debounce 모드: 스킵 여부 확인
+    if (mode === 'debounce') {
+      const skipSrc = isTestFile(filePath) ? testFile : srcFile;
+      if (shouldSkipDebounce(testFile, skipSrc)) {
+        // 스팸 방지: 스킵 시 finding 없음 (조용히)
+        return { exitCode: 0, findings };
+      }
+    }
+
+    const relPath = path.relative(PROJECT_DIR, testFile);
+    let args = null;
+    if (hasVitest()) {
+      args = ['vitest', 'run', relPath, '--reporter=verbose'];
+    } else if (hasJest()) {
+      args = ['jest', relPath, '--no-coverage'];
+    } else {
+      return { exitCode: 0, findings };
+    }
+
+    // debounce 상태 업데이트 (실행 전)
+    if (mode === 'debounce') {
+      const skipSrc = isTestFile(filePath) ? testFile : srcFile;
+      updateDebounceState(testFile, skipSrc);
+    }
+
+    const { stdout } = await execFileAsync('npx', args, {
+      cwd: PROJECT_DIR,
+      timeout: TEST_TIMEOUT_MS,
+      // Windows에서 npx는 npx.cmd — shell 없이는 execFile이 찾지 못함
+      shell: process.platform === 'win32',
+    });
+
+    const tail = stdout.trim().split('\n').slice(-MAX_OUTPUT_LINES).join('\n');
+    findings.push(`[AUTO-TEST] PASSED: ${relPath}\n${tail}`);
+  } catch (err) {
+    const stderr = err.stderr ? err.stderr.toString() : '';
+    const stdout = err.stdout ? err.stdout.toString() : '';
+    const combined = (stdout + '\n' + stderr).trim();
+    const tail = combined.split('\n').slice(-MAX_OUTPUT_LINES).join('\n');
+    findings.push(`[AUTO-TEST] FAILED\n${tail}`);
+  }
+  return { exitCode: 0, findings };
+}
 
-  console.log(`[AUTO-TEST] Running: ${relPath}`);
-  const output = execSync(cmd, {
-    cwd: PROJECT_DIR,
-    stdio: ['ignore', 'pipe', 'pipe'],
-    timeout: 60000,
-  }).toString();
-
-  const tail = output.trim().split('\n').slice(-MAX_OUTPUT_LINES).join('\n');
-  console.log(`[AUTO-TEST] PASSED\n${tail}`);
-} catch (err) {
-  const stderr = err.stderr ? err.stderr.toString() : '';
-  const stdout = err.stdout ? err.stdout.toString() : '';
-  const combined = (stdout + '\n' + stderr).trim();
-  const tail = combined.split('\n').slice(-MAX_OUTPUT_LINES).join('\n');
-  console.log(`[AUTO-TEST] FAILED\n${tail}`);
+// standalone CLI 모드
+if (isDirectRun(import.meta.url)) {
+  const { exitCode, findings } = await run(buildCliCtx());
+  if (findings.length > 0) process.stdout.write(findings.join('\n') + '\n');
+  process.exit(exitCode);
 }