@wooojin/forgen 0.2.0 → 0.2.1

package/dist/hooks/shared/hook-response.js

@@ -14,8 +14,8 @@
  *   모델에 컨텍스트를 주입하려면 반드시 additionalContext를 사용해야 함.
  */
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
-import { STATE_DIR } from '../../core/paths.js';
 /** 통과 응답 (컨텍스트 없음, 모든 이벤트 공통) */
 export function approve() {
     return JSON.stringify({ continue: true });
@@ -63,31 +63,20 @@ export function ask(reason) {
 export function failOpen() {
     return JSON.stringify({ continue: true });
 }
-/** 훅별 에러 카운트를 STATE_DIR/hook-errors.json에 누적 */
-export function incrementHookErrorCount(hookName) {
-    try {
-        const errorPath = path.join(STATE_DIR, 'hook-errors.json');
-        let errors = {};
-        try {
-            if (fs.existsSync(errorPath)) {
-                errors = JSON.parse(fs.readFileSync(errorPath, 'utf-8'));
-            }
-        }
-        catch { /* start fresh */ }
-        if (!errors[hookName])
-            errors[hookName] = { count: 0, lastAt: '' };
-        errors[hookName].count++;
-        errors[hookName].lastAt = new Date().toISOString();
-        fs.mkdirSync(STATE_DIR, { recursive: true });
-        fs.writeFileSync(errorPath, JSON.stringify(errors, null, 2));
-    }
-    catch { /* meta-error in error tracking — ignore */ }
-}
 /**
- * fail-open + 에러 카운트 누적.
- * 훅의 main().catch() 블록에서 명시적으로 호출.
+ * fail-open with error tracking: 에러 시 안전하게 통과하되, 실패 정보를 기록.
+ * forgen doctor의 Hook Health 섹션에서 실패 이력을 표시할 수 있도록 JSONL 로그에 기록.
+ *
+ * @fail-open: hook failure must never block the user's workflow
  */
 export function failOpenWithTracking(hookName) {
-    incrementHookErrorCount(hookName);
+    try {
+        const stateDir = path.join(os.homedir(), '.forgen', 'state');
+        fs.mkdirSync(stateDir, { recursive: true });
+        const logPath = path.join(stateDir, 'hook-errors.jsonl');
+        const entry = JSON.stringify({ hook: hookName, at: Date.now() });
+        fs.appendFileSync(logPath, entry + '\n');
+    }
+    catch { /* fail-open: tracking itself must not throw */ }
     return JSON.stringify({ continue: true });
 }

package/dist/hooks/shared/hook-timing.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Forgen — Hook Timing Profiler
+ *
+ * Records hook execution durations and provides timing statistics
+ * for visibility into which hooks are slow.
+ */
+export declare function recordHookTiming(hookName: string, durationMs: number, event: string): void;
+export interface TimingStats {
+    hook: string;
+    count: number;
+    p50: number;
+    p95: number;
+    max: number;
+}
+export declare function getTimingStats(): TimingStats[];

package/dist/hooks/shared/hook-timing.js

@@ -0,0 +1,64 @@
+/**
+ * Forgen — Hook Timing Profiler
+ *
+ * Records hook execution durations and provides timing statistics
+ * for visibility into which hooks are slow.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { STATE_DIR } from '../../core/paths.js';
+const TIMING_LOG = path.join(STATE_DIR, 'hook-timing.jsonl');
+const MAX_LINES = 500;
+export function recordHookTiming(hookName, durationMs, event) {
+    try {
+        fs.mkdirSync(STATE_DIR, { recursive: true });
+        const entry = JSON.stringify({ hook: hookName, ms: durationMs, event, at: Date.now() });
+        fs.appendFileSync(TIMING_LOG, entry + '\n');
+        // Rotate if too large
+        try {
+            const content = fs.readFileSync(TIMING_LOG, 'utf-8');
+            const lines = content.trim().split('\n');
+            if (lines.length > MAX_LINES) {
+                fs.writeFileSync(TIMING_LOG, lines.slice(-MAX_LINES).join('\n') + '\n');
+            }
+        }
+        catch { /* skip rotation on error */ }
+    }
+    catch { /* fail-open */ }
+}
+export function getTimingStats() {
+    try {
+        if (!fs.existsSync(TIMING_LOG))
+            return [];
+        const content = fs.readFileSync(TIMING_LOG, 'utf-8');
+        const entries = content.trim().split('\n')
+            .map(line => { try {
+            return JSON.parse(line);
+        }
+        catch {
+            return null;
+        } })
+            .filter(Boolean);
+        const byHook = new Map();
+        for (const e of entries) {
+            if (!byHook.has(e.hook))
+                byHook.set(e.hook, []);
+            byHook.get(e.hook).push(e.ms);
+        }
+        const stats = [];
+        for (const [hook, times] of byHook) {
+            times.sort((a, b) => a - b);
+            stats.push({
+                hook,
+                count: times.length,
+                p50: times[Math.floor(times.length * 0.5)] ?? 0,
+                p95: times[Math.floor(times.length * 0.95)] ?? 0,
+                max: times[times.length - 1] ?? 0,
+            });
+        }
+        return stats.sort((a, b) => b.p95 - a.p95);
+    }
+    catch {
+        return [];
+    }
+}

package/dist/hooks/skill-injector.js

@@ -34,10 +34,11 @@ function escapeXmlAttr(s) {
     return s.replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
 import { atomicWriteJSON } from './shared/atomic-write.js';
+import { withFileLockSync } from './shared/file-lock.js';
 import { FORGEN_HOME, ME_DIR, STATE_DIR } from '../core/paths.js';
 import { KEYWORD_PATTERNS } from './keyword-detector.js';
 import { isHookEnabled } from './hook-config.js';
-import { approve, approveWithContext, failOpen } from './shared/hook-response.js';
+import { approve, approveWithContext, failOpenWithTracking } from './shared/hook-response.js';
 /** keyword-detector가 처리하는 키워드 이름 집합 (skill + inject 모두 포함, 이중 주입 방지) */
 const KEYWORD_DETECTOR_SKILL_NAMES = new Set(KEYWORD_PATTERNS
     .filter(p => p.type === 'skill' || p.type === 'inject')
@@ -65,11 +66,39 @@ function loadSessionCache(sessionId) {
     }
     return new Set();
 }
-function saveSessionCache(sessionId, injected) {
-    atomicWriteJSON(getSessionCachePath(sessionId), {
-        injected: [...injected],
-        updatedAt: new Date().toISOString(),
-    });
+function saveSessionCache(sessionId, newSkillNames) {
+    const cachePath = getSessionCachePath(sessionId);
+    try {
+        withFileLockSync(cachePath, () => {
+            // Lock 안에서 fresh re-read → merge → write
+            const freshInjected = new Set();
+            try {
+                if (fs.existsSync(cachePath)) {
+                    const fresh = JSON.parse(fs.readFileSync(cachePath, 'utf-8'));
+                    const age = fresh.updatedAt ? Date.now() - new Date(fresh.updatedAt).getTime() : Infinity;
+                    if (Number.isFinite(age) && age <= 24 * 60 * 60 * 1000) {
+                        for (const name of fresh.injected ?? [])
+                            freshInjected.add(name);
+                    }
+                }
+            }
+            catch { /* fresh re-read 실패 시 빈 set으로 진행 */ }
+            for (const name of newSkillNames)
+                freshInjected.add(name);
+            atomicWriteJSON(cachePath, {
+                injected: [...freshInjected],
+                updatedAt: new Date().toISOString(),
+            });
+        });
+    }
+    catch (e) {
+        // Lock 실패 시 fail-open: 직접 write (중복 주입 가능성 있지만 기능 차단 안 함)
+        log.debug('skill session cache lock 실패 — fallback write', e);
+        atomicWriteJSON(cachePath, {
+            injected: [...new Set([...loadSessionCache(sessionId), ...newSkillNames])],
+            updatedAt: new Date().toISOString(),
+        });
+    }
 }
 /** YAML frontmatter 파싱 (간단한 구현) */
 export function parseFrontmatter(content) {
@@ -258,11 +287,11 @@ async function main() {
     }
     // 최대 제한 적용
     const toInject = matched.slice(0, MAX_SKILLS_PER_SESSION - injected.size);
-    // 파일 기반 캐시 업데이트
-    for (const skill of toInject) {
-        injected.add(skill.name);
-    }
-    saveSessionCache(sessionId, injected);
+    // 파일 기반 캐시 업데이트 (lock 보호)
+    const newSkillNames = toInject.map(s => s.name);
+    for (const name of newSkillNames)
+        injected.add(name);
+    saveSessionCache(sessionId, newSkillNames);
     // Adaptive budget: 다른 플러그인 감지 시 스킬 주입량 축소
     let skillCap = 3000; // INJECTION_CAPS.skillContentMax 기본값
     try {
@@ -281,5 +310,5 @@ async function main() {
 }
 main().catch((e) => {
     process.stderr.write(`[ch-hook] ${e instanceof Error ? e.message : String(e)}\n`);
-    console.log(failOpen());
+    console.log(failOpenWithTracking('skill-injector'));
 });

package/dist/hooks/slop-detector.js

@@ -9,7 +9,7 @@
 import { readStdinJSON } from './shared/read-stdin.js';
 import { createLogger } from '../core/logger.js';
 import { isHookEnabled, loadHookConfig } from './hook-config.js';
-import { approve, approveWithWarning, failOpen } from './shared/hook-response.js';
+import { approve, approveWithWarning, failOpenWithTracking } from './shared/hook-response.js';
 const log = createLogger('slop-detector');
 export const SLOP_PATTERNS = [
     { pattern: /\/\/\s*TODO:?\s*(implement|add|fix|handle)/i, message: 'Leftover TODO comment', severity: 'warn' },
@@ -84,10 +84,10 @@ async function main() {
     }
     catch (e) {
         log.debug('슬롭 감지 실패', e);
-        console.log(failOpen());
+        console.log(failOpenWithTracking('slop-detector'));
     }
 }
 main().catch((e) => {
     process.stderr.write(`[ch-hook] ${e instanceof Error ? e.message : String(e)}\n`);
-    console.log(failOpen());
+    console.log(failOpenWithTracking('slop-detector'));
 });