@wooojin/forgen 0.1.0

package/dist/hooks/db-guard.d.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+/**
+ * Forgen — PreToolUse: DB Guard Hook
+ *
+ * Bash 도구 실행 전 위험한 SQL 명령어를 감지하여 차단 또는 경고합니다.
+ */
+export interface SqlPattern {
+    pattern: RegExp;
+    description: string;
+    severity: 'block' | 'warn';
+}
+export declare const DANGEROUS_SQL_PATTERNS: SqlPattern[];
+/** SQL 명령어 위험도 검사 (순수 함수) */
+export declare function checkDangerousSql(toolName: string, toolInput: Record<string, unknown> | string): {
+    action: 'block' | 'warn' | 'pass';
+    description?: string;
+};

package/dist/hooks/db-guard.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+/**
+ * Forgen — PreToolUse: DB Guard Hook
+ *
+ * Bash 도구 실행 전 위험한 SQL 명령어를 감지하여 차단 또는 경고합니다.
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { readStdinJSON } from './shared/read-stdin.js';
+import { atomicWriteJSON } from './shared/atomic-write.js';
+import { isHookEnabled } from './hook-config.js';
+import { approve, approveWithWarning, deny, failOpen } from './shared/hook-response.js';
+import { STATE_DIR } from '../core/paths.js';
+const FAIL_COUNTER_PATH = path.join(STATE_DIR, 'db-guard-fail-counter.json');
+const FAIL_CLOSE_THRESHOLD = 3;
+export const DANGEROUS_SQL_PATTERNS = [
+    { pattern: /DROP\s+(TABLE|DATABASE|SCHEMA)/i, description: 'DROP TABLE/DATABASE/SCHEMA', severity: 'block' },
+    { pattern: /TRUNCATE\s+TABLE/i, description: 'TRUNCATE TABLE', severity: 'block' },
+    { pattern: /DELETE\s+FROM\s+\w+/i, description: 'DELETE FROM (WHERE clause required)', severity: 'block' },
+    { pattern: /ALTER\s+TABLE\s+\w+\s+DROP\s+COLUMN/i, description: 'ALTER TABLE DROP COLUMN', severity: 'warn' },
+    { pattern: /UPDATE\s+\w+\s+SET/i, description: 'UPDATE SET (WHERE clause required)', severity: 'warn' },
+];
+/** SQL 명령어 위험도 검사 (순수 함수) */
+export function checkDangerousSql(toolName, toolInput) {
+    if (toolName !== 'Bash')
+        return { action: 'pass' };
+    const command = typeof toolInput === 'string'
+        ? toolInput
+        : (toolInput.command ?? '');
+    // 주석 제거 후 SQL에 대해 패턴 매칭 (주석 안 키워드 오차단 방지)
+    const sqlWithoutComments = command
+        .replace(/--[^\n]*/g, '') // 라인 주석 제거
+        .replace(/\/\*[\s\S]*?\*\//g, ''); // 블록 주석 제거
+    for (const { pattern, description, severity } of DANGEROUS_SQL_PATTERNS) {
+        if (pattern.test(sqlWithoutComments)) {
+            // DELETE/UPDATE — SQL 본문에서 WHERE 절이 있으면 통과
+            if (/DELETE\s+FROM/i.test(sqlWithoutComments) && /\bWHERE\s+/i.test(sqlWithoutComments))
+                continue;
+            if (/UPDATE\s+\w+\s+SET/i.test(sqlWithoutComments) && /\bWHERE\s+/i.test(sqlWithoutComments))
+                continue;
+            return { action: severity, description };
+        }
+    }
+    return { action: 'pass' };
+}
+/** 연속 파싱 실패 카운터 */
+function getAndIncrementFailCount() {
+    try {
+        let count = 0;
+        if (fs.existsSync(FAIL_COUNTER_PATH)) {
+            const data = JSON.parse(fs.readFileSync(FAIL_COUNTER_PATH, 'utf-8'));
+            count = (data.count ?? 0) + 1;
+        }
+        else {
+            count = 1;
+        }
+        atomicWriteJSON(FAIL_COUNTER_PATH, { count, updatedAt: new Date().toISOString() });
+        return count;
+    }
+    catch {
+        return 1;
+    }
+}
+function resetFailCount() {
+    try {
+        if (fs.existsSync(FAIL_COUNTER_PATH))
+            fs.unlinkSync(FAIL_COUNTER_PATH);
+    }
+    catch { /* fail counter reset failed — counter stays elevated but next parse success resets it */ }
+}
+async function main() {
+    const data = await readStdinJSON();
+    if (!data) {
+        const failCount = getAndIncrementFailCount();
+        if (failCount >= FAIL_CLOSE_THRESHOLD) {
+            console.log(deny(`[Forgen] DB Guard: stdin parse failed ${failCount} consecutive times — blocking for safety.`));
+        }
+        else {
+            process.stderr.write(`[ch-hook] db-guard stdin parse failed (${failCount}/${FAIL_CLOSE_THRESHOLD})\n`);
+            console.log(approve());
+        }
+        return;
+    }
+    resetFailCount();
+    if (!isHookEnabled('db-guard')) {
+        console.log(approve());
+        return;
+    }
+    const toolName = data.tool_name ?? data.toolName ?? '';
+    const toolInput = data.tool_input ?? data.toolInput ?? {};
+    const check = checkDangerousSql(toolName, toolInput);
+    if (check.action === 'block') {
+        console.log(deny(`[Forgen] Dangerous SQL blocked: ${check.description}`));
+        return;
+    }
+    if (check.action === 'warn') {
+        console.log(approveWithWarning(`<compound-sql-warning>\n[Forgen] ⚠ Dangerous SQL detected: ${check.description}\nProceed with caution.\n</compound-sql-warning>`));
+        return;
+    }
+    console.log(approve());
+}
+main().catch((e) => {
+    process.stderr.write(`[ch-hook] DB Guard error: ${e instanceof Error ? e.message : String(e)}\n`);
+    console.log(failOpen());
+});

package/dist/hooks/hook-config.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Forgen — Hook Config Loader
+ *
+ * ~/.compound/hook-config.json 에서 훅별 설정을 읽어 반환합니다.
+ * 파일이 없거나 읽기에 실패하면 null 을 반환합니다 (failure-tolerant).
+ *
+ * 설정 형식 (hook-config.json):
+ * {
+ *   "tiers": { "compound-core": { "enabled": true }, "safety": { "enabled": true }, "workflow": { "enabled": true } },
+ *   "hooks": { "hookName": { "enabled": false, ...customConfig } },
+ *   "hookName": { "enabled": false }  // 레거시 호환 (hooks 키 없이 직접 지정)
+ * }
+ *
+ * 안전 보장:
+ *   - compound-core 티어는 tiers 설정으로 비활성화 불가 (복리화 보호)
+ *   - 개별 hooks.hookName.enabled: false 로만 비활성화 가능
+ */
+/** 특정 훅의 설정을 반환합니다. 실패 시 null 반환. */
+export declare function loadHookConfig(hookName: string): Record<string, unknown> | null;
+/**
+ * 훅이 활성화되어 있는지 확인합니다.
+ *
+ * 우선순위:
+ *   1. hooks.hookName.enabled (개별 훅 설정)
+ *   2. tiers.tierName.enabled (티어 설정) — compound-core는 티어 비활성화 무시
+ *   3. hookName.enabled (레거시 형식)
+ *   4. 기본값 true (하위호환)
+ */
+export declare function isHookEnabled(hookName: string): boolean;

package/dist/hooks/hook-config.js

@@ -0,0 +1,92 @@
+/**
+ * Forgen — Hook Config Loader
+ *
+ * ~/.compound/hook-config.json 에서 훅별 설정을 읽어 반환합니다.
+ * 파일이 없거나 읽기에 실패하면 null 을 반환합니다 (failure-tolerant).
+ *
+ * 설정 형식 (hook-config.json):
+ * {
+ *   "tiers": { "compound-core": { "enabled": true }, "safety": { "enabled": true }, "workflow": { "enabled": true } },
+ *   "hooks": { "hookName": { "enabled": false, ...customConfig } },
+ *   "hookName": { "enabled": false }  // 레거시 호환 (hooks 키 없이 직접 지정)
+ * }
+ *
+ * 안전 보장:
+ *   - compound-core 티어는 tiers 설정으로 비활성화 불가 (복리화 보호)
+ *   - 개별 hooks.hookName.enabled: false 로만 비활성화 가능
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { HOOK_REGISTRY } from './hook-registry.js';
+import { FORGEN_HOME } from '../core/paths.js';
+const HOOK_CONFIG_PATH = path.join(FORGEN_HOME, 'hook-config.json');
+/**
+ * 훅 → 티어 매핑 (hook-registry.ts에서 자동 파생).
+ * 이중 구현 방지: HOOK_REGISTRY가 단일 소스 오브 트루스.
+ */
+const HOOK_TIER_MAP = Object.fromEntries(HOOK_REGISTRY.map(h => [h.name, h.tier]));
+/** 프로세스 내 설정 캐시 (각 훅은 별도 프로세스이므로 수명 = 1회 실행) */
+let _configCache;
+/** 전체 설정 파일을 파싱합니다. 실패 시 null. 프로세스 내 캐싱. */
+function loadFullConfig() {
+    if (_configCache !== undefined)
+        return _configCache;
+    try {
+        if (!fs.existsSync(HOOK_CONFIG_PATH)) {
+            _configCache = null;
+            return null;
+        }
+        _configCache = JSON.parse(fs.readFileSync(HOOK_CONFIG_PATH, 'utf-8'));
+        return _configCache;
+    }
+    catch {
+        _configCache = null;
+        return null;
+    }
+}
+/** 특정 훅의 설정을 반환합니다. 실패 시 null 반환. */
+export function loadHookConfig(hookName) {
+    const all = loadFullConfig();
+    if (!all)
+        return null;
+    // v2 형식: hooks.hookName
+    const hooksSection = all.hooks;
+    if (hooksSection?.[hookName])
+        return hooksSection[hookName];
+    // 레거시 형식: 최상위에 hookName 직접 지정
+    const legacy = all[hookName];
+    return legacy ?? null;
+}
+/**
+ * 훅이 활성화되어 있는지 확인합니다.
+ *
+ * 우선순위:
+ *   1. hooks.hookName.enabled (개별 훅 설정)
+ *   2. tiers.tierName.enabled (티어 설정) — compound-core는 티어 비활성화 무시
+ *   3. hookName.enabled (레거시 형식)
+ *   4. 기본값 true (하위호환)
+ */
+export function isHookEnabled(hookName) {
+    const all = loadFullConfig();
+    if (!all)
+        return true;
+    // 1) 개별 훅 설정 (v2: hooks 섹션)
+    const hooksSection = all.hooks;
+    if (hooksSection?.[hookName]?.enabled === false)
+        return false;
+    if (hooksSection?.[hookName]?.enabled === true)
+        return true;
+    // 2) 티어 설정 — compound-core는 절대 티어 비활성화로 끄지 않음
+    const tier = HOOK_TIER_MAP[hookName];
+    if (tier && tier !== 'compound-core') {
+        const tiers = all.tiers;
+        if (tiers?.[tier]?.enabled === false)
+            return false;
+    }
+    // 3) 레거시 형식 (최상위 hookName.enabled)
+    const legacy = all[hookName];
+    if (legacy?.enabled === false)
+        return false;
+    // 4) 기본값: 활성화
+    return true;
+}

package/dist/hooks/hook-registry.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Forgen — Hook Registry
+ *
+ * 모든 훅의 메타데이터를 중앙 관리합니다.
+ * 단일 소스 오브 트루스: hooks/hook-registry.json
+ * postinstall.js와 이 모듈이 동일한 JSON을 읽으므로 중복/불일치 방지.
+ *
+ * 3개 티어로 분류:
+ *   - compound-core: 경험 축적 엔진 (항상 활성)
+ *   - safety: 범용 안전 훅 (기본 활성, 개별 비활성 가능)
+ *   - workflow: 워크플로우 스킬 훅 (다른 플러그인 감지 시 자동 비활성)
+ */
+export type HookTier = 'compound-core' | 'safety' | 'workflow';
+export type HookEventType = 'UserPromptSubmit' | 'SessionStart' | 'Stop' | 'PreToolUse' | 'PostToolUse' | 'PostToolUseFailure' | 'SubagentStart' | 'SubagentStop' | 'PreCompact' | 'PermissionRequest';
+export interface HookEntry {
+    /** 고유 이름 (hook-config.json에서 사용) */
+    name: string;
+    /** 티어 분류 */
+    tier: HookTier;
+    /** Claude Code 훅 이벤트 */
+    event: HookEventType;
+    /** 도구명 매칭 패턴 (regex 또는 '*'). Best practice: 필요한 도구만 필터링. */
+    matcher: string;
+    /** 실행 스크립트 (dist/ 기준 상대 경로) */
+    script: string;
+    /** 타임아웃 (초) */
+    timeout: number;
+    /** compound 피드백 루프에 필수인 훅인지 */
+    compoundCritical: boolean;
+}
+/**
+ * 단일 소스 오브 트루스: hooks/hook-registry.json
+ *
+ * 순서가 중요함:
+ *   - pre-tool-use는 db-guard/rate-limiter보다 앞에 위치
+ *     (Code Reflection + permission hints 주입 타이밍)
+ *   - 같은 이벤트 내 훅은 배열 순서대로 실행됨
+ */
+export declare const HOOK_REGISTRY: HookEntry[];
+/** 티어별 훅 목록 조회 */
+export declare function getHooksByTier(tier: HookTier): HookEntry[];
+/** compound-critical 훅만 조회 (이 훅들은 비활성화하면 복리화가 깨짐) */
+export declare function getCompoundCriticalHooks(): HookEntry[];

package/dist/hooks/hook-registry.js

@@ -0,0 +1,31 @@
+/**
+ * Forgen — Hook Registry
+ *
+ * 모든 훅의 메타데이터를 중앙 관리합니다.
+ * 단일 소스 오브 트루스: hooks/hook-registry.json
+ * postinstall.js와 이 모듈이 동일한 JSON을 읽으므로 중복/불일치 방지.
+ *
+ * 3개 티어로 분류:
+ *   - compound-core: 경험 축적 엔진 (항상 활성)
+ *   - safety: 범용 안전 훅 (기본 활성, 개별 비활성 가능)
+ *   - workflow: 워크플로우 스킬 훅 (다른 플러그인 감지 시 자동 비활성)
+ */
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+/**
+ * 단일 소스 오브 트루스: hooks/hook-registry.json
+ *
+ * 순서가 중요함:
+ *   - pre-tool-use는 db-guard/rate-limiter보다 앞에 위치
+ *     (Code Reflection + permission hints 주입 타이밍)
+ *   - 같은 이벤트 내 훅은 배열 순서대로 실행됨
+ */
+export const HOOK_REGISTRY = require('../../hooks/hook-registry.json');
+/** 티어별 훅 목록 조회 */
+export function getHooksByTier(tier) {
+    return HOOK_REGISTRY.filter(h => h.tier === tier);
+}
+/** compound-critical 훅만 조회 (이 훅들은 비활성화하면 복리화가 깨짐) */
+export function getCompoundCriticalHooks() {
+    return HOOK_REGISTRY.filter(h => h.compoundCritical);
+}

package/dist/hooks/hooks-generator.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Forgen — Dynamic hooks.json Generator
+ *
+ * hook-registry + hook-config + plugin-detector를 조합하여
+ * hooks/hooks.json을 동적으로 생성합니다.
+ *
+ * 생성 시점:
+ *   - postinstall (npm install 후)
+ *   - forgen config hooks (사용자 설정 변경 후)
+ *   - forgen install (플러그인 설치 후)
+ */
+interface HookCommand {
+    type: 'command';
+    command: string;
+    timeout: number;
+}
+interface HookMatcher {
+    matcher: string;
+    hooks: HookCommand[];
+}
+interface HooksJson {
+    description: string;
+    hooks: Record<string, HookMatcher[]>;
+}
+interface GenerateOptions {
+    /** 프로젝트 cwd (플러그인 감지에 사용) */
+    cwd?: string;
+    /** 훅 실행 스크립트의 루트 경로 */
+    pluginRoot?: string;
+}
+/**
+ * 활성 훅만 포함한 hooks.json 객체를 생성합니다.
+ *
+ * 동작:
+ *   1. 다른 플러그인 감지
+ *   2. 충돌 훅 식별
+ *   3. hook-config.json 설정 적용
+ *   4. 활성 훅만 hooks.json 구조로 변환
+ */
+export declare function generateHooksJson(options?: GenerateOptions): HooksJson;
+/**
+ * hooks.json 파일을 생성하여 저장합니다.
+ * @returns 생성된 훅 수와 비활성화된 훅 수
+ */
+export declare function writeHooksJson(hooksDir: string, options?: GenerateOptions): {
+    active: number;
+    disabled: number;
+};
+export {};

package/dist/hooks/hooks-generator.js

@@ -0,0 +1,99 @@
+/**
+ * Forgen — Dynamic hooks.json Generator
+ *
+ * hook-registry + hook-config + plugin-detector를 조합하여
+ * hooks/hooks.json을 동적으로 생성합니다.
+ *
+ * 생성 시점:
+ *   - postinstall (npm install 후)
+ *   - forgen config hooks (사용자 설정 변경 후)
+ *   - forgen install (플러그인 설치 후)
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { HOOK_REGISTRY } from './hook-registry.js';
+import { isHookEnabled } from './hook-config.js';
+import { detectInstalledPlugins, getHookConflicts } from '../core/plugin-detector.js';
+/**
+ * 활성 훅만 포함한 hooks.json 객체를 생성합니다.
+ *
+ * 동작:
+ *   1. 다른 플러그인 감지
+ *   2. 충돌 훅 식별
+ *   3. hook-config.json 설정 적용
+ *   4. 활성 훅만 hooks.json 구조로 변환
+ */
+export function generateHooksJson(options) {
+    const cwd = options?.cwd;
+    // biome-ignore lint/suspicious/noTemplateCurlyInString: CLAUDE_PLUGIN_ROOT is a Claude Code Plugin SDK variable resolved at runtime
+    const pluginRoot = options?.pluginRoot ?? '${CLAUDE_PLUGIN_ROOT}/dist';
+    // 다른 플러그인의 충돌 훅 감지
+    const hookConflicts = getHookConflicts(cwd);
+    const detectedPlugins = detectInstalledPlugins(cwd);
+    const hasOtherPlugins = detectedPlugins.length > 0;
+    // 활성 훅 필터링
+    const activeHooks = HOOK_REGISTRY.filter(hook => {
+        // 1) hook-config.json에서 명시적 비활성화
+        if (!isHookEnabled(hook.name))
+            return false;
+        // 2) 다른 플러그인과 충돌하는 workflow 훅은 자동 비활성
+        //    (단, compound-critical 훅은 항상 유지)
+        if (hasOtherPlugins && hook.tier === 'workflow' && hookConflicts.has(hook.name) && !hook.compoundCritical) {
+            return false;
+        }
+        return true;
+    });
+    // 이벤트별로 그룹핑
+    const byEvent = new Map();
+    for (const hook of activeHooks) {
+        const list = byEvent.get(hook.event) ?? [];
+        list.push(hook);
+        byEvent.set(hook.event, list);
+    }
+    // hooks.json 구조 생성 — matcher별로 그룹핑 (best practice: 도구 필터링)
+    const hooks = {};
+    for (const [event, entries] of byEvent) {
+        // 같은 matcher끼리 그룹핑
+        const byMatcher = new Map();
+        for (const h of entries) {
+            const m = h.matcher ?? '*';
+            const group = byMatcher.get(m) ?? [];
+            group.push(h);
+            byMatcher.set(m, group);
+        }
+        hooks[event] = [...byMatcher.entries()].map(([matcher, matcherEntries]) => ({
+            matcher,
+            hooks: matcherEntries.map(h => {
+                // script에 인자가 포함된 경우 (예: "hooks/subagent-tracker.js start")
+                // 파일 경로와 인자를 분리해야 셸에서 ENOENT를 방지
+                const spaceIdx = h.script.indexOf(' ');
+                const command = spaceIdx === -1
+                    ? `node "${pluginRoot}/${h.script}"`
+                    : `node "${pluginRoot}/${h.script.slice(0, spaceIdx)}" ${h.script.slice(spaceIdx + 1)}`;
+                return { type: 'command', command, timeout: h.timeout };
+            }),
+        }));
+    }
+    return {
+        description: `Forgen harness hooks (auto-generated, ${activeHooks.length}/${HOOK_REGISTRY.length} active)`,
+        hooks,
+    };
+}
+/**
+ * hooks.json 파일을 생성하여 저장합니다.
+ * @returns 생성된 훅 수와 비활성화된 훅 수
+ */
+export function writeHooksJson(hooksDir, options) {
+    const json = generateHooksJson(options);
+    // 활성 훅 수 계산
+    let active = 0;
+    for (const matchers of Object.values(json.hooks)) {
+        for (const m of matchers)
+            active += m.hooks.length;
+    }
+    const disabled = HOOK_REGISTRY.length - active;
+    const outputPath = path.join(hooksDir, 'hooks.json');
+    fs.mkdirSync(hooksDir, { recursive: true });
+    fs.writeFileSync(outputPath, `${JSON.stringify(json, null, 2)}\n`);
+    return { active, disabled };
+}

package/dist/hooks/intent-classifier.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+/**
+ * Forgen — Intent Classifier Hook
+ *
+ * Claude Code UserPromptSubmit 훅으로 등록.
+ * 사용자 프롬프트를 분석하여 의도를 분류하고, 의도별 가이드를 주입합니다.
+ *
+ * stdin: JSON { prompt: string, ... }
+ * stdout: JSON { result: "approve", message?: string }
+ */
+export type Intent = 'implement' | 'debug' | 'refactor' | 'explain' | 'review' | 'explore' | 'design' | 'general';
+export declare function classifyIntent(prompt: string): Intent;

package/dist/hooks/intent-classifier.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+/**
+ * Forgen — Intent Classifier Hook
+ *
+ * Claude Code UserPromptSubmit 훅으로 등록.
+ * 사용자 프롬프트를 분석하여 의도를 분류하고, 의도별 가이드를 주입합니다.
+ *
+ * stdin: JSON { prompt: string, ... }
+ * stdout: JSON { result: "approve", message?: string }
+ */
+import { readStdinJSON } from './shared/read-stdin.js';
+import { isHookEnabled } from './hook-config.js';
+import { approve, approveWithContext, failOpen } from './shared/hook-response.js';
+const INTENT_RULES = [
+    { intent: 'implement', pattern: /(?:만들어|추가해|구현해|생성해|작성해|넣어|create|add|implement|build|write|make)\b/i },
+    { intent: 'debug', pattern: /(?:에러|버그|안돼|안\s*되|안\s*됨|왜|고쳐|수정해|fix|bug|error|debug|문제|실패|fail|crash|broken)/i },
+    { intent: 'refactor', pattern: /(?:리팩토링|리팩터|정리|개선|refactor|clean\s*up|improve|optimize|최적화)/i },
+    { intent: 'explain', pattern: /(?:설명|알려|뭐야|뭔가요|어떻게|explain|what\s+is|how\s+does|why\s+does|tell\s+me)/i },
+    { intent: 'review', pattern: /(?:리뷰|검토|review|check|audit|평가)/i },
+    { intent: 'explore', pattern: /(?:찾아|어디|검색|find|search|where|locate|grep|어디에|어디서)/i },
+    { intent: 'design', pattern: /(?:설계|아키텍처|구조|design|architect|structure|다이어그램|diagram)/i },
+];
+const INTENT_HINTS = {
+    implement: 'Implementation task. Consider tests.',
+    debug: 'Debug mode. Approach: reproduce → isolate → fix.',
+    refactor: 'Refactoring task. Improve structure while preserving existing behavior.',
+    explain: 'Explanation request. Convey core concepts concisely.',
+    review: 'Code review. Classify feedback by severity.',
+    explore: 'Exploration task. Use Glob/Grep to find quickly.',
+    design: 'Design task. Specify trade-offs explicitly.',
+    general: 'General request.',
+};
+export function classifyIntent(prompt) {
+    for (const rule of INTENT_RULES) {
+        if (rule.pattern.test(prompt)) {
+            return rule.intent;
+        }
+    }
+    return 'general';
+}
+async function main() {
+    const input = await readStdinJSON();
+    if (!isHookEnabled('intent-classifier')) {
+        console.log(approve());
+        return;
+    }
+    if (!input?.prompt) {
+        console.log(approve());
+        return;
+    }
+    const intent = classifyIntent(input.prompt);
+    if (intent === 'general') {
+        console.log(approve());
+        return;
+    }
+    const hint = INTENT_HINTS[intent];
+    console.log(approveWithContext(`[intent: ${intent}] ${hint}`, 'UserPromptSubmit'));
+}
+main().catch((e) => {
+    process.stderr.write(`[ch-hook] ${e instanceof Error ? e.message : String(e)}\n`);
+    console.log(failOpen());
+});

package/dist/hooks/keyword-detector.d.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+/**
+ * Forgen — Keyword Detector Hook
+ *
+ * Claude Code UserPromptSubmit 훅으로 등록.
+ * 사용자 프롬프트에서 매직 키워드를 감지하여 해당 스킬을 주입합니다.
+ *
+ * stdin: JSON { prompt: string, ... }
+ * stdout: JSON { result: "block"|"approve", message?: string }
+ */
+export interface KeywordMatch {
+    type: 'skill' | 'inject' | 'cancel';
+    keyword: string;
+    skill?: string;
+    prompt?: string;
+    message?: string;
+}
+export declare function shouldTrackWorkflowActivation(match: KeywordMatch): boolean;
+export declare const KEYWORD_PATTERNS: Array<{
+    pattern: RegExp;
+    keyword: string;
+    type: 'skill' | 'inject' | 'cancel';
+    skill?: string;
+}>;
+export declare function detectKeyword(prompt: string): KeywordMatch | null;