oh-my-harness 0.4.1 → 0.5.0

package/README.md

@@ -368,6 +368,24 @@ No code changes required. The registry auto-discovers it.
 
 ---
 
+## Contributing
+
+Contributions are welcome! Please read the [Contributing Guide](CONTRIBUTING.md) before submitting a PR.
+
+---
+
+## Support This Project
+
+oh-my-harness is free and open source. Here's how you can help:
+
+- **Star** — [Give a star](https://github.com/kyu1204/oh-my-harness) to help others discover the project
+- **Report Bugs** — [Open an issue](https://github.com/kyu1204/oh-my-harness/issues/new) when something doesn't work
+- **Request Features** — [Suggest ideas](https://github.com/kyu1204/oh-my-harness/issues/new) for new presets, hooks, or emitters
+- **Contribute** — Fix a bug, add a preset, or improve docs — PRs are always welcome
+- **Spread the Word** — Share oh-my-harness with your team or community
+
+---
+
 ## License
 
 MIT

package/dist/catalog/converter.js

@@ -1,5 +1,5 @@
 import path from "path";
-import { renderTemplate, validateParams } from "./template-engine.js";
+import { renderTemplate, validateParams, applyDefaults } from "./template-engine.js";
 export async function convertHookEntries(entries, registry, projectDir) {
     const hooksConfig = {};
     const scripts = new Map();
@@ -11,7 +11,8 @@ export async function convertHookEntries(entries, registry, projectDir) {
             errors.push(`Unknown block id: "${entry.block}"`);
             continue;
         }
-        const paramErrors = validateParams(block, entry.params);
+        const resolvedParams = applyDefaults(block, entry.params);
+        const paramErrors = validateParams(block, resolvedParams);
         if (paramErrors.length > 0) {
             errors.push(...paramErrors);
             continue;
@@ -23,7 +24,7 @@ export async function convertHookEntries(entries, registry, projectDir) {
         seenBlockIds.add(entry.block);
         let scriptContent;
         try {
-            scriptContent = renderTemplate(block.template, entry.params);
+            scriptContent = renderTemplate(block.template, resolvedParams);
         }
         catch (err) {
             errors.push(`Failed to render block "${entry.block}": ${err.message}`);

package/dist/catalog/template-engine.d.ts

@@ -1,3 +1,4 @@
 import type { BuildingBlock } from "./types.js";
 export declare function renderTemplate(template: string, params: Record<string, unknown>): string;
+export declare function applyDefaults(block: BuildingBlock, params: Record<string, unknown>): Record<string, unknown>;
 export declare function validateParams(block: BuildingBlock, params: Record<string, unknown>): string[];

package/dist/catalog/template-engine.js

@@ -3,6 +3,15 @@ export function renderTemplate(template, params) {
     const compiled = Handlebars.compile(template);
     return compiled(params);
 }
+export function applyDefaults(block, params) {
+    const result = { ...params };
+    for (const param of block.params) {
+        if (result[param.name] === undefined && param.default !== undefined) {
+            result[param.name] = param.default;
+        }
+    }
+    return result;
+}
 export function validateParams(block, params) {
     const errors = [];
     for (const param of block.params) {

package/dist/catalog/types.d.ts

@@ -109,11 +109,11 @@ export declare const BuildingBlockSchema: z.ZodObject<{
 }>;
 export declare const HookEntrySchema: z.ZodObject<{
     block: z.ZodString;
-    params: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
 }, "strip", z.ZodTypeAny, {
     params: Record<string, unknown>;
     block: string;
 }, {
-    params: Record<string, unknown>;
     block: string;
+    params?: Record<string, unknown> | undefined;
 }>;

package/dist/catalog/types.js

@@ -20,5 +20,5 @@ export const BuildingBlockSchema = z.object({
 });
 export const HookEntrySchema = z.object({
     block: z.string(),
-    params: z.record(z.unknown()),
+    params: z.record(z.unknown()).default({}),
 });

package/dist/cli/command-checker.d.ts

@@ -0,0 +1,15 @@
+export interface CommandCheckResult {
+    command: string;
+    category: string;
+    executable: boolean;
+    error?: string;
+}
+export declare function extractExecutable(command: string): string;
+export declare function checkCommandExecutable(binary: string): Promise<boolean>;
+export declare function extractPreCommitCommands(hookContent: string): string[];
+export declare function extractPostSaveCommands(hookContent: string): string[];
+export declare function checkHarnessCommands(hooks: {
+    event: string;
+    matcher: string;
+    command: string;
+}[], projectDir: string): Promise<CommandCheckResult[]>;

package/dist/cli/command-checker.js

@@ -0,0 +1,104 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+// 명령어에서 바이너리 추출 (첫 토큰, 래퍼 처리)
+export function extractExecutable(command) {
+    const parts = command.trim().split(/\s+/);
+    // npm run X → npm
+    // npx X → npx
+    // bash script.sh → bash
+    return parts[0];
+}
+// 명령어 실행 가능 여부 확인
+export async function checkCommandExecutable(binary) {
+    try {
+        await execFileAsync("which", [binary]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+// pre-commit hook 스크립트에서 실행되는 명령어 추출
+export function extractPreCommitCommands(hookContent) {
+    const commands = [];
+    // 패턴: if ! <command> 또는 직접 명령 실행
+    const matches = hookContent.matchAll(/if\s+!\s+(.+?)\s+>&?2/g);
+    for (const match of matches) {
+        commands.push(match[1].trim());
+    }
+    return commands;
+}
+// post-save hook 스크립트에서 실행되는 명령어 추출
+export function extractPostSaveCommands(hookContent) {
+    const commands = [];
+    // 패턴: <command> "$FILE_PATH" 또는 <command> --fix "$FILE_PATH"
+    const lines = hookContent.split("\n");
+    for (const line of lines) {
+        const trimmed = line.trim();
+        // eslint --fix "$FILE_PATH" 패턴
+        if (trimmed.includes("$FILE_PATH") &&
+            !trimmed.startsWith("#") &&
+            !trimmed.startsWith("if") &&
+            !trimmed.startsWith("FILE_PATH") &&
+            !trimmed.startsWith("BASENAME") &&
+            !trimmed.startsWith("echo ")) {
+            const cmd = trimmed.split(/\s+"\$FILE_PATH"/)[0].trim();
+            if (cmd && !cmd.startsWith("[")) {
+                commands.push(cmd);
+            }
+        }
+    }
+    return commands;
+}
+// 전체 명령어 체크
+export async function checkHarnessCommands(hooks, projectDir) {
+    const results = [];
+    const fs = await import("node:fs/promises");
+    const path = await import("node:path");
+    for (const hook of hooks) {
+        const scriptPath = hook.command.replace(/^bash\s+/, "");
+        const fullPath = path.join(projectDir, scriptPath);
+        let content;
+        try {
+            content = await fs.readFile(fullPath, "utf-8");
+        }
+        catch {
+            continue; // 스크립트 파일 없으면 스킵
+        }
+        const scriptName = path.basename(scriptPath);
+        // pre-commit gate류 — 파일명 매칭 확장 + 내용 기반 감지
+        if (scriptName.includes("pre-commit") ||
+            scriptName.includes("test-gate") ||
+            scriptName.includes("typecheck-gate") ||
+            scriptName.includes("before-commit") ||
+            /if\s+!\s+.+\s+>&?2/.test(content)) {
+            const commands = extractPreCommitCommands(content);
+            const isTypecheck = scriptName.includes("typecheck") || commands.some((c) => /\btsc\b/.test(c));
+            const category = isTypecheck ? "commit-typecheck-gate" : "commit-test-gate";
+            for (const cmd of commands) {
+                const binary = extractExecutable(cmd);
+                const executable = await checkCommandExecutable(binary);
+                results.push({ command: cmd, category, executable });
+            }
+        }
+        // post-save류 (lint-on-save, format-on-save)
+        if (scriptName.includes("post-save") ||
+            scriptName.includes("lint-on-save") ||
+            scriptName.includes("format-on-save")) {
+            const commands = extractPostSaveCommands(content);
+            const category = scriptName.includes("format") ? "format-on-save" : "lint-on-save";
+            for (const cmd of commands) {
+                const binary = extractExecutable(cmd);
+                const executable = await checkCommandExecutable(binary);
+                results.push({ command: cmd, category, executable });
+            }
+        }
+        // auto-pr (gh CLI 체크)
+        if (scriptName.includes("auto-pr")) {
+            const hasGh = await checkCommandExecutable("gh");
+            results.push({ command: "gh", category: "auto-pr", executable: hasGh });
+        }
+    }
+    return results;
+}

package/dist/cli/commands/test.d.ts

@@ -0,0 +1,12 @@
+import type { TestResult } from "../harness-tester.js";
+import type { CommandCheckResult } from "../command-checker.js";
+export interface TestCommandOptions {
+    projectDir?: string;
+}
+export declare function formatCategoryName(category: string): string;
+export declare function testCommand(options?: TestCommandOptions): Promise<{
+    passed: number;
+    failed: number;
+    results: TestResult[];
+    commandResults: CommandCheckResult[];
+}>;

package/dist/cli/commands/test.js

@@ -0,0 +1,146 @@
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+import fs from "node:fs/promises";
+import path from "node:path";
+import yaml from "js-yaml";
+import { getRegisteredHooks, generateTestCases, generateBlockTestCases, runTestCase } from "../harness-tester.js";
+import { checkHarnessCommands } from "../command-checker.js";
+import { HarnessConfigSchema } from "../../core/harness-schema.js";
+import { builtinBlocks } from "../../catalog/blocks/index.js";
+export function formatCategoryName(category) {
+    const names = {
+        "path-guard": "File guards",
+        "command-guard": "Command guards",
+        "branch-guard": "Branch guard",
+        "lockfile-guard": "Lockfile guard",
+        "secret-file-guard": "Secret file guard",
+        "commit-test-gate": "Pre-commit test gate",
+        "commit-typecheck-gate": "Pre-commit typecheck gate",
+        "lint-on-save": "Lint on save",
+        "format-on-save": "Format on save",
+        "auto-pr": "Auto PR",
+        "tdd-guard": "TDD Guard",
+    };
+    return names[category] ?? category;
+}
+export async function testCommand(options = {}) {
+    const projectDir = options.projectDir ?? process.cwd();
+    // 1. harness.yaml 읽기
+    const harnessPath = path.join(projectDir, "harness.yaml");
+    let enforcement = { blockedPaths: [], blockedCommands: [] };
+    let hookEntries = [];
+    try {
+        const raw = await fs.readFile(harnessPath, "utf-8");
+        const parsed = yaml.load(raw);
+        const result = HarnessConfigSchema.safeParse(parsed);
+        if (result.success) {
+            enforcement = {
+                blockedPaths: result.data.enforcement.blockedPaths,
+                blockedCommands: result.data.enforcement.blockedCommands,
+            };
+            hookEntries = result.data.hooks ?? [];
+        }
+        else {
+            console.log(chalk.yellow(`Warning: harness.yaml schema validation failed: ${result.error.message}`));
+        }
+    }
+    catch (err) {
+        const error = err;
+        if (error.code !== "ENOENT") {
+            console.log(chalk.red(`Error reading harness.yaml: ${error.message}`));
+            process.exit(1);
+        }
+        // ENOENT: harness.yaml 없으면 settings.json만으로 진행
+    }
+    // 2. settings.json에서 등록된 hook 가져오기
+    let hooks;
+    try {
+        hooks = await getRegisteredHooks(projectDir);
+    }
+    catch (err) {
+        const error = err;
+        if (error.code === "ENOENT") {
+            console.log(chalk.red("harness not initialized. Run `omh init` first."));
+        }
+        else {
+            console.log(chalk.red(`Failed to read settings.json: ${error.message}`));
+        }
+        process.exit(1);
+    }
+    if (hooks.length === 0) {
+        console.log(chalk.yellow("No hooks registered in settings.json."));
+        return { passed: 0, failed: 0, results: [], commandResults: [] };
+    }
+    // 3. 시뮬레이션 테스트 케이스 생성 + 실행
+    p.intro(`${chalk.bgCyan(chalk.black(" omh test "))} ${chalk.dim("Harness dry-run verification")}`);
+    // 현재 브랜치 가져오기
+    let currentBranch;
+    try {
+        const { execFile: execFileCb } = await import("node:child_process");
+        const { promisify: promisifyFn } = await import("node:util");
+        const execFileAsync = promisifyFn(execFileCb);
+        const { stdout } = await execFileAsync("git", ["branch", "--show-current"], { cwd: projectDir });
+        currentBranch = stdout.trim() || undefined;
+    }
+    catch {
+        // git 없으면 undefined
+    }
+    const enforcementCases = generateTestCases(hooks, enforcement, currentBranch);
+    const blockCases = generateBlockTestCases(hookEntries, builtinBlocks, currentBranch);
+    // Block cases take priority — only keep enforcement cases for categories not covered by blocks
+    const blockCategories = new Set(blockCases.map((c) => c.category));
+    const uniqueEnforcementCases = enforcementCases.filter((c) => !blockCategories.has(c.category));
+    const testCases = [...uniqueEnforcementCases, ...blockCases];
+    const results = [];
+    // 카테고리별 그룹핑
+    const categories = [...new Set(testCases.map((tc) => tc.category))];
+    for (const category of categories) {
+        const casesInCategory = testCases.filter((tc) => tc.category === category);
+        const categoryResults = [];
+        for (const tc of casesInCategory) {
+            const result = await runTestCase(projectDir, tc);
+            categoryResults.push(result);
+            results.push(result);
+        }
+        // 카테고리 출력
+        const lines = categoryResults.map((r) => {
+            if (r.passed) {
+                return `  ${chalk.green("✓")} ${r.testCase.name}`;
+            }
+            else {
+                const hint = r.error ?? `expected ${r.testCase.expectation} but got ${r.actual}`;
+                return `  ${chalk.red("✗")} ${r.testCase.name}\n    ${chalk.dim(hint)}`;
+            }
+        });
+        p.note(lines.join("\n"), formatCategoryName(category));
+    }
+    // 4. 명령어 실행 가능 체크
+    const commandResults = await checkHarnessCommands(hooks, projectDir);
+    if (commandResults.length > 0) {
+        const cmdLines = commandResults.map((r) => {
+            if (r.executable) {
+                return `  ${chalk.green("✓")} ${r.command} — executable`;
+            }
+            else {
+                return `  ${chalk.red("✗")} ${r.command} — ${chalk.red("not found")}`;
+            }
+        });
+        p.note(cmdLines.join("\n"), "Command checks");
+    }
+    // 5. 결과 요약
+    const hookPassed = results.filter((r) => r.passed).length;
+    const hookFailed = results.filter((r) => !r.passed).length;
+    const cmdPassed = commandResults.filter((r) => r.executable).length;
+    const cmdFailed = commandResults.filter((r) => !r.executable).length;
+    const totalPassed = hookPassed + cmdPassed;
+    const totalFailed = hookFailed + cmdFailed;
+    const total = totalPassed + totalFailed;
+    if (totalFailed === 0) {
+        p.outro(chalk.green(`${totalPassed}/${total} checks passed ✓`));
+    }
+    else {
+        p.outro(chalk.red(`${totalFailed}/${total} checks failed`));
+        process.exit(1);
+    }
+    return { passed: totalPassed, failed: totalFailed, results, commandResults };
+}

package/dist/cli/event-verifier.d.ts

@@ -0,0 +1,8 @@
+import { type HookEvent } from "./event-logger.js";
+export interface EventVerification {
+    verified: boolean;
+    matchedEvent?: HookEvent;
+    warning?: string;
+}
+export declare function getEventSnapshot(projectDir: string): Promise<number>;
+export declare function verifyEventLogged(projectDir: string, snapshotCount: number, expectedHook: string, expectedDecision: "block" | "allow"): Promise<EventVerification>;

package/dist/cli/event-verifier.js

@@ -0,0 +1,29 @@
+import { readEvents } from "./event-logger.js";
+// 테스트 실행 전 스냅샷 카운트 가져오기
+export async function getEventSnapshot(projectDir) {
+    const events = await readEvents(projectDir);
+    return events.length;
+}
+// 테스트 실행 후 새 이벤트에서 hook 매칭 확인
+export async function verifyEventLogged(projectDir, snapshotCount, expectedHook, expectedDecision) {
+    const events = await readEvents(projectDir);
+    const newEvents = events.slice(snapshotCount);
+    if (newEvents.length === 0) {
+        return { verified: false, warning: "No new events recorded in events.jsonl" };
+    }
+    // hook 이름 매칭 (정규화 후 동등 비교: catalog-command-guard.sh → command-guard)
+    const normalize = (name) => name.replace(/\.sh$/, "").replace(/^catalog-/, "").replace(/^harness-/, "");
+    const normalizedExpected = normalize(expectedHook);
+    const matched = newEvents.find((e) => normalize(e.hook) === normalizedExpected);
+    if (!matched) {
+        return { verified: false, warning: `No event found for hook "${expectedHook}"` };
+    }
+    if (matched.decision !== expectedDecision) {
+        return {
+            verified: false,
+            matchedEvent: matched,
+            warning: `Event logged decision="${matched.decision}" but expected "${expectedDecision}"`,
+        };
+    }
+    return { verified: true, matchedEvent: matched };
+}

package/dist/cli/harness-tester.d.ts

@@ -0,0 +1,41 @@
+import type { HookEntry, BuildingBlock } from "../catalog/types.js";
+export interface HookInput {
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+}
+export interface HookResult {
+    decision: "block" | "allow";
+    reason?: string;
+}
+export interface TestCase {
+    name: string;
+    category: string;
+    hookScript: string;
+    input: HookInput;
+    expectation: "block" | "allow";
+    setup?: (projectDir: string) => Promise<void>;
+    teardown?: (projectDir: string) => Promise<void>;
+}
+export interface TestResult {
+    testCase: TestCase;
+    actual: "block" | "allow";
+    passed: boolean;
+    reason?: string;
+    error?: string;
+}
+export declare function simulateHook(hookPath: string, input: HookInput, cwd?: string): Promise<HookResult>;
+export declare function getRegisteredHooks(projectDir: string): Promise<{
+    event: string;
+    matcher: string;
+    command: string;
+}[]>;
+export declare function generateTestCases(hooks: {
+    event: string;
+    matcher: string;
+    command: string;
+}[], enforcement: {
+    blockedPaths?: string[];
+    blockedCommands?: string[];
+}, currentBranch?: string): TestCase[];
+export declare function runTestCase(projectDir: string, testCase: TestCase): Promise<TestResult>;
+export declare function generateBlockTestCases(hookEntries: HookEntry[], blocks: BuildingBlock[], currentBranch?: string): TestCase[];