@rigour-labs/cli 2.22.0 → 3.0.1

package/dist/commands/explain.js

@@ -28,6 +28,38 @@ export async function explainCommand(cwd) {
         console.log(chalk.bold('Status: ') + (report.status === 'PASS'
             ? chalk.green.bold('✅ PASS')
             : chalk.red.bold('🛑 FAIL')));
+        // Score summary
+        if (report.stats) {
+            const stats = report.stats;
+            const scoreParts = [];
+            if (stats.score !== undefined)
+                scoreParts.push(`Score: ${stats.score}/100`);
+            if (stats.ai_health_score !== undefined)
+                scoreParts.push(`AI Health: ${stats.ai_health_score}/100`);
+            if (stats.structural_score !== undefined)
+                scoreParts.push(`Structural: ${stats.structural_score}/100`);
+            if (scoreParts.length > 0) {
+                console.log(chalk.bold('\n' + scoreParts.join(' | ')));
+            }
+            // Severity breakdown
+            if (stats.severity_breakdown) {
+                const sevParts = Object.entries(stats.severity_breakdown)
+                    .filter(([, count]) => count > 0)
+                    .map(([sev, count]) => `${sev}: ${count}`);
+                if (sevParts.length > 0) {
+                    console.log(chalk.dim('Severity: ' + sevParts.join(', ')));
+                }
+            }
+            // Provenance breakdown
+            if (stats.provenance_breakdown) {
+                const provParts = Object.entries(stats.provenance_breakdown)
+                    .filter(([, count]) => count > 0)
+                    .map(([prov, count]) => `${prov}: ${count}`);
+                if (provParts.length > 0) {
+                    console.log(chalk.dim('Categories: ' + provParts.join(', ')));
+                }
+            }
+        }
         console.log(chalk.bold('\nGate Summary:'));
         for (const [gate, status] of Object.entries(report.summary || {})) {
             const icon = status === 'PASS' ? '✅' : status === 'FAIL' ? '❌' : '⏭️';
@@ -35,8 +67,21 @@ export async function explainCommand(cwd) {
         }
         if (report.failures && report.failures.length > 0) {
             console.log(chalk.bold.red(`\n🔧 ${report.failures.length} Violation(s) to Fix:\n`));
+            // Severity color helper
+            const sevColor = (s) => {
+                switch (s) {
+                    case 'critical': return chalk.red.bold;
+                    case 'high': return chalk.red;
+                    case 'medium': return chalk.yellow;
+                    case 'low': return chalk.dim;
+                    default: return chalk.dim;
+                }
+            };
             report.failures.forEach((failure, index) => {
-                console.log(chalk.white(`${index + 1}. `) + chalk.bold.yellow(`[${failure.id.toUpperCase()}]`) + chalk.white(` ${failure.title}`));
+                const sev = failure.severity || 'medium';
+                const sevLabel = sevColor(sev)(`[${sev.toUpperCase()}]`);
+                const provLabel = failure.provenance ? chalk.dim(`(${failure.provenance})`) : '';
+                console.log(chalk.white(`${index + 1}. `) + sevLabel + ' ' + chalk.bold.yellow(`[${failure.id.toUpperCase()}]`) + ' ' + provLabel + chalk.white(` ${failure.title}`));
                 console.log(chalk.dim(`   └─ ${failure.details}`));
                 if (failure.files && failure.files.length > 0) {
                     console.log(chalk.cyan(`   📁 Files: ${failure.files.join(', ')}`));

package/dist/commands/export-audit.d.ts

@@ -0,0 +1,16 @@
+/**
+ * export-audit command
+ *
+ * Generates a compliance audit package from the last gate check.
+ * The artifact compliance officers hand to auditors.
+ *
+ * Formats: JSON (structured) or Markdown (human-readable)
+ *
+ * @since v2.17.0
+ */
+export interface ExportAuditOptions {
+    format?: 'json' | 'md';
+    output?: string;
+    run?: boolean;
+}
+export declare function exportAuditCommand(cwd: string, options?: ExportAuditOptions): Promise<void>;

package/dist/commands/export-audit.js

@@ -0,0 +1,245 @@
+/**
+ * export-audit command
+ *
+ * Generates a compliance audit package from the last gate check.
+ * The artifact compliance officers hand to auditors.
+ *
+ * Formats: JSON (structured) or Markdown (human-readable)
+ *
+ * @since v2.17.0
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import yaml from 'yaml';
+import { getScoreHistory, getScoreTrend } from '@rigour-labs/core';
+const CLI_VERSION = '2.0.0';
+export async function exportAuditCommand(cwd, options = {}) {
+    const format = options.format || 'json';
+    const configPath = path.join(cwd, 'rigour.yml');
+    let reportPath = path.join(cwd, 'rigour-report.json');
+    // If --run, execute a fresh check first
+    if (options.run) {
+        console.log(chalk.blue('Running fresh rigour check...\n'));
+        const { checkCommand } = await import('./check.js');
+        try {
+            await checkCommand(cwd, [], {});
+        }
+        catch {
+            // checkCommand calls process.exit, so we catch here for the --run flow
+        }
+    }
+    // Read config
+    let config = {};
+    if (await fs.pathExists(configPath)) {
+        try {
+            const configContent = await fs.readFile(configPath, 'utf-8');
+            config = yaml.parse(configContent);
+            if (config?.output?.report_path) {
+                reportPath = path.join(cwd, config.output.report_path);
+            }
+        }
+        catch { }
+    }
+    // Read report
+    if (!(await fs.pathExists(reportPath))) {
+        console.error(chalk.red(`Error: No report found at ${reportPath}`));
+        console.error(chalk.dim('Run `rigour check` first, or use `rigour export-audit --run`.'));
+        process.exit(2);
+    }
+    let report;
+    try {
+        const reportContent = await fs.readFile(reportPath, 'utf-8');
+        report = JSON.parse(reportContent);
+    }
+    catch (error) {
+        console.error(chalk.red(`Error reading report: ${error.message}`));
+        process.exit(3);
+    }
+    // Build audit package
+    const auditPackage = buildAuditPackage(cwd, report, config);
+    // Determine output path
+    const outputPath = options.output
+        ? path.resolve(cwd, options.output)
+        : path.join(cwd, `rigour-audit-report.${format}`);
+    // Write output
+    if (format === 'md') {
+        const markdown = renderMarkdown(auditPackage);
+        await fs.writeFile(outputPath, markdown, 'utf-8');
+    }
+    else {
+        await fs.writeJson(outputPath, auditPackage, { spaces: 2 });
+    }
+    console.log(chalk.green(`\n✔ Audit report exported: ${path.relative(cwd, outputPath)}`));
+    console.log(chalk.dim(`  Format: ${format.toUpperCase()} | Status: ${auditPackage.summary.status} | Score: ${auditPackage.summary.score}/100`));
+}
+function buildAuditPackage(cwd, report, config) {
+    const stats = report.stats || {};
+    const failures = report.failures || [];
+    // Score trend
+    const trend = getScoreTrend(cwd);
+    const history = getScoreHistory(cwd, 5);
+    // Severity breakdown
+    const severityBreakdown = stats.severity_breakdown || {};
+    const provenanceBreakdown = stats.provenance_breakdown || {};
+    // Gate results from summary
+    const gateResults = Object.entries(report.summary || {}).map(([gate, status]) => ({
+        gate,
+        status: status,
+    }));
+    // Top violations
+    const violations = failures.map((f) => ({
+        id: f.id,
+        severity: f.severity || 'medium',
+        provenance: f.provenance || 'traditional',
+        title: f.title,
+        details: f.details,
+        files: f.files || [],
+        line: f.line,
+        hint: f.hint,
+    }));
+    return {
+        schema_version: '1.0.0',
+        metadata: {
+            project: path.basename(cwd),
+            rigour_version: CLI_VERSION,
+            timestamp: new Date().toISOString(),
+            preset: config.preset || 'custom',
+            config_path: 'rigour.yml',
+            generated_by: 'rigour export-audit',
+        },
+        summary: {
+            status: report.status,
+            score: stats.score ?? 100,
+            ai_health_score: stats.ai_health_score,
+            structural_score: stats.structural_score,
+            duration_ms: stats.duration_ms,
+            total_violations: failures.length,
+        },
+        severity_breakdown: {
+            critical: severityBreakdown.critical || 0,
+            high: severityBreakdown.high || 0,
+            medium: severityBreakdown.medium || 0,
+            low: severityBreakdown.low || 0,
+            info: severityBreakdown.info || 0,
+        },
+        provenance_breakdown: {
+            'ai-drift': provenanceBreakdown['ai-drift'] || 0,
+            traditional: provenanceBreakdown.traditional || 0,
+            security: provenanceBreakdown.security || 0,
+            governance: provenanceBreakdown.governance || 0,
+        },
+        gate_results: gateResults,
+        violations,
+        score_trend: trend ? {
+            direction: trend.direction,
+            delta: trend.delta,
+            recent_average: trend.recentAvg,
+            previous_average: trend.previousAvg,
+            last_scores: trend.recentScores,
+        } : null,
+        recent_history: history.map(h => ({
+            timestamp: h.timestamp,
+            score: h.score,
+            status: h.status,
+        })),
+    };
+}
+function renderMarkdown(audit) {
+    const lines = [];
+    lines.push(`# Rigour Audit Report`);
+    lines.push('');
+    lines.push(`**Project:** ${audit.metadata.project}`);
+    lines.push(`**Generated:** ${audit.metadata.timestamp}`);
+    lines.push(`**Rigour Version:** ${audit.metadata.rigour_version}`);
+    lines.push(`**Preset:** ${audit.metadata.preset}`);
+    lines.push('');
+    // Summary
+    lines.push('## Summary');
+    lines.push('');
+    const statusEmoji = audit.summary.status === 'PASS' ? '✅' : '🛑';
+    lines.push(`| Metric | Value |`);
+    lines.push(`|:-------|:------|`);
+    lines.push(`| **Status** | ${statusEmoji} ${audit.summary.status} |`);
+    lines.push(`| **Overall Score** | ${audit.summary.score}/100 |`);
+    if (audit.summary.ai_health_score !== undefined) {
+        lines.push(`| **AI Health Score** | ${audit.summary.ai_health_score}/100 |`);
+    }
+    if (audit.summary.structural_score !== undefined) {
+        lines.push(`| **Structural Score** | ${audit.summary.structural_score}/100 |`);
+    }
+    lines.push(`| **Total Violations** | ${audit.summary.total_violations} |`);
+    lines.push(`| **Duration** | ${audit.summary.duration_ms}ms |`);
+    lines.push('');
+    // Severity Breakdown
+    lines.push('## Severity Breakdown');
+    lines.push('');
+    lines.push('| Severity | Count |');
+    lines.push('|:---------|:------|');
+    for (const [sev, count] of Object.entries(audit.severity_breakdown)) {
+        if (count > 0) {
+            lines.push(`| ${sev.charAt(0).toUpperCase() + sev.slice(1)} | ${count} |`);
+        }
+    }
+    lines.push('');
+    // Provenance Breakdown
+    lines.push('## Provenance Breakdown');
+    lines.push('');
+    lines.push('| Category | Count |');
+    lines.push('|:---------|:------|');
+    for (const [prov, count] of Object.entries(audit.provenance_breakdown)) {
+        if (count > 0) {
+            lines.push(`| ${prov} | ${count} |`);
+        }
+    }
+    lines.push('');
+    // Gate Results
+    lines.push('## Gate Results');
+    lines.push('');
+    lines.push('| Gate | Status |');
+    lines.push('|:-----|:-------|');
+    for (const gate of audit.gate_results) {
+        const icon = gate.status === 'PASS' ? '✅' : gate.status === 'FAIL' ? '❌' : '⏭️';
+        lines.push(`| ${gate.gate} | ${icon} ${gate.status} |`);
+    }
+    lines.push('');
+    // Violations
+    if (audit.violations.length > 0) {
+        lines.push('## Violations');
+        lines.push('');
+        for (let i = 0; i < audit.violations.length; i++) {
+            const v = audit.violations[i];
+            lines.push(`### ${i + 1}. [${v.severity.toUpperCase()}] ${v.title}`);
+            lines.push('');
+            lines.push(`- **ID:** \`${v.id}\``);
+            lines.push(`- **Severity:** ${v.severity}`);
+            lines.push(`- **Provenance:** ${v.provenance}`);
+            lines.push(`- **Details:** ${v.details}`);
+            if (v.files && v.files.length > 0) {
+                lines.push(`- **Files:** ${v.files.join(', ')}`);
+            }
+            if (v.hint) {
+                lines.push(`- **Hint:** ${v.hint}`);
+            }
+            lines.push('');
+        }
+    }
+    // Score Trend
+    if (audit.score_trend) {
+        lines.push('## Score Trend');
+        lines.push('');
+        const arrow = audit.score_trend.direction === 'improving' ? '↑' :
+            audit.score_trend.direction === 'degrading' ? '↓' : '→';
+        lines.push(`**Direction:** ${audit.score_trend.direction} ${arrow}`);
+        lines.push(`**Recent Average:** ${audit.score_trend.recent_average}/100`);
+        lines.push(`**Previous Average:** ${audit.score_trend.previous_average}/100`);
+        lines.push(`**Delta:** ${audit.score_trend.delta > 0 ? '+' : ''}${audit.score_trend.delta}`);
+        lines.push(`**Recent Scores:** ${audit.score_trend.last_scores.join(' → ')}`);
+        lines.push('');
+    }
+    // Footer
+    lines.push('---');
+    lines.push(`*Generated by Rigour v${audit.metadata.rigour_version} — ${audit.metadata.timestamp}*`);
+    lines.push('');
+    return lines.join('\n');
+}

package/dist/commands/hooks.d.ts

@@ -0,0 +1,22 @@
+/**
+ * `rigour hooks init` — Generate tool-specific hook configurations.
+ *
+ * Detects which AI coding tools are present (or accepts --tool flag)
+ * and generates the appropriate hook files so that Rigour runs
+ * quality checks after every file write/edit.
+ *
+ * Supported tools:
+ *   - Claude Code (.claude/settings.json PostToolUse)
+ *   - Cursor (.cursor/hooks.json afterFileEdit)
+ *   - Cline (.clinerules/hooks/PostToolUse)
+ *   - Windsurf (.windsurf/hooks.json post_write_code)
+ *
+ * @since v3.0.0
+ */
+export interface HooksOptions {
+    tool?: string;
+    dryRun?: boolean;
+    force?: boolean;
+    block?: boolean;
+}
+export declare function hooksInitCommand(cwd: string, options?: HooksOptions): Promise<void>;

package/dist/commands/hooks.js

@@ -0,0 +1,274 @@
+/**
+ * `rigour hooks init` — Generate tool-specific hook configurations.
+ *
+ * Detects which AI coding tools are present (or accepts --tool flag)
+ * and generates the appropriate hook files so that Rigour runs
+ * quality checks after every file write/edit.
+ *
+ * Supported tools:
+ *   - Claude Code (.claude/settings.json PostToolUse)
+ *   - Cursor (.cursor/hooks.json afterFileEdit)
+ *   - Cline (.clinerules/hooks/PostToolUse)
+ *   - Windsurf (.windsurf/hooks.json post_write_code)
+ *
+ * @since v3.0.0
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import { randomUUID } from 'crypto';
+// ── Studio event logging ─────────────────────────────────────────────
+async function logStudioEvent(cwd, event) {
+    try {
+        const rigourDir = path.join(cwd, '.rigour');
+        await fs.ensureDir(rigourDir);
+        const eventsPath = path.join(rigourDir, 'events.jsonl');
+        const logEntry = JSON.stringify({
+            id: randomUUID(),
+            timestamp: new Date().toISOString(),
+            ...event,
+        }) + '\n';
+        await fs.appendFile(eventsPath, logEntry);
+    }
+    catch {
+        // Silent fail
+    }
+}
+// ── Tool detection ───────────────────────────────────────────────────
+const TOOL_MARKERS = {
+    claude: ['CLAUDE.md', '.claude'],
+    cursor: ['.cursor', '.cursorrules'],
+    cline: ['.clinerules'],
+    windsurf: ['.windsurfrules', '.windsurf'],
+};
+function detectTools(cwd) {
+    const detected = [];
+    for (const [tool, markers] of Object.entries(TOOL_MARKERS)) {
+        for (const marker of markers) {
+            if (fs.existsSync(path.join(cwd, marker))) {
+                detected.push(tool);
+                break;
+            }
+        }
+    }
+    return detected;
+}
+function resolveCheckerPath(cwd) {
+    const localPath = path.join(cwd, 'node_modules', '@rigour-labs', 'core', 'dist', 'hooks', 'standalone-checker.js');
+    if (fs.existsSync(localPath)) {
+        return localPath;
+    }
+    return 'npx rigour-hook-check';
+}
+// ── Tool resolution (from --tool flag or auto-detect) ────────────────
+const ALL_TOOLS = ['claude', 'cursor', 'cline', 'windsurf'];
+function resolveTools(cwd, toolFlag) {
+    if (toolFlag === 'all') {
+        return ALL_TOOLS;
+    }
+    if (toolFlag) {
+        const requested = toolFlag.split(',').map(t => t.trim().toLowerCase());
+        const valid = requested.filter(t => ALL_TOOLS.includes(t));
+        if (valid.length === 0) {
+            console.error(chalk.red(`Unknown tool: ${toolFlag}. Valid: claude, cursor, cline, windsurf, all`));
+            process.exit(1);
+        }
+        return valid;
+    }
+    // Auto-detect
+    const detected = detectTools(cwd);
+    if (detected.length === 0) {
+        console.log(chalk.yellow('No AI coding tools detected. Defaulting to Claude Code.'));
+        console.log(chalk.dim('  Use --tool <name> to specify: claude, cursor, cline, windsurf, all\n'));
+        return ['claude'];
+    }
+    console.log(chalk.green(`Detected tools: ${detected.join(', ')}`));
+    return detected;
+}
+// ── Per-tool hook generators ─────────────────────────────────────────
+function generateClaudeHooks(checkerPath, block) {
+    const blockFlag = block ? ' --block' : '';
+    const settings = {
+        hooks: {
+            PostToolUse: [{
+                    matcher: "Write|Edit|MultiEdit",
+                    hooks: [{
+                            type: "command",
+                            command: `node ${checkerPath} --files "$TOOL_INPUT_file_path"${blockFlag}`,
+                        }]
+                }]
+        }
+    };
+    return [{
+            path: '.claude/settings.json',
+            content: JSON.stringify(settings, null, 4),
+            description: 'Claude Code PostToolUse hook',
+        }];
+}
+function generateCursorHooks(checkerPath, _block) {
+    const hooks = {
+        version: 1,
+        hooks: { afterFileEdit: [{ command: `node ${checkerPath} --stdin` }] }
+    };
+    return [{
+            path: '.cursor/hooks.json',
+            content: JSON.stringify(hooks, null, 4),
+            description: 'Cursor afterFileEdit hook config',
+        }];
+}
+function generateClineHooks(checkerPath, _block) {
+    const script = buildClineScript(checkerPath);
+    return [{
+            path: '.clinerules/hooks/PostToolUse',
+            content: script,
+            executable: true,
+            description: 'Cline PostToolUse executable hook',
+        }];
+}
+function buildClineScript(checkerPath) {
+    return `#!/usr/bin/env node
+/**
+ * Cline PostToolUse hook for Rigour.
+ * Receives JSON on stdin with { toolName, toolInput }.
+ */
+const WRITE_TOOLS = ['write_to_file', 'replace_in_file'];
+
+let data = '';
+process.stdin.on('data', chunk => { data += chunk; });
+process.stdin.on('end', async () => {
+    try {
+        const payload = JSON.parse(data);
+        if (!WRITE_TOOLS.includes(payload.toolName)) {
+            process.stdout.write(JSON.stringify({}));
+            return;
+        }
+        const filePath = payload.toolInput?.path || payload.toolInput?.file_path;
+        if (!filePath) {
+            process.stdout.write(JSON.stringify({}));
+            return;
+        }
+
+        const { execSync } = require('child_process');
+        const raw = execSync(
+            \`node ${checkerPath} --files "\${filePath}"\`,
+            { encoding: 'utf-8', timeout: 5000 }
+        );
+        const result = JSON.parse(raw);
+        if (result.status === 'fail') {
+            const msgs = result.failures
+                .map(f => \`[rigour/\${f.gate}] \${f.file}: \${f.message}\`)
+                .join('\\n');
+            process.stdout.write(JSON.stringify({
+                contextModification: \`\\n[Rigour] \${result.failures.length} issue(s):\\n\${msgs}\\nPlease fix before continuing.\`,
+            }));
+        } else {
+            process.stdout.write(JSON.stringify({}));
+        }
+    } catch (err) {
+        process.stderr.write(\`Rigour hook error: \${err.message}\\n\`);
+        process.stdout.write(JSON.stringify({}));
+    }
+});
+`;
+}
+function generateWindsurfHooks(checkerPath, _block) {
+    const hooks = {
+        version: 1,
+        hooks: { post_write_code: [{ command: `node ${checkerPath} --stdin` }] }
+    };
+    return [{
+            path: '.windsurf/hooks.json',
+            content: JSON.stringify(hooks, null, 4),
+            description: 'Windsurf post_write_code hook config',
+        }];
+}
+const GENERATORS = {
+    claude: generateClaudeHooks,
+    cursor: generateCursorHooks,
+    cline: generateClineHooks,
+    windsurf: generateWindsurfHooks,
+};
+// ── File writing ─────────────────────────────────────────────────────
+function printDryRun(files) {
+    console.log(chalk.cyan('\nDry run — files that would be created:\n'));
+    for (const file of files) {
+        console.log(chalk.bold(`  ${file.path}`));
+        console.log(chalk.dim(`    ${file.description}`));
+        if (file.executable) {
+            console.log(chalk.dim('    (executable)'));
+        }
+    }
+    console.log('');
+}
+async function writeHookFiles(cwd, files, force) {
+    let written = 0;
+    let skipped = 0;
+    for (const file of files) {
+        const fullPath = path.join(cwd, file.path);
+        const exists = await fs.pathExists(fullPath);
+        if (exists && !force) {
+            console.log(chalk.yellow(`  SKIP ${file.path} (already exists, use --force to overwrite)`));
+            skipped++;
+            continue;
+        }
+        await fs.ensureDir(path.dirname(fullPath));
+        await fs.writeFile(fullPath, file.content, 'utf-8');
+        if (file.executable) {
+            await fs.chmod(fullPath, 0o755);
+        }
+        console.log(chalk.green(`  CREATE ${file.path}`));
+        console.log(chalk.dim(`         ${file.description}`));
+        written++;
+    }
+    return { written, skipped };
+}
+// ── Next-steps guidance ──────────────────────────────────────────────
+const NEXT_STEPS = {
+    claude: 'Claude Code: Hooks are active immediately. Rigour runs after every Write/Edit.',
+    cursor: 'Cursor: Reload window (Cmd+Shift+P > Reload). Check Output > Hooks panel for logs.',
+    cline: 'Cline: Hook is active. Quality feedback appears in agent context on violations.',
+    windsurf: 'Windsurf: Reload editor. Check terminal for Rigour output after Cascade writes.',
+};
+function printNextSteps(tools) {
+    console.log(chalk.cyan('\nNext steps:'));
+    for (const tool of tools) {
+        console.log(chalk.dim(`  ${NEXT_STEPS[tool]}`));
+    }
+    console.log('');
+}
+// ── Main command entry point ─────────────────────────────────────────
+export async function hooksInitCommand(cwd, options = {}) {
+    console.log(chalk.blue('\nRigour Hooks Setup\n'));
+    await logStudioEvent(cwd, {
+        type: 'tool_call',
+        tool: 'rigour_hooks_init',
+        arguments: { tool: options.tool, dryRun: options.dryRun },
+    });
+    const tools = resolveTools(cwd, options.tool);
+    const checkerPath = resolveCheckerPath(cwd);
+    const block = !!options.block;
+    // Collect generated files from all tools
+    const allFiles = [];
+    for (const tool of tools) {
+        allFiles.push(...GENERATORS[tool](checkerPath, block));
+    }
+    if (options.dryRun) {
+        printDryRun(allFiles);
+        return;
+    }
+    const { written, skipped } = await writeHookFiles(cwd, allFiles, !!options.force);
+    console.log('');
+    if (written > 0) {
+        console.log(chalk.green.bold(`Created ${written} hook file(s).`));
+    }
+    if (skipped > 0) {
+        console.log(chalk.yellow(`Skipped ${skipped} existing file(s).`));
+    }
+    printNextSteps(tools);
+    await logStudioEvent(cwd, {
+        type: 'tool_response',
+        tool: 'rigour_hooks_init',
+        status: 'success',
+        content: [{ type: 'text', text: `Generated hooks for: ${tools.join(', ')}` }],
+    });
+}

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

@@ -0,0 +1 @@
+export {};