@hiro-c/agent-gate 1.0.0

package/dist/cli/agent-gate.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { ValidationResult } from '../contracts/types/ValidationResult';
+import { Adapter } from '../adapters/Adapter';
+export declare function run(input: string, adapter?: Adapter): Promise<ValidationResult>;
+interface ParsedArgs {
+    positional: string[];
+    agentId: string;
+    showHelp: boolean;
+    showVersion: boolean;
+}
+export declare function parseArgs(args: string[]): ParsedArgs;
+export {};
+//# sourceMappingURL=agent-gate.d.ts.map

package/dist/cli/agent-gate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-gate.d.ts","sourceRoot":"","sources":["../../src/cli/agent-gate.ts"],"names":[],"mappings":";AAIA,OAAO,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAA;AAYtE,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAsC7C,wBAAsB,GAAG,CACvB,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,OAAO,GAChB,OAAO,CAAC,gBAAgB,CAAC,CAE3B;AAsGD,UAAU,UAAU;IAClB,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;IACjB,WAAW,EAAE,OAAO,CAAA;CACrB;AAED,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,UAAU,CAgCpD"}

package/dist/cli/agent-gate.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = run;
+exports.parseArgs = parseArgs;
+const fs_1 = require("fs");
+const processHookData_1 = require("../hooks/processHookData");
+const installer_1 = require("./installer");
+const adapters_1 = require("../adapters");
+const stats_1 = require("../observability/stats");
+const decisionLogger_1 = require("../observability/decisionLogger");
+const collectRuleSources_1 = require("../collector/collectRuleSources");
+const lintRuleSources_1 = require("../doctor/lintRuleSources");
+const formatFindings_1 = require("../doctor/formatFindings");
+const server_1 = require("../daemon/server");
+const client_1 = require("../daemon/client");
+const protocol_1 = require("../daemon/protocol");
+const HELP_TEXT = `agent-gate — runtime enforcer for AI coding agent rules
+
+Usage:
+  agent-gate                        Run as a hook (reads JSON from stdin)
+  agent-gate --agent <id>           Use the named adapter (default: claude-code)
+  agent-gate install                Register the hook in ~/.claude/settings.json
+  agent-gate uninstall              Remove the hook from ~/.claude/settings.json
+  agent-gate stats                  Summarize decisions from the log file
+  agent-gate lint                   Audit CLAUDE.md / AGENTS.md / etc. for AI-friendliness
+  agent-gate daemon                 Start the long-lived daemon (Unix socket)
+  agent-gate --help                 Show this help
+  agent-gate --version              Show version
+
+Adapters (use with --agent):
+  ${(0, adapters_1.availableAdapterIds)().join(', ')}
+
+Environment:
+  AGENT_GATE_MODEL              Validation model (default: claude-sonnet-4-6)
+  AGENT_GATE_API_KEY            Use Anthropic API directly when set
+  AGENT_GATE_COOLDOWN           Cooldown in seconds between AI validations
+  AGENT_GATE_DISABLED           Set to "true" to disable the whole tool
+  AGENT_GATE_DISABLED_RULES     Comma-separated rule ids to disable
+  AGENT_GATE_LOG                Set to "1" to write decisions to ~/.agent-gate/log.jsonl
+  AGENT_GATE_DAEMON             Set to "1" to route hook calls through the daemon
+  AGENT_GATE_SOCKET_PATH        Daemon socket path (default: $TMPDIR/agent-gate.sock)
+  USE_SYSTEM_CLAUDE             Set to "true" to force PATH claude binary
+`;
+async function run(input, adapter) {
+    return (0, processHookData_1.processHookData)(input, adapter ? { adapter } : undefined);
+}
+function runHookMode(adapter) {
+    let inputData = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', (chunk) => {
+        inputData += chunk;
+    });
+    process.stdin.on('end', async () => {
+        try {
+            if (process.env.AGENT_GATE_DAEMON === '1') {
+                const socketPath = process.env.AGENT_GATE_SOCKET_PATH ?? (0, protocol_1.defaultSocketPath)();
+                const resp = await (0, client_1.sendToDaemon)({ adapter: adapter.id, payload: inputData, cwd: process.cwd() }, { socketPath, timeoutMs: 2000 });
+                if (resp !== null) {
+                    console.log(resp.output);
+                    process.exit(0);
+                }
+                // Daemon unreachable: fall through to direct mode.
+            }
+            const result = await run(inputData, adapter);
+            console.log(adapter.formatResponse(result));
+        }
+        catch (error) {
+            console.error('agent-gate error:', error);
+        }
+        finally {
+            process.exit(0);
+        }
+    });
+}
+async function runDaemon() {
+    const socketPath = process.env.AGENT_GATE_SOCKET_PATH ?? (0, protocol_1.defaultSocketPath)();
+    const server = new server_1.DaemonServer({
+        socketPath,
+        handler: async (req) => {
+            const adapter = (0, adapters_1.getAdapter)(req.adapter);
+            if (!adapter) {
+                return {
+                    output: JSON.stringify({
+                        error: `unknown adapter: ${req.adapter}`,
+                    }),
+                };
+            }
+            const result = await (0, processHookData_1.processHookData)(req.payload, {
+                adapter,
+                cwd: req.cwd,
+            });
+            return { output: adapter.formatResponse(result) };
+        },
+    });
+    await server.start();
+    console.log(`agent-gate daemon listening on ${socketPath}`);
+    const shutdown = async () => {
+        await server.stop();
+        process.exit(0);
+    };
+    process.on('SIGINT', () => void shutdown());
+    process.on('SIGTERM', () => void shutdown());
+}
+function runInstall() {
+    const rawScriptPath = process.argv[1] ?? '';
+    let effectivePath = '';
+    try {
+        if (rawScriptPath) {
+            effectivePath = (0, fs_1.realpathSync)(rawScriptPath);
+        }
+    }
+    catch {
+        effectivePath = '';
+    }
+    const hookCommand = (0, installer_1.resolveHookCommand)(effectivePath);
+    const settingsFile = (0, installer_1.defaultSettingsPath)();
+    (0, installer_1.installHook)(hookCommand, settingsFile);
+    console.log(`agent-gate installed.`);
+    console.log(`  settings: ${settingsFile}`);
+    console.log(`  command:  ${hookCommand}`);
+    console.log(`Restart Claude Code to activate.`);
+}
+function runUninstall() {
+    const settingsFile = (0, installer_1.defaultSettingsPath)();
+    (0, installer_1.uninstallHook)(settingsFile);
+    console.log(`agent-gate uninstalled.`);
+    console.log(`  settings: ${settingsFile}`);
+    console.log(`Restart Claude Code to deactivate.`);
+}
+function printVersion() {
+    const pkg = require('../../package.json');
+    console.log(pkg.version ?? 'unknown');
+}
+function parseArgs(args) {
+    let agentId = adapters_1.DEFAULT_ADAPTER_ID;
+    let showHelp = false;
+    let showVersion = false;
+    const positional = [];
+    for (let i = 0; i < args.length; i++) {
+        const a = args[i];
+        if (a === '--agent') {
+            const next = args[i + 1];
+            if (next) {
+                agentId = next;
+                i++;
+            }
+            continue;
+        }
+        if (a.startsWith('--agent=')) {
+            agentId = a.slice('--agent='.length);
+            continue;
+        }
+        if (a === '--help' || a === '-h' || a === 'help') {
+            showHelp = true;
+            continue;
+        }
+        if (a === '--version' || a === '-v') {
+            showVersion = true;
+            continue;
+        }
+        positional.push(a);
+    }
+    return { positional, agentId, showHelp, showVersion };
+}
+function main() {
+    const parsedArgs = parseArgs(process.argv.slice(2));
+    if (parsedArgs.showHelp) {
+        console.log(HELP_TEXT);
+        return;
+    }
+    if (parsedArgs.showVersion) {
+        printVersion();
+        return;
+    }
+    const adapter = (0, adapters_1.getAdapter)(parsedArgs.agentId);
+    if (!adapter) {
+        console.error(`Unknown adapter: ${parsedArgs.agentId}. Available: ${(0, adapters_1.availableAdapterIds)().join(', ')}`);
+        process.exit(1);
+    }
+    const subcommand = parsedArgs.positional[0];
+    switch (subcommand) {
+        case undefined:
+            runHookMode(adapter);
+            return;
+        case 'install':
+            runInstall();
+            return;
+        case 'uninstall':
+            runUninstall();
+            return;
+        case 'stats':
+            runStats();
+            return;
+        case 'lint':
+            runLint();
+            return;
+        case 'daemon':
+            void runDaemon();
+            return;
+        default:
+            console.error(`Unknown subcommand: ${subcommand}`);
+            console.error(HELP_TEXT);
+            process.exit(1);
+    }
+}
+function runStats() {
+    const stats = (0, stats_1.readStats)((0, decisionLogger_1.defaultLogPath)());
+    console.log((0, stats_1.formatStats)(stats));
+}
+function runLint() {
+    const sources = (0, collectRuleSources_1.collectRuleSources)(process.cwd());
+    if (sources.length === 0) {
+        console.log('No instruction files found (looked for CLAUDE.md, AGENTS.md, .cursorrules, .cursor/rules/*.mdc, .clinerules/*.md, .windsurf/rules/*.md, .github/copilot-instructions.md, CONVENTIONS.md).');
+        return;
+    }
+    const findings = (0, lintRuleSources_1.lintRuleSources)(sources);
+    console.log((0, formatFindings_1.formatFindings)(findings));
+    const hasError = findings.some((f) => f.severity === 'error');
+    if (hasError) {
+        process.exitCode = 1;
+    }
+}
+if (require.main === module) {
+    main();
+}

package/dist/cli/installer.d.ts

@@ -0,0 +1,21 @@
+export declare const DEFAULT_HOOK_MATCHER = "Edit|Write|Bash";
+export interface HookCommandEntry {
+    type: string;
+    command: string;
+}
+export interface HookMatcherEntry {
+    matcher?: string;
+    hooks?: HookCommandEntry[];
+}
+export interface ClaudeSettings {
+    hooks?: {
+        PreToolUse?: HookMatcherEntry[];
+        [key: string]: HookMatcherEntry[] | undefined;
+    };
+    [key: string]: unknown;
+}
+export declare function defaultSettingsPath(): string;
+export declare function resolveHookCommand(resolvedScriptPath: string): string;
+export declare function installHook(hookCommand: string, settingsFile?: string, matcher?: string): ClaudeSettings;
+export declare function uninstallHook(settingsFile?: string): ClaudeSettings;
+//# sourceMappingURL=installer.d.ts.map

package/dist/cli/installer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installer.d.ts","sourceRoot":"","sources":["../../src/cli/installer.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,oBAAoB,oBAAoB,CAAA;AAErD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,KAAK,CAAC,EAAE,gBAAgB,EAAE,CAAA;CAC3B;AAED,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE;QACN,UAAU,CAAC,EAAE,gBAAgB,EAAE,CAAA;QAC/B,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,EAAE,GAAG,SAAS,CAAA;KAC9C,CAAA;IACD,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED,wBAAgB,kBAAkB,CAAC,kBAAkB,EAAE,MAAM,GAAG,MAAM,CAKrE;AAwBD,wBAAgB,WAAW,CACzB,WAAW,EAAE,MAAM,EACnB,YAAY,GAAE,MAA8B,EAC5C,OAAO,GAAE,MAA6B,GACrC,cAAc,CAiBhB;AAED,wBAAgB,aAAa,CAC3B,YAAY,GAAE,MAA8B,GAC3C,cAAc,CAyBhB"}

package/dist/cli/installer.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_HOOK_MATCHER = void 0;
+exports.defaultSettingsPath = defaultSettingsPath;
+exports.resolveHookCommand = resolveHookCommand;
+exports.installHook = installHook;
+exports.uninstallHook = uninstallHook;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+exports.DEFAULT_HOOK_MATCHER = 'Edit|Write|Bash';
+function defaultSettingsPath() {
+    return (0, path_1.join)((0, os_1.homedir)(), '.claude', 'settings.json');
+}
+function resolveHookCommand(resolvedScriptPath) {
+    if (!resolvedScriptPath) {
+        return 'agent-gate';
+    }
+    return `node ${resolvedScriptPath}`;
+}
+function readSettings(settingsFile) {
+    if (!(0, fs_1.existsSync)(settingsFile)) {
+        return {};
+    }
+    const content = (0, fs_1.readFileSync)(settingsFile, 'utf-8');
+    if (content.trim() === '') {
+        return {};
+    }
+    return JSON.parse(content);
+}
+function writeSettings(settingsFile, settings) {
+    (0, fs_1.mkdirSync)((0, path_1.dirname)(settingsFile), { recursive: true });
+    (0, fs_1.writeFileSync)(settingsFile, JSON.stringify(settings, null, 2) + '\n');
+}
+function isAgentGateEntry(entry) {
+    return (entry.hooks ?? []).some((h) => typeof h.command === 'string' && h.command.includes('agent-gate'));
+}
+function installHook(hookCommand, settingsFile = defaultSettingsPath(), matcher = exports.DEFAULT_HOOK_MATCHER) {
+    const settings = readSettings(settingsFile);
+    if (!settings.hooks)
+        settings.hooks = {};
+    const preToolUse = settings.hooks.PreToolUse ?? [];
+    const filtered = preToolUse.filter((entry) => !isAgentGateEntry(entry));
+    filtered.push({
+        matcher,
+        hooks: [{ type: 'command', command: hookCommand }],
+    });
+    settings.hooks.PreToolUse = filtered;
+    writeSettings(settingsFile, settings);
+    return settings;
+}
+function uninstallHook(settingsFile = defaultSettingsPath()) {
+    if (!(0, fs_1.existsSync)(settingsFile)) {
+        return {};
+    }
+    const settings = readSettings(settingsFile);
+    if (settings.hooks?.PreToolUse) {
+        const cleaned = settings.hooks.PreToolUse.filter((entry) => !isAgentGateEntry(entry));
+        if (cleaned.length === 0) {
+            delete settings.hooks.PreToolUse;
+        }
+        else {
+            settings.hooks.PreToolUse = cleaned;
+        }
+        if (settings.hooks && Object.keys(settings.hooks).length === 0) {
+            delete settings.hooks;
+        }
+    }
+    writeSettings(settingsFile, settings);
+    return settings;
+}

package/dist/collector/collectClaudeMd.d.ts

@@ -0,0 +1,3 @@
+import { ClaudeMdFile } from '../contracts/types/ClaudeMdFile';
+export declare function collectClaudeMd(cwd: string): ClaudeMdFile[];
+//# sourceMappingURL=collectClaudeMd.d.ts.map

package/dist/collector/collectClaudeMd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectClaudeMd.d.ts","sourceRoot":"","sources":["../../src/collector/collectClaudeMd.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,MAAM,iCAAiC,CAAA;AAe9D,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,GAAG,YAAY,EAAE,CAY3D"}

package/dist/collector/collectClaudeMd.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectClaudeMd = collectClaudeMd;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const EXCLUDED_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'target',
+    '.venv',
+    'vendor',
+    '__pycache__',
+    'dist',
+    'build',
+]);
+const MAX_DEPTH = 3;
+function collectClaudeMd(cwd) {
+    const upward = collectUpward(cwd);
+    const downward = collectDownward(cwd);
+    // Deduplicate: upward already includes cwd/CLAUDE.md
+    const upwardPaths = new Set(upward.map((f) => f.path));
+    const combined = [
+        ...upward,
+        ...downward.filter((f) => !upwardPaths.has(f.path)),
+    ];
+    return combined;
+}
+function collectUpward(cwd) {
+    const files = [];
+    let dir = cwd;
+    while (true) {
+        const claudeMdPath = (0, path_1.join)(dir, 'CLAUDE.md');
+        const content = readFileSafe(claudeMdPath);
+        if (content !== null) {
+            files.push({ path: claudeMdPath, content });
+        }
+        const parent = (0, path_1.dirname)(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return files;
+}
+function collectDownward(cwd) {
+    const files = [];
+    walkDir(cwd, 0, files);
+    return files;
+}
+function walkDir(dir, depth, files) {
+    if (depth > MAX_DEPTH)
+        return;
+    let entries;
+    try {
+        entries = (0, fs_1.readdirSync)(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (EXCLUDED_DIRS.has(entry))
+            continue;
+        const fullPath = (0, path_1.join)(dir, entry);
+        if (entry === 'CLAUDE.md') {
+            const content = readFileSafe(fullPath);
+            if (content !== null) {
+                files.push({ path: fullPath, content });
+            }
+            continue;
+        }
+        try {
+            if ((0, fs_1.statSync)(fullPath).isDirectory()) {
+                walkDir(fullPath, depth + 1, files);
+            }
+        }
+        catch {
+            // Skip inaccessible entries
+        }
+    }
+}
+function readFileSafe(filePath) {
+    try {
+        return (0, fs_1.readFileSync)(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/collector/collectRuleSources.d.ts

@@ -0,0 +1,3 @@
+import { RuleSource } from '../contracts/types/RuleSource';
+export declare function collectRuleSources(cwd: string): RuleSource[];
+//# sourceMappingURL=collectRuleSources.d.ts.map

package/dist/collector/collectRuleSources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"collectRuleSources.d.ts","sourceRoot":"","sources":["../../src/collector/collectRuleSources.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,UAAU,EAAkB,MAAM,+BAA+B,CAAA;AA4D1E,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,EAAE,CAM5D"}

package/dist/collector/collectRuleSources.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectRuleSources = collectRuleSources;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const EXCLUDED_DIRS = new Set([
+    'node_modules',
+    '.git',
+    'target',
+    '.venv',
+    'vendor',
+    '__pycache__',
+    'dist',
+    'build',
+]);
+const MAX_DEPTH = 3;
+// Files looked up directly inside a candidate directory
+const DIRECT_FILES = [
+    { filename: 'CLAUDE.md', kind: 'claude-md' },
+    { filename: 'AGENTS.md', kind: 'agents-md' },
+    { filename: '.cursorrules', kind: 'cursorrules' },
+    { filename: 'CONVENTIONS.md', kind: 'aider-conventions' },
+];
+// Files looked up inside a known subdirectory of a candidate directory.
+// e.g. `<dir>/.cursor/rules/*.mdc` ; the parentDir here is `.cursor/rules`
+// or `.github` for copilot-instructions.md.
+const NESTED_FILES = [
+    {
+        parentDir: '.cursor/rules',
+        fileMatcher: (name) => name.endsWith('.mdc'),
+        kind: 'cursor-mdc',
+    },
+    {
+        parentDir: '.clinerules',
+        fileMatcher: (name) => name.endsWith('.md'),
+        kind: 'clinerules',
+    },
+    {
+        parentDir: '.windsurf/rules',
+        fileMatcher: (name) => name.endsWith('.md'),
+        kind: 'windsurf-rule',
+    },
+    {
+        parentDir: '.github',
+        fileMatcher: (name) => name === 'copilot-instructions.md',
+        kind: 'copilot-instructions',
+    },
+];
+function collectRuleSources(cwd) {
+    const upward = collectUpward(cwd);
+    const downward = collectDownward(cwd);
+    const upwardPaths = new Set(upward.map((f) => f.path));
+    return [...upward, ...downward.filter((f) => !upwardPaths.has(f.path))];
+}
+function collectUpward(cwd) {
+    const files = [];
+    let dir = cwd;
+    while (true) {
+        collectDirectFiles(dir, files);
+        collectNestedFiles(dir, files);
+        const parent = (0, path_1.dirname)(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return files;
+}
+function collectDownward(cwd) {
+    const files = [];
+    walkDir(cwd, 0, files);
+    return files;
+}
+function walkDir(dir, depth, files) {
+    if (depth > MAX_DEPTH)
+        return;
+    let entries;
+    try {
+        entries = (0, fs_1.readdirSync)(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (EXCLUDED_DIRS.has(entry))
+            continue;
+        const fullPath = (0, path_1.join)(dir, entry);
+        const directSpec = DIRECT_FILES.find((s) => s.filename === entry);
+        if (directSpec) {
+            const content = readFileSafe(fullPath);
+            if (content !== null) {
+                files.push({ path: fullPath, content, kind: directSpec.kind });
+            }
+            continue;
+        }
+        let isDir = false;
+        try {
+            isDir = (0, fs_1.statSync)(fullPath).isDirectory();
+        }
+        catch {
+            continue;
+        }
+        if (isDir) {
+            const nestedSpec = NESTED_FILES.find((s) => s.parentDir === entry);
+            if (nestedSpec) {
+                collectFromNestedDir(fullPath, nestedSpec, files);
+            }
+            walkDir(fullPath, depth + 1, files);
+        }
+    }
+}
+function collectDirectFiles(dir, files) {
+    for (const spec of DIRECT_FILES) {
+        const filePath = (0, path_1.join)(dir, spec.filename);
+        const content = readFileSafe(filePath);
+        if (content !== null) {
+            files.push({ path: filePath, content, kind: spec.kind });
+        }
+    }
+}
+function collectNestedFiles(dir, files) {
+    for (const spec of NESTED_FILES) {
+        const nestedDir = (0, path_1.join)(dir, spec.parentDir);
+        collectFromNestedDir(nestedDir, spec, files);
+    }
+}
+function collectFromNestedDir(nestedDir, spec, files) {
+    let entries;
+    try {
+        entries = (0, fs_1.readdirSync)(nestedDir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        if (!spec.fileMatcher(entry))
+            continue;
+        const fullPath = (0, path_1.join)(nestedDir, entry);
+        const content = readFileSafe(fullPath);
+        if (content !== null) {
+            files.push({ path: fullPath, content, kind: spec.kind });
+        }
+    }
+}
+function readFileSafe(filePath) {
+    try {
+        return (0, fs_1.readFileSync)(filePath, 'utf-8');
+    }
+    catch {
+        return null;
+    }
+}

package/dist/config/AgentGateConfig.d.ts

@@ -0,0 +1,18 @@
+import { AgentGatePluginConfig } from './defineConfig';
+/**
+ * The resolved configuration that the hook pipeline consumes.
+ *
+ * This is the same shape as AgentGatePluginConfig; both names exist
+ * so callers can pick the more descriptive one for their context.
+ */
+export type AgentGateConfig = AgentGatePluginConfig;
+/**
+ * Resolves the effective AgentGateConfig for the given cwd.
+ *
+ * Reads `.agent-gate.config.{ts,mts,mjs,cjs,js}` (preferred) or the
+ * legacy `.agent-gate.json`, walking upward from cwd. Merges the
+ * AGENT_GATE_DISABLED_RULES env var into disabledRules so command-line
+ * users can disable rules without touching the config file.
+ */
+export declare function loadAgentGateConfig(cwd: string): AgentGateConfig;
+//# sourceMappingURL=AgentGateConfig.d.ts.map

package/dist/config/AgentGateConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AgentGateConfig.d.ts","sourceRoot":"","sources":["../../src/config/AgentGateConfig.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAA;AAGtD;;;;;GAKG;AACH,MAAM,MAAM,eAAe,GAAG,qBAAqB,CAAA;AAanD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,MAAM,GAAG,eAAe,CAWhE"}

package/dist/config/AgentGateConfig.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadAgentGateConfig = loadAgentGateConfig;
+const PluginConfigLoader_1 = require("./PluginConfigLoader");
+const ENV_DISABLED_RULES = 'AGENT_GATE_DISABLED_RULES';
+function disabledFromEnv() {
+    const raw = process.env[ENV_DISABLED_RULES];
+    if (!raw)
+        return [];
+    return raw
+        .split(',')
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+/**
+ * Resolves the effective AgentGateConfig for the given cwd.
+ *
+ * Reads `.agent-gate.config.{ts,mts,mjs,cjs,js}` (preferred) or the
+ * legacy `.agent-gate.json`, walking upward from cwd. Merges the
+ * AGENT_GATE_DISABLED_RULES env var into disabledRules so command-line
+ * users can disable rules without touching the config file.
+ */
+function loadAgentGateConfig(cwd) {
+    const fromFile = (0, PluginConfigLoader_1.loadPluginConfig)(cwd);
+    const fromEnv = disabledFromEnv();
+    const combinedDisabled = new Set([
+        ...(fromFile.disabledRules ?? []),
+        ...fromEnv,
+    ]);
+    return {
+        ...fromFile,
+        disabledRules: Array.from(combinedDisabled),
+    };
+}

package/dist/config/Config.d.ts

@@ -0,0 +1,26 @@
+export declare const DEFAULT_MODEL = "claude-sonnet-4-6";
+export type ConfigOptions = {
+    model?: string;
+    apiKey?: string;
+    cooldown?: number;
+    disabled?: boolean;
+    useSystemClaude?: boolean;
+    /**
+     * Language for the AI validator's "reason" field.
+     * - "auto" (or undefined): match the dominant language of the instruction
+     *   files, falling back to English when ambiguous.
+     * - "en", "ja", "zh", "ko", etc.: write reasons in that language.
+     */
+    reasonLang?: string;
+};
+export declare class Config {
+    readonly model: string;
+    readonly apiKey: string | undefined;
+    readonly cooldown: number;
+    readonly disabled: boolean;
+    readonly useSystemClaude: boolean;
+    readonly reasonLang: string | undefined;
+    constructor(options?: ConfigOptions);
+    get useApi(): boolean;
+}
+//# sourceMappingURL=Config.d.ts.map

package/dist/config/Config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Config.d.ts","sourceRoot":"","sources":["../../src/config/Config.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,aAAa,sBAAsB,CAAA;AAEhD,MAAM,MAAM,aAAa,GAAG;IAC1B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;;;;OAKG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,qBAAa,MAAM;IACjB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAA;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAA;IAC1B,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAA;IACjC,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;gBAE3B,OAAO,CAAC,EAAE,aAAa;IAUnC,IAAI,MAAM,IAAI,OAAO,CAEpB;CACF"}