ccguard/dist/hooks/processHookData.js

Automated enforcement of net-negative LOC, complexity constraints, and quality standards for Claude code

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.processHookData = processHookData;
const contracts_1 = require("../contracts");
const userPromptHandler_1 = require("./userPromptHandler");
const GuardManager_1 = require("../ccguard/GuardManager");
const ConfigLoader_1 = require("../config/ConfigLoader");
const defaultResult = {
    decision: 'approve',
    reason: 'No validation required',
};
async function processHookData(inputData, deps) {
    try {
        const parsedData = JSON.parse(inputData);
        // Initialize dependencies
        const configLoader = deps.configLoader ?? new ConfigLoader_1.ConfigLoader();
        const guardManager = new GuardManager_1.GuardManager(deps.storage, configLoader, deps.rootDir);
        const userPromptHandler = deps.userPromptHandler ?? new userPromptHandler_1.UserPromptHandler(guardManager);
        // Process user commands (on/off/status)
        const commandResult = await userPromptHandler.processUserCommand(inputData);
        if (commandResult) {
            return commandResult;
        }
        // Check if guard is disabled
        const disabledResult = await userPromptHandler.getDisabledResult();
        if (disabledResult) {
            return disabledResult;
        }
        // Parse hook data
        const hookResult = contracts_1.HookDataSchema.safeParse(parsedData);
        if (!hookResult.success) {
            return defaultResult;
        }
        // Only process PreToolUse events
        if (hookResult.data.hook_event_name !== 'PreToolUse') {
            return defaultResult;
        }
        // Check if this is a file modification operation
        if (!shouldValidateOperation(hookResult.data)) {
            return defaultResult;
        }
        // Perform validation
        if (deps.validator) {
            const context = await buildContext(hookResult.data, deps.storage);
            return await deps.validator(context);
        }
        return defaultResult;
    }
    catch (error) {
        console.error('Error processing hook data:', error);
        return {
            decision: 'block',
            reason: 'Error processing hook data. Please try again.',
        };
    }
}
function shouldValidateOperation(hookData) {
    // Only validate Edit, MultiEdit, and Write operations
    const validTools = ['Edit', 'MultiEdit', 'Write'];
    if (!validTools.includes(hookData.tool_name)) {
        return false;
    }
    // Parse as tool operation
    const operationResult = contracts_1.ToolOperationSchema.safeParse({
        ...hookData,
        tool_input: hookData.tool_input,
    });
    if (!operationResult.success) {
        return false;
    }
    return true;
}
async function buildContext(hookData, storage) {
    const operation = contracts_1.ToolOperationSchema.parse(hookData);
    const guardState = await storage.getGuardState();
    const sessionStats = await storage.getSessionStats();
    return {
        operation,
        sessionStats,
        guardEnabled: guardState?.enabled ?? true,
    };
}
//# sourceMappingURL=processHookData.js.map