@su-record/vibe 2.9.38 → 2.9.40

package/hooks/scripts/__tests__/step-counter.test.js

@@ -0,0 +1,358 @@
+/**
+ * step-counter.js — Phase 1 + Phase 2 테스트
+ *
+ * 검증 범위:
+ *  - 책임 1) current-run.json steps 증가 (회귀 테스트)
+ *  - 책임 2) current-run.jsonl append (Phase 1)
+ *  - 책임 3) error_category 분류기 + 3-fail detector → anti-pattern md (Phase 2)
+ *  - 책임 간 독립성, hot-path 안정성
+ *
+ * 패턴: keyword-detector.test.js 와 동일한 execFileSync 방식.
+ */
+import { describe, it, expect, beforeEach } 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 SCRIPT = path.resolve(__dirname, '..', 'step-counter.js');
+
+/**
+ * 격리된 임시 프로젝트에서 step-counter 를 1회 실행.
+ * stdin 으로 PostToolUse payload 전달.
+ */
+function runCounter({ payload, projectDir }) {
+  const result = spawnSync('node', [SCRIPT], {
+    input: payload ? JSON.stringify(payload) : '',
+    encoding: 'utf-8',
+    timeout: 5000,
+    env: {
+      ...process.env,
+      CLAUDE_PROJECT_DIR: projectDir,
+      // VIBE_HOOK_DEPTH 미설정 — 재귀 가드 영향 없음
+    },
+  });
+  return result;
+}
+
+function makeTmpProject() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'vibe-step-counter-'));
+  // .vibe/metrics/ 는 step-counter 가 직접 생성하도록 미리 만들지 않음
+  return dir;
+}
+
+function readJson(p) {
+  return JSON.parse(fs.readFileSync(p, 'utf-8'));
+}
+
+function readJsonl(p) {
+  return fs.readFileSync(p, 'utf-8').split('\n').filter(Boolean).map((l) => JSON.parse(l));
+}
+
+describe('step-counter PostToolUse hook', () => {
+  let projectDir;
+  let runJson;
+  let runJsonl;
+
+  beforeEach(() => {
+    projectDir = makeTmpProject();
+    runJson = path.join(projectDir, '.vibe', 'metrics', 'current-run.json');
+    runJsonl = path.join(projectDir, '.vibe', 'metrics', 'current-run.jsonl');
+  });
+
+  // ───────── 책임 1 회귀 ─────────
+  describe('책임 1: current-run.json 카운터', () => {
+    it('첫 호출 시 steps=1, startedAt 채움', () => {
+      const r = runCounter({
+        payload: { tool_name: 'Bash', tool_input: { command: 'ls' }, tool_response: { is_error: false } },
+        projectDir,
+      });
+      expect(r.status).toBe(0);
+      const data = readJson(runJson);
+      expect(data.steps).toBe(1);
+      expect(data.startedAt).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+    });
+
+    it('연속 호출 시 steps 누적', () => {
+      for (let i = 0; i < 3; i++) {
+        runCounter({
+          payload: { tool_name: 'Bash', tool_input: { command: 'echo hi' }, tool_response: {} },
+          projectDir,
+        });
+      }
+      const data = readJson(runJson);
+      expect(data.steps).toBe(3);
+    });
+
+    it('손상된 JSON 이 있어도 새로 시작', () => {
+      fs.mkdirSync(path.join(projectDir, '.vibe', 'metrics'), { recursive: true });
+      fs.writeFileSync(runJson, '{ broken json');
+      const r = runCounter({
+        payload: { tool_name: 'Bash', tool_input: {}, tool_response: {} },
+        projectDir,
+      });
+      expect(r.status).toBe(0);
+      const data = readJson(runJson);
+      expect(data.steps).toBe(1);
+    });
+  });
+
+  // ───────── 책임 2 신규 ─────────
+  describe('책임 2: current-run.jsonl 로깅', () => {
+    it('툴콜 1회 = jsonl 1라인', () => {
+      runCounter({
+        payload: { tool_name: 'Edit', tool_input: { file_path: 'src/foo.ts' }, tool_response: {} },
+        projectDir,
+      });
+      const lines = readJsonl(runJsonl);
+      expect(lines).toHaveLength(1);
+      expect(lines[0].tool).toBe('Edit');
+      expect(lines[0].ok).toBe(true);
+      expect(lines[0].target_file).toBe('src/foo.ts');
+      expect(lines[0].error_category).toBeNull();
+      expect(lines[0].ts).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+    });
+
+    it('tool_response.is_error=true 면 ok=false', () => {
+      runCounter({
+        payload: { tool_name: 'Bash', tool_input: { command: 'false' }, tool_response: { is_error: true } },
+        projectDir,
+      });
+      const [line] = readJsonl(runJsonl);
+      expect(line.ok).toBe(false);
+    });
+
+    it('절대 경로 file_path 를 프로젝트 상대 경로로 정규화', () => {
+      const abs = path.join(projectDir, 'src', 'bar.ts');
+      runCounter({
+        payload: { tool_name: 'Write', tool_input: { file_path: abs }, tool_response: {} },
+        projectDir,
+      });
+      const [line] = readJsonl(runJsonl);
+      expect(line.target_file).toBe('src/bar.ts');
+    });
+
+    it('file_path 없는 툴콜은 target_file=null', () => {
+      runCounter({
+        payload: { tool_name: 'Bash', tool_input: { command: 'pwd' }, tool_response: {} },
+        projectDir,
+      });
+      const [line] = readJsonl(runJsonl);
+      expect(line.target_file).toBeNull();
+    });
+
+    it('tool_name 없으면 jsonl 라인 안 씀 (steps 는 증가)', () => {
+      runCounter({ payload: {}, projectDir });
+      expect(fs.existsSync(runJsonl)).toBe(false);
+      expect(readJson(runJson).steps).toBe(1);
+    });
+
+    it('연속 호출 시 jsonl 누적', () => {
+      runCounter({
+        payload: { tool_name: 'Read', tool_input: { file_path: 'a.ts' }, tool_response: {} },
+        projectDir,
+      });
+      runCounter({
+        payload: { tool_name: 'Edit', tool_input: { file_path: 'a.ts' }, tool_response: {} },
+        projectDir,
+      });
+      const lines = readJsonl(runJsonl);
+      expect(lines).toHaveLength(2);
+      expect(lines.map((l) => l.tool)).toEqual(['Read', 'Edit']);
+    });
+  });
+
+  // ───────── 독립성 ─────────
+  describe('두 책임의 독립성', () => {
+    it('payload 가 비어 stdin 무효여도 카운터는 증가', () => {
+      const r = runCounter({ payload: null, projectDir });
+      expect(r.status).toBe(0);
+      expect(readJson(runJson).steps).toBe(1);
+    });
+  });
+
+  // ───────── Phase 2: error_category 분류 ─────────
+  describe('책임 3a: error_category 분류기', () => {
+    it('TypeError of undefined → nullability', () => {
+      runCounter({
+        payload: {
+          tool_name: 'Bash',
+          tool_input: { command: 'node x.js' },
+          tool_response: { is_error: true, error: "TypeError: Cannot read properties of undefined (reading 'foo')" },
+        },
+        projectDir,
+      });
+      const [line] = readJsonl(runJsonl);
+      expect(line.error_category).toBe('nullability');
+    });
+
+    it('TS2345 → type-narrow', () => {
+      runCounter({
+        payload: {
+          tool_name: 'Bash',
+          tool_input: { command: 'tsc' },
+          tool_response: { is_error: true, error: "src/x.ts(3,4): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'." },
+        },
+        projectDir,
+      });
+      const [line] = readJsonl(runJsonl);
+      expect(line.error_category).toBe('type-narrow');
+    });
+
+    it('ECONNREFUSED → integration', () => {
+      runCounter({
+        payload: {
+          tool_name: 'Bash',
+          tool_input: { command: 'curl' },
+          tool_response: { is_error: true, error: 'connect ECONNREFUSED 127.0.0.1:5432' },
+        },
+        projectDir,
+      });
+      const [line] = readJsonl(runJsonl);
+      expect(line.error_category).toBe('integration');
+    });
+
+    it('알 수 없는 에러 → other', () => {
+      runCounter({
+        payload: {
+          tool_name: 'Bash',
+          tool_input: { command: 'x' },
+          tool_response: { is_error: true, error: 'some unrecognized failure mode 12345' },
+        },
+        projectDir,
+      });
+      const [line] = readJsonl(runJsonl);
+      expect(line.error_category).toBe('other');
+    });
+
+    it('성공 툴콜은 error_category=null', () => {
+      runCounter({
+        payload: { tool_name: 'Bash', tool_input: { command: 'ls' }, tool_response: { is_error: false } },
+        projectDir,
+      });
+      const [line] = readJsonl(runJsonl);
+      expect(line.ok).toBe(true);
+      expect(line.error_category).toBeNull();
+    });
+  });
+
+  // ───────── Phase 2: 3-fail detector ─────────
+  describe('책임 3b: 3-fail detector → anti-pattern md', () => {
+    function failBash(command, errorText, projectDir) {
+      runCounter({
+        payload: {
+          tool_name: 'Bash',
+          tool_input: { command },
+          tool_response: { is_error: true, error: errorText },
+        },
+        projectDir,
+      });
+    }
+
+    function listAntiPatterns(projectDir) {
+      const dir = path.join(projectDir, '.vibe', 'anti-patterns');
+      if (!fs.existsSync(dir)) return [];
+      return fs.readdirSync(dir).filter((f) => f.endsWith('.md'));
+    }
+
+    it('같은 (file, category) 3회 누적 시 anti-pattern md 생성', () => {
+      const err = "TypeError: Cannot read properties of undefined (reading 'x')";
+      // file_path 없는 Bash 실패 3회 → target_file=null, category=nullability
+      for (let i = 0; i < 3; i++) failBash(`run-${i}`, err, projectDir);
+      const files = listAntiPatterns(projectDir);
+      expect(files).toHaveLength(1);
+      expect(files[0]).toMatch(/^nullability__global__\d{8}\.md$/);
+    });
+
+    it('2회만 누적되면 생성 안 함', () => {
+      const err = 'connect ECONNREFUSED foo';
+      for (let i = 0; i < 2; i++) failBash(`x-${i}`, err, projectDir);
+      expect(listAntiPatterns(projectDir)).toHaveLength(0);
+    });
+
+    it('3회지만 카테고리 다르면 생성 안 함', () => {
+      failBash('a', "Cannot read properties of undefined", projectDir); // nullability
+      failBash('b', "ECONNREFUSED", projectDir);                         // integration
+      failBash('c', "TS2345 not assignable", projectDir);                // type-narrow
+      expect(listAntiPatterns(projectDir)).toHaveLength(0);
+    });
+
+    it('동일 (file, category) 4회 — md 1개만 (dedup)', () => {
+      const err = "TypeError: Cannot read properties of undefined";
+      for (let i = 0; i < 4; i++) failBash(`r-${i}`, err, projectDir);
+      expect(listAntiPatterns(projectDir)).toHaveLength(1);
+    });
+
+    it('frontmatter 가 schema 충족', () => {
+      const err = "TypeError: Cannot read properties of null";
+      for (let i = 0; i < 3; i++) failBash(`r-${i}`, err, projectDir);
+      const [filename] = listAntiPatterns(projectDir);
+      const content = fs.readFileSync(path.join(projectDir, '.vibe', 'anti-patterns', filename), 'utf-8');
+      expect(content).toMatch(/^---\n/);
+      expect(content).toMatch(/^slug: nullability__global__\d{8}$/m);
+      expect(content).toMatch(/^type: anti-pattern$/m);
+      expect(content).toMatch(/^root-cause-tag: nullability$/m);
+      expect(content).toMatch(/^trigger-signature: "/m);
+      expect(content).toMatch(/^fail-count: 3$/m);
+      expect(content).toMatch(/^suggested-stop: "/m);
+      expect(content).toMatch(/^created: \d{4}-\d{2}-\d{2}$/m);
+    });
+
+    it('파일 경로 있는 실패는 file slug 사용', () => {
+      const filePath = 'src/cli/foo.ts';
+      const err = "TypeError: Cannot read properties of undefined";
+      for (let i = 0; i < 3; i++) {
+        runCounter({
+          payload: {
+            tool_name: 'Edit',
+            tool_input: { file_path: filePath },
+            tool_response: { is_error: true, error: err },
+          },
+          projectDir,
+        });
+      }
+      const [filename] = listAntiPatterns(projectDir);
+      expect(filename).toMatch(/^nullability__src-cli-foo-ts__\d{8}\.md$/);
+    });
+
+    it('윈도우 외 실패는 카운트 안 됨', () => {
+      const err = "TypeError: Cannot read properties of undefined";
+      // 같은 카테고리 실패 2회
+      failBash('a', err, projectDir);
+      failBash('b', err, projectDir);
+      // 성공 툴콜로 윈도우 채움 (10줄 이상)
+      for (let i = 0; i < 10; i++) {
+        runCounter({
+          payload: { tool_name: 'Read', tool_input: { file_path: `f${i}.ts` }, tool_response: {} },
+          projectDir,
+        });
+      }
+      // 마지막 실패 1회 — 윈도우(10줄) 안에는 이 실패 + 직전 성공만 있으므로 트립 안 함
+      failBash('c', err, projectDir);
+      expect(listAntiPatterns(projectDir)).toHaveLength(0);
+    });
+  });
+
+  // ───────── 차단 금지 ─────────
+  describe('hot path 안정성', () => {
+    it('항상 exit 0', () => {
+      const r = runCounter({
+        payload: { tool_name: 'Bash', tool_input: { command: 'x' }, tool_response: {} },
+        projectDir,
+      });
+      expect(r.status).toBe(0);
+    });
+
+    it('잘못된 stdin JSON 도 차단 안 함', () => {
+      const r = spawnSync('node', [SCRIPT], {
+        input: 'not json at all',
+        encoding: 'utf-8',
+        timeout: 5000,
+        env: { ...process.env, CLAUDE_PROJECT_DIR: projectDir },
+      });
+      expect(r.status).toBe(0);
+    });
+  });
+});

package/hooks/scripts/lib/curation-index.js

@@ -0,0 +1,101 @@
+/**
+ * Phase 3 — Curation index loader
+ *
+ * `.vibe/recipes/*.md` 와 `.vibe/anti-patterns/*.md` 의 frontmatter 만 parse 해
+ * 1줄 요약 인덱스를 만든다. 본문은 읽지 않음 (세션 컨텍스트 절약).
+ *
+ * SPEC 결정:
+ *   - INDEX.jsonl 미사용. 디렉토리 스캔 + frontmatter parse 가 충분히 빠르다 (<100 파일).
+ *   - 최근 N=5 상한 (created 내림차순).
+ *
+ * 의도적 제한:
+ *   - 본격 YAML parser 의존성 추가 거부. 우리가 *직접 작성*한 frontmatter 만
+ *     읽으므로 문법이 정해져 있다. 라인별 정규식이면 충분.
+ */
+import fs from 'fs';
+import path from 'path';
+import { projectVibeRoot } from '../utils.js';
+
+const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---/;
+// "key: value" 또는 'key: "quoted value"' (이스케이프 \\" 포함)
+const FIELD_RE = /^([a-z][a-z0-9_-]*):\s*(?:"((?:[^"\\]|\\.)*)"|(.+?))\s*$/;
+
+function parseFrontmatter(content) {
+  const m = FRONTMATTER_RE.exec(content);
+  if (!m) return null;
+  const fields = {};
+  for (const line of m[1].split('\n')) {
+    const fm = FIELD_RE.exec(line);
+    if (!fm) continue;
+    const key = fm[1];
+    const value = fm[2] !== undefined ? fm[2].replace(/\\"/g, '"') : fm[3];
+    fields[key] = value;
+  }
+  return fields;
+}
+
+function readHead(filePath, bytes = 2048) {
+  const fd = fs.openSync(filePath, 'r');
+  try {
+    const buf = Buffer.alloc(bytes);
+    const n = fs.readSync(fd, buf, 0, bytes, 0);
+    return buf.toString('utf-8', 0, n);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+function listMd(dir) {
+  if (!fs.existsSync(dir)) return [];
+  return fs.readdirSync(dir)
+    .filter((f) => f.endsWith('.md') && !f.startsWith('_') && f !== 'README.md')
+    .map((f) => path.join(dir, f));
+}
+
+function safeParse(filePath) {
+  try {
+    const head = readHead(filePath);
+    const fields = parseFrontmatter(head);
+    if (!fields || !fields.slug) return null;
+    return fields;
+  } catch {
+    return null;
+  }
+}
+
+function compareCreatedDesc(a, b) {
+  // created 가 ISO 면 문자열 비교로 시간 정렬 가능, 아니면 mtime fallback
+  return (b.created || '').localeCompare(a.created || '');
+}
+
+/**
+ * 프로젝트의 recipes + anti-patterns 인덱스를 로드.
+ * @returns { recipes: [{slug, summary}], antiPatterns: [{tag, summary}] }
+ */
+export function loadCurationIndex(projectDir, opts = {}) {
+  const { recipeLimit = 5, antiPatternLimit = 5 } = opts;
+  const root = projectVibeRoot(projectDir);
+
+  const recipes = listMd(path.join(root, 'recipes'))
+    .map(safeParse).filter(Boolean)
+    .sort(compareCreatedDesc)
+    .slice(0, recipeLimit)
+    .map((f) => ({
+      slug: f.slug,
+      summary: f.recipe || f['symptom-context'] || '(no summary)',
+    }));
+
+  const antiPatterns = listMd(path.join(root, 'anti-patterns'))
+    .map(safeParse).filter(Boolean)
+    .sort(compareCreatedDesc)
+    .slice(0, antiPatternLimit)
+    .map((f) => ({
+      tag: f['root-cause-tag'] || 'other',
+      summary: f['suggested-stop'] || f['trigger-signature'] || '(no summary)',
+    }));
+
+  return { recipes, antiPatterns };
+}
+
+/** Test-only: frontmatter parser 노출 */
+export const _internal = { parseFrontmatter };