toolmoat 0.0.0-stage → 0.1.0

package/dist/report/json.js

@@ -0,0 +1,40 @@
+import { countBySeverity } from '../scan/engine.js';
+import { VERSION } from '../version.js';
+/** Machine-readable report with a stable key order and 2-space indentation. */
+export function renderJson(result, options = {}) {
+    const report = {
+        tool: 'toolmoat',
+        version: options.version ?? VERSION,
+        summary: {
+            filesScanned: result.filesScanned,
+            targets: [...result.targets],
+            durationMs: Math.round(result.durationMs),
+            counts: countBySeverity(result.findings),
+        },
+        findings: result.findings.map(toJsonFinding),
+        skipped: result.skipped.map((skip) => ({ path: skip.path, reason: skip.reason })),
+    };
+    return `${JSON.stringify(report, null, 2)}\n`;
+}
+/** Copies a finding with its keys in a fixed order, leaving out absent optional fields. */
+export function toJsonFinding(finding) {
+    const out = {
+        ruleId: finding.ruleId,
+        severity: finding.severity,
+        category: finding.category,
+        title: finding.title,
+        message: finding.message,
+        file: finding.file,
+    };
+    if (finding.line !== undefined)
+        out.line = finding.line;
+    if (finding.column !== undefined)
+        out.column = finding.column;
+    if (finding.snippet !== undefined)
+        out.snippet = finding.snippet;
+    if (finding.target !== undefined)
+        out.target = finding.target;
+    if (finding.remediation !== undefined)
+        out.remediation = finding.remediation;
+    return out;
+}

package/dist/report/markdown.d.ts

@@ -0,0 +1,12 @@
+import type { ScanResult } from '../types.js';
+import type { ReportOptions } from './index.js';
+/** GitHub caps step summaries at 1 MiB and PR comments at 64 KiB, so long reports are cut. */
+export declare const MAX_MARKDOWN_ROWS = 200;
+/** Report for GitHub step summaries and PR comments: severity counts, then one table row per finding. */
+export declare function renderMarkdown(result: ScanResult, options?: ReportOptions): string;
+/**
+ * Makes untrusted text safe inside a GitHub table cell: one line, no
+ * invisible characters, no raw HTML, and markdown punctuation (including
+ * pipes and backticks) escaped so it renders literally.
+ */
+export declare function escapeCell(text: string, max?: number): string;

package/dist/report/markdown.js

@@ -0,0 +1,87 @@
+import { countBySeverity } from '../scan/engine.js';
+import { SEVERITIES } from '../types.js';
+import { printable, truncate } from '../util/text.js';
+import { VERSION } from '../version.js';
+/** GitHub caps step summaries at 1 MiB and PR comments at 64 KiB, so long reports are cut. */
+export const MAX_MARKDOWN_ROWS = 200;
+const MAX_CELL = 300;
+const MAX_REMEDIATIONS = 50;
+/** Report for GitHub step summaries and PR comments: severity counts, then one table row per finding. */
+export function renderMarkdown(result, options = {}) {
+    const version = options.version ?? VERSION;
+    const findings = result.findings;
+    const out = ['## toolmoat scan results', ''];
+    out.push(`Scanned ${plural(result.filesScanned, 'file')} in ${plural(result.targets.length, 'target')} with toolmoat ${escapeCell(version)}.`, '');
+    if (findings.length === 0) {
+        out.push('**No issues found.**', '');
+    }
+    else {
+        const counts = countBySeverity(findings);
+        out.push('| Severity | Findings |', '| --- | ---: |');
+        for (const severity of SEVERITIES)
+            out.push(`| ${label(severity)} | ${counts[severity]} |`);
+        out.push('', '### Findings', '', '| Severity | Rule | Location | Message |', '| --- | --- | --- | --- |');
+        for (const finding of findings.slice(0, MAX_MARKDOWN_ROWS))
+            out.push(row(finding));
+        out.push('');
+        if (findings.length > MAX_MARKDOWN_ROWS) {
+            out.push(`Showing the first ${MAX_MARKDOWN_ROWS} of ${findings.length} findings. Run \`toolmoat scan\` locally or use \`--format sarif\` for the full list.`, '');
+        }
+        out.push(...remediations(findings));
+    }
+    const notes = footnotes(result, options);
+    if (notes.length > 0)
+        out.push(...notes, '');
+    return `${out.join('\n').trimEnd()}\n`;
+}
+function row(finding) {
+    const severity = finding.severity === 'critical' || finding.severity === 'high' ? `**${label(finding.severity)}**` : label(finding.severity);
+    const rule = `\`${finding.ruleId}\` ${escapeCell(finding.title)}`;
+    return `| ${severity} | ${rule} | ${escapeCell(locationOf(finding))} | ${escapeCell(finding.message)} |`;
+}
+function remediations(findings) {
+    const seen = new Set();
+    const items = [];
+    for (const finding of findings) {
+        if (!finding.remediation || seen.has(finding.ruleId))
+            continue;
+        seen.add(finding.ruleId);
+        if (items.length < MAX_REMEDIATIONS)
+            items.push(`- \`${finding.ruleId}\` ${escapeCell(finding.title)}: ${escapeCell(finding.remediation, 600)}`);
+    }
+    return items.length === 0 ? [] : ['### How to fix', '', ...items, ''];
+}
+function footnotes(result, options) {
+    const notes = [];
+    if (options.hidden)
+        notes.push(`${plural(options.hidden, 'finding')} below ${options.minSeverity ?? 'low'} not shown.`);
+    if (options.suppressed)
+        notes.push(`${plural(options.suppressed, 'finding')} suppressed by ${escapeCell(options.ignoreFile ?? 'the ignore file')}.`);
+    if (result.skipped.length > 0)
+        notes.push(`${plural(result.skipped.length, 'file')} skipped.`);
+    return notes.length === 0 ? [] : [notes.join(' ')];
+}
+function locationOf(finding) {
+    if (finding.line === undefined)
+        return finding.file;
+    return finding.column === undefined ? `${finding.file}:${finding.line}` : `${finding.file}:${finding.line}:${finding.column}`;
+}
+/**
+ * Makes untrusted text safe inside a GitHub table cell: one line, no
+ * invisible characters, no raw HTML, and markdown punctuation (including
+ * pipes and backticks) escaped so it renders literally.
+ */
+export function escapeCell(text, max = MAX_CELL) {
+    const flat = truncate(printable(text.replace(/\r?\n/g, ' ')).trim(), max);
+    return flat
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/[\\`*_[\]|~]/g, (ch) => `\\${ch}`);
+}
+function label(severity) {
+    return severity.charAt(0).toUpperCase() + severity.slice(1);
+}
+function plural(n, noun) {
+    return `${n} ${noun}${n === 1 ? '' : 's'}`;
+}

package/dist/report/sarif.d.ts

@@ -0,0 +1,89 @@
+import type { Category, ScanResult, Severity } from '../types.js';
+import type { ReportOptions } from './index.js';
+export declare const SARIF_SCHEMA = "https://json.schemastore.org/sarif-2.1.0.json";
+export declare const INFORMATION_URI = "https://github.com/Whitul/toolmoat";
+type SarifLevel = 'error' | 'warning' | 'note';
+export interface SarifArtifactLocation {
+    uri: string;
+    uriBaseId?: string;
+}
+export interface SarifReportingDescriptor {
+    id: string;
+    name: string;
+    shortDescription: {
+        text: string;
+    };
+    fullDescription: {
+        text: string;
+    };
+    help: {
+        text: string;
+        markdown: string;
+    };
+    defaultConfiguration: {
+        level: SarifLevel;
+    };
+    properties: {
+        tags: string[];
+        precision: 'high' | 'medium';
+        'security-severity': string;
+    };
+}
+export interface SarifResult {
+    ruleId: string;
+    ruleIndex: number;
+    level: SarifLevel;
+    message: {
+        text: string;
+    };
+    locations: {
+        physicalLocation: {
+            artifactLocation: SarifArtifactLocation;
+            region: {
+                startLine: number;
+                startColumn?: number;
+                snippet?: {
+                    text: string;
+                };
+            };
+        };
+    }[];
+    partialFingerprints: {
+        primaryLocationLineHash: string;
+    };
+    properties: {
+        severity: Severity;
+        category: Category;
+        target?: string;
+    };
+}
+export interface SarifLog {
+    $schema: string;
+    version: '2.1.0';
+    runs: {
+        tool: {
+            driver: {
+                name: string;
+                version: string;
+                semanticVersion: string;
+                informationUri: string;
+                rules: SarifReportingDescriptor[];
+            };
+        };
+        originalUriBaseIds: Record<string, {
+            uri: string;
+        }>;
+        columnKind: 'utf16CodeUnits';
+        results: SarifResult[];
+    }[];
+}
+/** SARIF 2.1.0 for GitHub code scanning and other SARIF viewers. */
+export declare function renderSarif(result: ScanResult, options?: ReportOptions): string;
+export declare function buildSarif(result: ScanResult, options?: ReportOptions): SarifLog;
+/**
+ * Where a finding lives, as SARIF wants it: a forward-slash path relative to
+ * %SRCROOT% (the cwd) when the file is inside it, a file:/// URI for files
+ * elsewhere such as ~/.claude, and synthetic ids like mcp://server/tool as is.
+ */
+export declare function sarifArtifactLocation(file: string, cwd: string, filePaths?: ReadonlyMap<string, string>): SarifArtifactLocation;
+export {};

package/dist/report/sarif.js

@@ -0,0 +1,142 @@
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { sha256 } from '../util/hash.js';
+import { expandHome } from '../util/paths.js';
+import { printable } from '../util/text.js';
+import { VERSION } from '../version.js';
+export const SARIF_SCHEMA = 'https://json.schemastore.org/sarif-2.1.0.json';
+export const INFORMATION_URI = 'https://github.com/Whitul/toolmoat';
+const SRCROOT = '%SRCROOT%';
+const LEVEL = {
+    critical: 'error',
+    high: 'error',
+    medium: 'warning',
+    low: 'note',
+    info: 'note',
+};
+/** GitHub code scanning maps these to its critical/high/medium/low buckets. */
+const SECURITY_SEVERITY = {
+    critical: '9.5',
+    high: '8.0',
+    medium: '5.5',
+    low: '3.0',
+    info: '0.0',
+};
+/** SARIF 2.1.0 for GitHub code scanning and other SARIF viewers. */
+export function renderSarif(result, options = {}) {
+    return `${JSON.stringify(buildSarif(result, options), null, 2)}\n`;
+}
+export function buildSarif(result, options = {}) {
+    const version = options.version ?? VERSION;
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    const descriptors = [];
+    const indexById = new Map();
+    const addDescriptor = (descriptor) => {
+        const existing = indexById.get(descriptor.id);
+        if (existing !== undefined)
+            return existing;
+        indexById.set(descriptor.id, descriptors.length);
+        descriptors.push(descriptor);
+        return descriptors.length - 1;
+    };
+    for (const rule of result.rules)
+        addDescriptor(ruleDescriptor(rule));
+    const occurrences = new Map();
+    const results = result.findings.map((finding) => {
+        const ruleIndex = indexById.get(finding.ruleId) ?? addDescriptor(findingDescriptor(finding));
+        const hash = sha256(`${finding.ruleId}\n${finding.file}\n${finding.snippet ?? ''}`).slice('sha256:'.length);
+        const occurrence = (occurrences.get(hash) ?? 0) + 1;
+        occurrences.set(hash, occurrence);
+        const region = { startLine: Math.max(1, finding.line ?? 1) };
+        if (finding.line !== undefined && finding.column !== undefined)
+            region.startColumn = Math.max(1, finding.column);
+        if (finding.snippet)
+            region.snippet = { text: finding.snippet };
+        const properties = { severity: finding.severity, category: finding.category };
+        if (finding.target !== undefined)
+            properties.target = finding.target;
+        return {
+            ruleId: finding.ruleId,
+            ruleIndex,
+            level: LEVEL[finding.severity],
+            message: { text: printable(finding.message) },
+            locations: [{ physicalLocation: { artifactLocation: sarifArtifactLocation(finding.file, cwd, options.filePaths), region } }],
+            partialFingerprints: { primaryLocationLineHash: `${hash.slice(0, 32)}:${occurrence}` },
+            properties,
+        };
+    });
+    return {
+        $schema: SARIF_SCHEMA,
+        version: '2.1.0',
+        runs: [
+            {
+                tool: { driver: { name: 'toolmoat', version, semanticVersion: version, informationUri: INFORMATION_URI, rules: descriptors } },
+                originalUriBaseIds: { [SRCROOT]: { uri: directoryUri(cwd) } },
+                columnKind: 'utf16CodeUnits',
+                results,
+            },
+        ],
+    };
+}
+/**
+ * Where a finding lives, as SARIF wants it: a forward-slash path relative to
+ * %SRCROOT% (the cwd) when the file is inside it, a file:/// URI for files
+ * elsewhere such as ~/.claude, and synthetic ids like mcp://server/tool as is.
+ */
+export function sarifArtifactLocation(file, cwd, filePaths) {
+    if (file.includes('://'))
+        return { uri: file };
+    const absolute = filePaths?.get(file) ?? absoluteFromDisplay(file);
+    if (absolute === undefined)
+        return { uri: encodePath(file), uriBaseId: SRCROOT };
+    const relative = path.relative(cwd, absolute);
+    if (relative && relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative)) {
+        return { uri: encodePath(relative.split(path.sep).join('/')), uriBaseId: SRCROOT };
+    }
+    return { uri: pathToFileURL(absolute).href };
+}
+function absoluteFromDisplay(file) {
+    if (file === '~' || file.startsWith('~/') || file.startsWith('~\\'))
+        return expandHome(file);
+    return path.isAbsolute(file) ? file : undefined;
+}
+function encodePath(relative) {
+    return relative.replace(/\\/g, '/').split('/').map(encodeURIComponent).join('/');
+}
+function directoryUri(dir) {
+    const href = pathToFileURL(dir).href;
+    return href.endsWith('/') ? href : `${href}/`;
+}
+function ruleDescriptor(rule) {
+    return descriptor(rule.id, rule.title, rule.description, rule.severity, rule.category, rule.remediation, rule.kinds);
+}
+/** Fallback for a finding whose rule is not in the active rule list, so ruleIndex always resolves. */
+function findingDescriptor(finding) {
+    return descriptor(finding.ruleId, finding.title, finding.title, finding.severity, finding.category, finding.remediation, []);
+}
+function descriptor(id, title, description, severity, category, remediation, kinds) {
+    const facts = `Severity: ${severity}. Category: ${category}.${kinds.length > 0 ? ` Applies to: ${kinds.join(', ')}.` : ''}`;
+    const text = [description, remediation ? `How to fix: ${remediation}` : '', facts].filter(Boolean).join('\n\n');
+    const markdown = [`**${title}**`, description, remediation ? `**How to fix:** ${remediation}` : '', facts].filter(Boolean).join('\n\n');
+    return {
+        id,
+        name: pascalCase(title) || id.replace(/-/g, ''),
+        shortDescription: { text: title },
+        fullDescription: { text: description },
+        help: { text, markdown },
+        defaultConfiguration: { level: LEVEL[severity] },
+        properties: {
+            tags: ['security', category],
+            precision: severity === 'critical' || severity === 'high' ? 'high' : 'medium',
+            'security-severity': SECURITY_SEVERITY[severity],
+        },
+    };
+}
+/** "Download piped into a shell" -> "DownloadPipedIntoAShell". */
+function pascalCase(title) {
+    return title
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}

package/dist/report/text.d.ts

@@ -0,0 +1,16 @@
+import type { ScanResult } from '../types.js';
+import type { ReportOptions } from './index.js';
+/**
+ * Renders findings for a terminal or a CI log: grouped by target, then file,
+ * with remediation once per rule at the end. Output is ASCII apart from the
+ * ellipsis in truncated snippets, and every attacker-influenced string goes
+ * through printable() so a scanned file cannot inject terminal escapes.
+ */
+export declare function renderText(result: ScanResult, options?: ReportOptions): string;
+/**
+ * Short form of a path for headers. Display paths (relative, "~/..." or
+ * synthetic ids) pass through; absolute paths become "." or a path relative
+ * to cwd when inside it, "~/..." inside the home directory, otherwise stay
+ * absolute. Always with forward slashes.
+ */
+export declare function shortPath(p: string, cwd?: string): string;

package/dist/report/text.js

@@ -0,0 +1,206 @@
+import path from 'node:path';
+import { countBySeverity } from '../scan/engine.js';
+import { SEVERITIES } from '../types.js';
+import { palette } from '../util/colors.js';
+import { homeDir } from '../util/paths.js';
+import { printable } from '../util/text.js';
+import { VERSION } from '../version.js';
+const BADGE_WIDTH = 'CRITICAL'.length;
+const WRAP_WIDTH = 100;
+const MAX_HEADER_ROOTS = 4;
+/**
+ * Renders findings for a terminal or a CI log: grouped by target, then file,
+ * with remediation once per rule at the end. Output is ASCII apart from the
+ * ellipsis in truncated snippets, and every attacker-influenced string goes
+ * through printable() so a scanned file cannot inject terminal escapes.
+ */
+export function renderText(result, options = {}) {
+    const c = palette(process.stdout, options.color ?? false);
+    const cwd = options.cwd ?? process.cwd();
+    const lines = [];
+    if (!options.quiet) {
+        lines.push(header(result, options, cwd));
+        if (result.filesScanned === 0)
+            lines.push('No agent skills, plugins, hooks or MCP configs were found.');
+        if (options.ignoreFile)
+            lines.push(c.gray(`Ignore file: ${printable(options.ignoreFile)}`));
+        lines.push('');
+    }
+    for (const group of groupByTarget(result.findings)) {
+        lines.push(`${c.bold(group.label)} ${c.gray(`(${plural(group.findings.length, 'finding')})`)}`);
+        for (const finding of group.findings)
+            lines.push(...findingBlock(finding, c), '');
+    }
+    if (!options.quiet) {
+        lines.push(...remediationSection(result.findings, c));
+        lines.push(...footer(result, options, c));
+    }
+    while (lines.length > 0 && lines[lines.length - 1] === '')
+        lines.pop();
+    return lines.length === 0 ? '' : `${lines.join('\n')}\n`;
+}
+function header(result, options, cwd) {
+    const version = options.version ?? VERSION;
+    let text = `toolmoat ${version} scanned ${plural(result.filesScanned, 'file')} in ${plural(result.targets.length, 'target')}`;
+    const roots = (options.roots ?? []).map((root) => printable(shortPath(root, cwd)));
+    if (roots.length > 0) {
+        const shown = options.verbose || roots.length <= MAX_HEADER_ROOTS ? roots : [...roots.slice(0, MAX_HEADER_ROOTS - 1), `+${roots.length - MAX_HEADER_ROOTS + 1} more`];
+        text += ` (${shown.join(', ')})`;
+    }
+    return `${text} in ${formatDuration(result.durationMs)}`;
+}
+function findingBlock(finding, c) {
+    const lines = [
+        `  ${badge(finding.severity, c)}  ${c.cyan(finding.ruleId)}  ${c.bold(printable(finding.title))}`,
+        `    ${location(finding)}  ${printable(finding.message)}`,
+    ];
+    if (finding.snippet)
+        lines.push(`    ${c.gray(`> ${printable(finding.snippet)}`)}`);
+    return lines;
+}
+function remediationSection(findings, c) {
+    const seen = new Set();
+    const lines = [];
+    for (const finding of findings) {
+        if (!finding.remediation || seen.has(finding.ruleId))
+            continue;
+        seen.add(finding.ruleId);
+        lines.push(`  ${c.cyan(finding.ruleId)}  ${c.bold(printable(finding.title))}`);
+        lines.push(...wrapText(finding.remediation, WRAP_WIDTH, '    '));
+    }
+    return lines.length === 0 ? [] : [c.bold('How to fix'), ...lines, ''];
+}
+function footer(result, options, c) {
+    const lines = [];
+    const total = result.findings.length;
+    if (total === 0) {
+        lines.push(c.green('No issues found.'));
+    }
+    else {
+        const counts = countBySeverity(result.findings);
+        const parts = SEVERITIES.filter((s) => counts[s] > 0).map((s) => colorFor(s, c)(`${counts[s]} ${s}`));
+        lines.push(`${c.bold(plural(total, 'finding'))}: ${parts.join(', ')}`);
+    }
+    if (options.hidden) {
+        const below = options.minSeverity ?? 'low';
+        lines.push(c.gray(`${plural(options.hidden, 'finding')} below ${below} not shown (use --min-severity info to include them).`));
+    }
+    if (options.suppressed) {
+        lines.push(c.gray(`${plural(options.suppressed, 'finding')} suppressed by ${printable(options.ignoreFile ?? 'the ignore file')}.`));
+    }
+    if (result.skipped.length > 0) {
+        if (options.verbose) {
+            lines.push(`Skipped ${plural(result.skipped.length, 'file')}:`);
+            for (const skip of result.skipped)
+                lines.push(`  ${printable(skip.path)}  ${c.gray(printable(skip.reason))}`);
+        }
+        else {
+            lines.push(c.gray(`Skipped ${plural(result.skipped.length, 'file')} (use --verbose to list them).`));
+        }
+    }
+    return lines;
+}
+/** Groups findings by target in order of first appearance, then by file within each target, keeping the incoming order otherwise. */
+function groupByTarget(findings) {
+    const groups = new Map();
+    for (const finding of findings) {
+        const key = finding.target ?? '';
+        const list = groups.get(key);
+        if (list)
+            list.push(finding);
+        else
+            groups.set(key, [finding]);
+    }
+    return [...groups].map(([target, list]) => {
+        const fileOrder = new Map();
+        for (const f of list)
+            if (!fileOrder.has(f.file))
+                fileOrder.set(f.file, fileOrder.size);
+        const sorted = [...list].sort((a, b) => fileOrder.get(a.file) - fileOrder.get(b.file));
+        return { label: target ? printable(target) : 'Other files', findings: sorted };
+    });
+}
+function location(finding) {
+    let text = printable(finding.file);
+    if (finding.line !== undefined)
+        text += `:${finding.line}`;
+    if (finding.line !== undefined && finding.column !== undefined)
+        text += `:${finding.column}`;
+    return text;
+}
+function badge(severity, c) {
+    return colorFor(severity, c)(severity.toUpperCase().padEnd(BADGE_WIDTH));
+}
+function colorFor(severity, c) {
+    switch (severity) {
+        case 'critical':
+            return (s) => c.bold(c.magenta(s));
+        case 'high':
+            return (s) => c.bold(c.red(s));
+        case 'medium':
+            return c.yellow;
+        case 'low':
+            return c.blue;
+        case 'info':
+            return c.gray;
+    }
+}
+/**
+ * Short form of a path for headers. Display paths (relative, "~/..." or
+ * synthetic ids) pass through; absolute paths become "." or a path relative
+ * to cwd when inside it, "~/..." inside the home directory, otherwise stay
+ * absolute. Always with forward slashes.
+ */
+export function shortPath(p, cwd = process.cwd()) {
+    if (p.includes('://'))
+        return p;
+    if (!path.isAbsolute(p))
+        return toSlash(p) || '.';
+    const abs = path.resolve(p);
+    const home = homeDir();
+    const fromCwd = path.relative(cwd, abs);
+    if (fromCwd === '')
+        return '.';
+    if (path.resolve(cwd) !== path.resolve(home) && isInside(fromCwd))
+        return toSlash(fromCwd);
+    const fromHome = path.relative(home, abs);
+    if (fromHome === '')
+        return '~';
+    if (isInside(fromHome))
+        return `~/${toSlash(fromHome)}`;
+    return toSlash(abs);
+}
+function isInside(relative) {
+    return relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+}
+function toSlash(p) {
+    return p.split(path.sep).join('/');
+}
+function plural(n, noun) {
+    return `${n} ${noun}${n === 1 ? '' : 's'}`;
+}
+function formatDuration(ms) {
+    return ms < 1000 ? `${Math.max(0, Math.round(ms))} ms` : `${(ms / 1000).toFixed(1)} s`;
+}
+/** Word-wraps each paragraph of text to width columns, prefixing every line with indent. */
+function wrapText(text, width, indent) {
+    const out = [];
+    const room = Math.max(20, width - indent.length);
+    for (const paragraph of text.split(/\r?\n/)) {
+        let line = '';
+        for (const word of printable(paragraph).split(/\s+/)) {
+            if (!word)
+                continue;
+            if (line && line.length + 1 + word.length > room) {
+                out.push(indent + line);
+                line = word;
+            }
+            else {
+                line = line ? `${line} ${word}` : word;
+            }
+        }
+        if (line)
+            out.push(indent + line);
+    }
+    return out;
+}

package/dist/rules/code.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Dangerous-code rules: things a skill, hook, command file or MCP server
+ * script does that an attacker wants but a benign tool almost never needs.
+ *
+ * These rules also run over one-line command strings (the config scanner wraps
+ * a hook command, an MCP server command line or a package.json script in a
+ * synthetic ScanFile of kind 'script'), so every pattern must work on a single
+ * line as well as inside a multi-line script.
+ *
+ * All regexes are linear-time: bounded repetition, no nested quantifiers,
+ * anchored on a distinctive keyword so attacker-controlled filler cannot make
+ * the engine backtrack.
+ */
+import type { Rule } from '../types.js';
+export declare const codeRules: readonly Rule[];