@lousy-agents/cli 5.6.1 → 5.7.0

package/dist/index.js

@@ -32244,11 +32244,11 @@ var external_node_tty_namespaceObject = /*#__PURE__*/__webpack_require__.t(exter
 const {
   env: consola_DXBYu_KD_env = {},
   argv = [],
-  platform = ""
+  platform: consola_DXBYu_KD_platform = ""
 } = typeof process === "undefined" ? {} : process;
 const isDisabled = "NO_COLOR" in consola_DXBYu_KD_env || argv.includes("--no-color");
 const isForced = "FORCE_COLOR" in consola_DXBYu_KD_env || argv.includes("--color");
-const consola_DXBYu_KD_isWindows = platform === "win32";
+const consola_DXBYu_KD_isWindows = consola_DXBYu_KD_platform === "win32";
 const isDumbTerminal = consola_DXBYu_KD_env.TERM === "dumb";
 const isCompatibleTerminal = external_node_tty_namespaceObject && external_node_tty_.isatty && external_node_tty_.isatty(1) && consola_DXBYu_KD_env.TERM && !isDumbTerminal;
 const isCI = "CI" in consola_DXBYu_KD_env && ("GITHUB_ACTIONS" in consola_DXBYu_KD_env || "GITLAB_CI" in consola_DXBYu_KD_env || "CIRCLECI" in consola_DXBYu_KD_env);
@@ -36673,6 +36673,91 @@ const initCommand = defineCommand({
     return new FileSystemAgentLintGateway();
 }
 
+;// CONCATENATED MODULE: ../core/src/gateways/hook-config-gateway.ts
+/**
+ * Gateway for hook configuration file system operations.
+ * Discovers hook config files for GitHub Copilot and Claude Code.
+ */ 
+
+
+/** Maximum hook config file size: 1 MB */ const MAX_CONFIG_FILE_BYTES = 1_048_576;
+/** Matches the Copilot hook key `"preToolUse":` to detect hook section presence */ const COPILOT_HOOK_PATTERN = /"preToolUse"\s*:/;
+/** Matches the Claude hook key `"PreToolUse":` to detect hook section presence */ const CLAUDE_HOOK_PATTERN = /"PreToolUse"\s*:/;
+/**
+ * Hook configuration file locations to search.
+ */ const HOOK_CONFIG_PATHS = [
+    {
+        relativePath: (0,external_node_path_.join)(".github", "copilot", "hooks.json"),
+        platform: "copilot"
+    },
+    {
+        relativePath: (0,external_node_path_.join)(".claude", "settings.json"),
+        platform: "claude"
+    },
+    {
+        relativePath: (0,external_node_path_.join)(".claude", "settings.local.json"),
+        platform: "claude"
+    }
+];
+/**
+ * File system implementation of the hook config lint gateway.
+ */ class FileSystemHookConfigGateway {
+    async discoverHookFiles(targetDir) {
+        const discovered = [];
+        for (const config of HOOK_CONFIG_PATHS){
+            let safePath;
+            try {
+                safePath = await file_system_utils_resolveSafePath(targetDir, config.relativePath);
+            } catch  {
+                continue;
+            }
+            if (!await file_system_utils_fileExists(safePath)) {
+                continue;
+            }
+            const stats = await (0,promises_.lstat)(safePath);
+            if (stats.isSymbolicLink()) {
+                continue;
+            }
+            try {
+                await assertFileSizeWithinLimit(safePath, MAX_CONFIG_FILE_BYTES, `Hook config ${config.relativePath}`);
+            } catch  {
+                continue;
+            }
+            const content = await (0,promises_.readFile)(safePath, "utf-8");
+            if (this.mayContainHookSection(content, config.platform)) {
+                discovered.push({
+                    filePath: safePath,
+                    platform: config.platform
+                });
+            }
+        }
+        return discovered;
+    }
+    async readFileContent(filePath) {
+        const stats = await (0,promises_.lstat)(filePath);
+        if (stats.isSymbolicLink()) {
+            throw new Error(`Symlinks are not allowed: ${filePath}`);
+        }
+        await assertFileSizeWithinLimit(filePath, MAX_CONFIG_FILE_BYTES, `Hook config ${filePath}`);
+        return (0,promises_.readFile)(filePath, "utf-8");
+    }
+    /**
+     * Lightweight heuristic to check if a file may contain a pre-tool-use hooks section.
+     * Uses substring search rather than JSON.parse so that files with invalid JSON are
+     * still discovered and surfaced as `hook/invalid-json` diagnostics by the use case.
+     */ mayContainHookSection(content, platform) {
+        if (platform === "copilot") {
+            return COPILOT_HOOK_PATTERN.test(content);
+        }
+        return CLAUDE_HOOK_PATTERN.test(content);
+    }
+}
+/**
+ * Creates and returns the default hook config lint gateway.
+ */ function createHookConfigGateway() {
+    return new FileSystemHookConfigGateway();
+}
+
 ;// CONCATENATED MODULE: ../core/src/gateways/instruction-file-discovery-gateway.ts
 /**
  * Gateway for discovering instruction files across multiple formats.
@@ -55723,6 +55808,13 @@ const remark = unified().use(remarkParse).use(remarkStringify).freeze()
         "agent/invalid-description": "error",
         "agent/invalid-field": "warn"
     },
+    hooks: {
+        "hook/invalid-json": "error",
+        "hook/invalid-config": "error",
+        "hook/missing-command": "error",
+        "hook/missing-matcher": "warn",
+        "hook/missing-timeout": "warn"
+    },
     instructions: {
         "instruction/parse-error": "warn",
         "instruction/command-not-in-code-block": "warn",
@@ -55755,6 +55847,7 @@ const remark = unified().use(remarkParse).use(remarkStringify).freeze()
 ]));
 /** Zod schema for the lint.rules section of the config */ const LintRulesConfigSchema = schemas_object({
     agents: RuleConfigMapSchema.optional(),
+    hooks: RuleConfigMapSchema.optional(),
     instructions: RuleConfigMapSchema.optional(),
     skills: RuleConfigMapSchema.optional()
 });
@@ -55799,6 +55892,7 @@ const remark = unified().use(remarkParse).use(remarkStringify).freeze()
     }
     return {
         agents: mergeTargetRules(DEFAULT_LINT_RULES.agents, rules.agents),
+        hooks: mergeTargetRules(DEFAULT_LINT_RULES.hooks, rules.hooks),
         instructions: mergeTargetRules(DEFAULT_LINT_RULES.instructions, rules.instructions),
         skills: mergeTargetRules(DEFAULT_LINT_RULES.skills, rules.skills)
     };
@@ -56190,6 +56284,7 @@ const remark = unified().use(remarkParse).use(remarkStringify).freeze()
  */ /** Maps a lint target to its config key */ const TARGET_TO_CONFIG_KEY = {
     skill: "skills",
     agent: "agents",
+    hook: "hooks",
     instruction: "instructions"
 };
 /**
@@ -56391,6 +56486,205 @@ const remark = unified().use(remarkParse).use(remarkStringify).freeze()
     return lines[0]?.trim() === "---";
 }
 
+;// CONCATENATED MODULE: ../core/src/entities/copilot-hook-schema.ts
+/**
+ * Zod schemas for the GitHub Copilot hooks configuration format.
+ *
+ * Lives in entities (Layer 1) so that use cases can import it without
+ * violating the dependency rule. The agent-shell package maintains an
+ * aligned copy (packages/agent-shell/src/types.ts HooksConfigSchema)
+ * because agent-shell is a standalone published binary that cannot
+ * depend on @lousy-agents/core.
+ */ 
+const MAX_HOOKS_PER_EVENT = 100;
+/** Regex that allows standard env var names and rejects __proto__ (the prototype-polluting key). */ const ENV_KEY_PATTERN = /^(?!__proto__$)[a-zA-Z_][a-zA-Z0-9_]*$/;
+/**
+ * Zod schema for a single GitHub Copilot hook command entry.
+ */ const CopilotHookCommandSchema = schemas_object({
+    type: schemas_literal("command"),
+    bash: schemas_string().min(1, "Hook bash command must not be empty").optional(),
+    powershell: schemas_string().min(1, "Hook PowerShell command must not be empty").optional(),
+    cwd: schemas_string().optional(),
+    timeoutSec: schemas_number().positive().optional(),
+    env: record(schemas_string().regex(ENV_KEY_PATTERN, "Hook env key must be a valid identifier (no prototype-polluting keys)"), schemas_string()).optional()
+}).strict().refine((data)=>Boolean(data.bash) || Boolean(data.powershell), {
+    message: "At least one of 'bash' or 'powershell' must be provided and non-empty"
+});
+const hookArray = schemas_array(CopilotHookCommandSchema).max(MAX_HOOKS_PER_EVENT);
+/**
+ * Zod schema for the GitHub Copilot hooks configuration file.
+ * All hook event arrays are optional — configs may use any combination of events.
+ */ const CopilotHooksConfigSchema = schemas_object({
+    version: schemas_literal(1),
+    hooks: schemas_object({
+        sessionStart: hookArray.optional(),
+        userPromptSubmitted: hookArray.optional(),
+        preToolUse: hookArray.optional(),
+        postToolUse: hookArray.optional(),
+        sessionEnd: hookArray.optional()
+    }).strict()
+}).strict();
+
+;// CONCATENATED MODULE: ../core/src/use-cases/lint-hook-config.ts
+// biome-ignore-all lint/style/useNamingConvention: Claude Code API uses PascalCase hook event names (PreToolUse)
+/**
+ * Use case for linting pre-tool-use hook configurations.
+ * Validates GitHub Copilot and Claude Code hook config files.
+ */ 
+
+
+const INVALID_JSON_MESSAGE_PREFIX = "Invalid JSON in hook configuration file";
+/**
+ * Zod schema for a single Claude Code hook command entry.
+ */ const ClaudeHookCommandSchema = schemas_object({
+    type: schemas_literal("command"),
+    command: schemas_string().min(1, "Hook command must not be empty")
+}).strict();
+/**
+ * Zod schema for a single Claude Code PreToolUse hook entry.
+ */ const ClaudePreToolUseEntrySchema = schemas_object({
+    matcher: schemas_string().optional(),
+    hooks: schemas_array(ClaudeHookCommandSchema).min(1)
+}).strict();
+/**
+ * Zod schema for the Claude Code hooks section within settings.
+ */ const ClaudeHooksConfigSchema = schemas_object({
+    hooks: schemas_object({
+        PreToolUse: schemas_array(ClaudePreToolUseEntrySchema).min(1)
+    }).passthrough()
+}).passthrough();
+/**
+ * Use case for linting hook configuration files across a repository.
+ */ class LintHookConfigUseCase {
+    gateway;
+    constructor(gateway){
+        this.gateway = gateway;
+    }
+    async execute(input) {
+        if (!input.targetDir) {
+            throw new Error("Target directory is required");
+        }
+        const hookFiles = await this.gateway.discoverHookFiles(input.targetDir);
+        const results = [];
+        for (const hookFile of hookFiles){
+            const content = await this.gateway.readFileContent(hookFile.filePath);
+            const result = this.lintHookFile(hookFile, content);
+            results.push(result);
+        }
+        const totalErrors = results.reduce((sum, r)=>sum + r.diagnostics.filter((d)=>d.severity === "error").length, 0);
+        const totalWarnings = results.reduce((sum, r)=>sum + r.diagnostics.filter((d)=>d.severity === "warning").length, 0);
+        return {
+            results,
+            totalFiles: hookFiles.length,
+            totalErrors,
+            totalWarnings
+        };
+    }
+    lintHookFile(hookFile, content) {
+        let parsed;
+        try {
+            parsed = JSON.parse(content);
+        } catch (error) {
+            const errorMessage = error instanceof Error && error.message ? `${INVALID_JSON_MESSAGE_PREFIX}: ${error.message}` : `${INVALID_JSON_MESSAGE_PREFIX}.`;
+            return {
+                filePath: hookFile.filePath,
+                platform: hookFile.platform,
+                diagnostics: [
+                    {
+                        line: 1,
+                        severity: "error",
+                        message: errorMessage,
+                        ruleId: "hook/invalid-json"
+                    }
+                ],
+                valid: false
+            };
+        }
+        const diagnostics = hookFile.platform === "copilot" ? this.validateCopilotConfig(parsed) : this.validateClaudeConfig(parsed);
+        return {
+            filePath: hookFile.filePath,
+            platform: hookFile.platform,
+            diagnostics,
+            valid: diagnostics.every((d)=>d.severity !== "error")
+        };
+    }
+    validateCopilotConfig(parsed) {
+        const diagnostics = [];
+        const result = CopilotHooksConfigSchema.safeParse(parsed);
+        if (!result.success) {
+            for (const issue of result.error.issues){
+                const lastPathSegment = issue.path.length > 0 ? issue.path[issue.path.length - 1] : undefined;
+                const isCommandField = lastPathSegment === "bash" || lastPathSegment === "powershell";
+                const isMissingCommand = // Refine failure: neither bash nor powershell provided.
+                // Keyed off code===custom at the command-object level — the last
+                // path segment is an array index (number), not a named field.
+                issue.code === "custom" && !isCommandField || // Field-level failure: bash/powershell present but empty or wrong type
+                isCommandField && (issue.code === "too_small" || issue.code === "invalid_type");
+                diagnostics.push({
+                    line: 1,
+                    severity: "error",
+                    message: issue.message,
+                    field: issue.path.length > 0 ? issue.path.join(".") : undefined,
+                    ruleId: isMissingCommand ? "hook/missing-command" : "hook/invalid-config"
+                });
+            }
+            return diagnostics;
+        }
+        const lifecycleNames = [
+            "sessionStart",
+            "userPromptSubmitted",
+            "preToolUse",
+            "postToolUse",
+            "sessionEnd"
+        ];
+        for (const lifecycleName of lifecycleNames){
+            const hooksForLifecycle = result.data.hooks[lifecycleName] ?? [];
+            hooksForLifecycle.forEach((hook, index)=>{
+                if (hook.timeoutSec === undefined) {
+                    diagnostics.push({
+                        line: 1,
+                        severity: "warning",
+                        message: "Recommended field 'timeoutSec' is missing from hook command",
+                        field: `hooks.${lifecycleName}[${index}].timeoutSec`,
+                        ruleId: "hook/missing-timeout"
+                    });
+                }
+            });
+        }
+        return diagnostics;
+    }
+    validateClaudeConfig(parsed) {
+        const diagnostics = [];
+        const result = ClaudeHooksConfigSchema.safeParse(parsed);
+        if (!result.success) {
+            for (const issue of result.error.issues){
+                const lastPathSegment = issue.path.length > 0 ? issue.path[issue.path.length - 1] : undefined;
+                const isMissingCommand = lastPathSegment === "command" && (issue.code === "too_small" || issue.code === "invalid_type");
+                diagnostics.push({
+                    line: 1,
+                    severity: "error",
+                    message: issue.message,
+                    field: issue.path.length > 0 ? issue.path.join(".") : undefined,
+                    ruleId: isMissingCommand ? "hook/missing-command" : "hook/invalid-config"
+                });
+            }
+            return diagnostics;
+        }
+        for (const [index, entry] of result.data.hooks.PreToolUse.entries()){
+            if (entry.matcher === undefined) {
+                diagnostics.push({
+                    line: 1,
+                    severity: "warning",
+                    message: "Recommended field 'matcher' is missing from PreToolUse hook entry. Without a matcher, the hook runs for all tools.",
+                    field: `hooks.PreToolUse[${index}].matcher`,
+                    ruleId: "hook/missing-matcher"
+                });
+            }
+        }
+        return diagnostics;
+    }
+}
+
 ;// CONCATENATED MODULE: ../core/src/use-cases/lint-skill-frontmatter.ts
 
 const AgentSkillFrontmatterSchema = schemas_object({
@@ -56562,6 +56856,8 @@ function hasFrontmatterDelimiters(content) {
 
 
 
+
+
 /** Schema for validating target directory */ const TargetDirSchema = schemas_string().min(1, "Target directory is required");
 /**
  * Validates the target directory.
@@ -56682,6 +56978,45 @@ function hasFrontmatterDelimiters(content) {
     });
     return agentOutputToLintOutput(output);
 }
+/**
+ * Converts hook lint output to unified LintOutput.
+ */ function hookOutputToLintOutput(output) {
+    const diagnostics = [];
+    for (const result of output.results){
+        for (const d of result.diagnostics){
+            diagnostics.push({
+                filePath: result.filePath,
+                line: d.line,
+                severity: d.severity,
+                message: d.message,
+                field: d.field,
+                ruleId: d.ruleId,
+                target: "hook"
+            });
+        }
+    }
+    return {
+        diagnostics,
+        target: "hook",
+        filesAnalyzed: output.results.map((r)=>r.filePath),
+        summary: {
+            totalFiles: output.totalFiles,
+            totalErrors: output.totalErrors,
+            totalWarnings: output.totalWarnings,
+            totalInfos: 0
+        }
+    };
+}
+/**
+ * Runs hook configuration linting.
+ */ async function lintHooks(targetDir) {
+    const gateway = createHookConfigGateway();
+    const useCase = new LintHookConfigUseCase(gateway);
+    const output = await useCase.execute({
+        targetDir
+    });
+    return hookOutputToLintOutput(output);
+}
 /**
  * Runs instruction quality analysis.
  */ async function lintInstructions(targetDir) {
@@ -56731,7 +57066,7 @@ function hasFrontmatterDelimiters(content) {
  */ const lintCommand = defineCommand({
     meta: {
         name: "lint",
-        description: "Lint agent skills, custom agents, and instruction files. Validates frontmatter and instruction quality."
+        description: "Lint agent skills, custom agents, instruction files, and hook configurations. Validates frontmatter, instruction quality, and hook config schemas."
     },
     args: {
         skills: {
@@ -56744,6 +57079,11 @@ function hasFrontmatterDelimiters(content) {
             description: "Lint custom agent frontmatter in .github/agents/",
             default: false
         },
+        hooks: {
+            type: "boolean",
+            description: "Lint pre-tool-use hook configurations in .github/copilot/hooks.json, .claude/settings.json, and .claude/settings.local.json",
+            default: false
+        },
         instructions: {
             type: "boolean",
             description: "Analyze instruction quality across all instruction file formats",
@@ -56769,8 +57109,9 @@ function hasFrontmatterDelimiters(content) {
         }
         const lintSkillsFlag = context.args?.skills === true || context.data?.skills === true;
         const lintAgentsFlag = context.args?.agents === true || context.data?.agents === true;
+        const lintHooksFlag = context.args?.hooks === true || context.data?.hooks === true;
         const lintInstructionsFlag = context.args?.instructions === true || context.data?.instructions === true;
-        const noFlagProvided = !lintSkillsFlag && !lintAgentsFlag && !lintInstructionsFlag;
+        const noFlagProvided = !lintSkillsFlag && !lintAgentsFlag && !lintHooksFlag && !lintInstructionsFlag;
         const formatValue = context.args?.format ?? context.data?.format ?? "human";
         const format = [
             "human",
@@ -56794,6 +57135,13 @@ function hasFrontmatterDelimiters(content) {
             totalErrors += agentOutput.summary.totalErrors;
             totalWarnings += agentOutput.summary.totalWarnings;
         }
+        if (noFlagProvided || lintHooksFlag) {
+            const rawOutput = await lintHooks(targetDir);
+            const hookOutput = applySeverityFilter(rawOutput, rulesConfig);
+            allOutputs.push(hookOutput);
+            totalErrors += hookOutput.summary.totalErrors;
+            totalWarnings += hookOutput.summary.totalWarnings;
+        }
         if (noFlagProvided || lintInstructionsFlag) {
             const rawOutput = await lintInstructions(targetDir);
             const instructionOutput = applySeverityFilter(rawOutput, rulesConfig);
@@ -56804,6 +57152,7 @@ function hasFrontmatterDelimiters(content) {
         const targetLabels = {
             skill: "skill(s)",
             agent: "agent(s)",
+            hook: "hook config(s)",
             instruction: "instruction file(s)"
         };
         if (format !== "human") {