npm - semlint-cli - Versions diffs - 0.1.0 - Mend

semlint-cli 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/README.md +162 -0
package/dist/backend.js +205 -0
package/dist/cli.js +93 -0
package/dist/config.js +108 -0
package/dist/diagnostics.js +91 -0
package/dist/filter.js +144 -0
package/dist/git.js +85 -0
package/dist/main.js +186 -0
package/dist/reporter.js +42 -0
package/dist/rules.js +88 -0
package/dist/types.js +2 -0
package/package.json +51 -0
package/rules/SEMLINT_NAMING_001.json +12 -0
package/rules/SEMLINT_PATTERN_002.json +12 -0
package/rules/SEMLINT_SWE_003.json +12 -0

package/README.md ADDED Viewed

@@ -0,0 +1,162 @@
+# Semlint CLI MVP
+Semlint is a deterministic semantic lint CLI that:
+- reads a git diff,
+- runs enabled semantic rules in parallel,
+- executes an external backend command per rule,
+- prints text or JSON diagnostics,
+- returns CI-friendly exit codes.
+## Install
+```bash
+pnpm install
+pnpm build
+```
+## Command
+```bash
+semlint check
+```
+If running from source:
+```bash
+pnpm check
+```
+## CLI flags
+- `--backend <name>`: override backend name
+- `--model <name>`: override model name
+- `--config <path>`: config file path
+- `--format <text|json>`: output format
+- `--base <ref>`: base git ref for explicit ref-to-ref diff
+- `--head <ref>`: head git ref for explicit ref-to-ref diff
+- `--fail-on <error|warn|never>`: failure threshold (default `error`)
+- `--batch`: run all selected rules in one backend call
+- `--debug`: enable debug logs to stderr
+Default diff behavior (without `--base`/`--head`) uses your local branch state:
+- tracked changes across commits since merge-base,
+- staged changes,
+- unstaged changes,
+- untracked files.
+If you pass `--base` or `--head`, Semlint uses explicit `git diff <base> <head>` mode.
+## Exit codes
+- `0`: no blocking diagnostics
+- `1`: blocking diagnostics found
+- `2`: backend/runtime failure
+## Config discovery order
+1. `--config <path>`
+2. `./semlint.json`
+3. `./.semlint.json`
+4. defaults
+Unknown fields are ignored.
+## Minimal config example
+```json
+{
+  "backend": "cursor-cli",
+  "model": "auto",
+  "budgets": {
+    "timeout_ms": 120000
+  },
+  "output": {
+    "format": "text"
+  },
+  "execution": {
+    "batch": false
+  },
+  "rules": {
+    "disable": ["SEMLINT_EXAMPLE_001"],
+    "severity_overrides": {
+      "SEMLINT_API_001": "error"
+    }
+  },
+  "backends": {
+    "cursor-cli": {
+      "executable": "agent"
+    }
+  }
+}
+```
+## Rule files
+Rule JSON files are loaded from `rules/`.
+Required fields:
+- `id` (string, unique)
+- `title` (string)
+- `severity_default` (`error|warn|info`)
+- `prompt` (non-empty string)
+Optional fields:
+- `include_globs`: string[]
+- `exclude_globs`: string[]
+- `diff_regex`: string[]
+Invalid rules cause runtime failure with exit code `2`.
+## Backend contract
+For backend `cursor-cli`, Semlint executes:
+```bash
+cursor agent "<prompt>" --model <model> --print --output-format text
+```
+For `cursor-cli`, Semlint always uses `cursor agent` directly.
+Other backend names still resolve executables from config:
+- `backends.<backend>.executable` if provided
+Backend stdout must be valid JSON with shape:
+```json
+{
+  "diagnostics": [
+    {
+      "rule_id": "SEMLINT_API_001",
+      "severity": "warn",
+      "message": "text",
+      "file": "src/file.ts",
+      "line": 42
+    }
+  ]
+}
+```
+If parsing fails, Semlint retries once with appended instruction:
+`Return valid JSON only.`
+## Batch mode
+Use batch mode to reduce cost by evaluating all runnable rules in a single backend call:
+```bash
+semlint check --batch
+```
+Or configure it in `semlint.json`:
+```json
+{
+  "execution": {
+    "batch": true
+  }
+}
+```

package/dist/backend.js ADDED Viewed

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBackendRunner = createBackendRunner;
+const node_child_process_1 = require("node:child_process");
+const STRICT_JSON_RETRY_INSTRUCTION = [
+    "Return valid JSON only.",
+    "Do not include markdown fences.",
+    "Do not include commentary, headings, or any text before/after JSON.",
+    "The first character of your response must be '{' and the last must be '}'.",
+    'Output must match: {"diagnostics":[{"rule_id":"<id>","severity":"error|warn|info","message":"<text>","file":"<path>","line":1}]}'
+].join(" ");
+function isEnoentError(error) {
+    return (typeof error === "object" &&
+        error !== null &&
+        "code" in error &&
+        error.code === "ENOENT");
+}
+function debugLog(enabled, message) {
+    if (enabled) {
+        process.stderr.write(`[debug] ${message}\n`);
+    }
+}
+function resolveCommandSpecs(config) {
+    if (config.backend === "cursor-cli") {
+        // Always use `cursor agent` directly for cursor-cli.
+        return [{ executable: "cursor", argsPrefix: ["agent"] }];
+    }
+    const configuredExecutable = config.backendExecutables[config.backend];
+    if (!configuredExecutable) {
+        throw new Error(`No executable configured for backend "${config.backend}". Configure it under backends.${config.backend}.executable`);
+    }
+    return [{ executable: configuredExecutable, argsPrefix: [] }];
+}
+function executeBackendCommand(executable, args, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const startedAt = Date.now();
+        const child = (0, node_child_process_1.spawn)(executable, args, {
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        let timedOut = false;
+        const timer = setTimeout(() => {
+            timedOut = true;
+            child.kill("SIGKILL");
+        }, timeoutMs);
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", (error) => {
+            clearTimeout(timer);
+            reject(error);
+        });
+        child.on("close", (code) => {
+            clearTimeout(timer);
+            if (timedOut) {
+                reject(new Error(`Backend timed out after ${timeoutMs}ms`));
+                return;
+            }
+            if (code !== 0) {
+                reject(new Error(`Backend command failed with code ${code}. stderr: ${stderr.trim() || "(empty)"}`));
+                return;
+            }
+            resolve({ stdout, stderr, elapsedMs: Date.now() - startedAt });
+        });
+    });
+}
+function extractFirstJsonObject(raw) {
+    let start = -1;
+    let depth = 0;
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < raw.length; i += 1) {
+        const ch = raw[i];
+        if (start === -1) {
+            if (ch === "{") {
+                start = i;
+                depth = 1;
+            }
+            continue;
+        }
+        if (inString) {
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (ch === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === "\"") {
+            inString = true;
+            continue;
+        }
+        if (ch === "{") {
+            depth += 1;
+            continue;
+        }
+        if (ch === "}") {
+            depth -= 1;
+            if (depth === 0) {
+                return raw.slice(start, i + 1);
+            }
+        }
+    }
+    return undefined;
+}
+function parseBackendResult(raw) {
+    const candidate = raw.trim();
+    let parsed;
+    try {
+        parsed = JSON.parse(candidate);
+    }
+    catch {
+        const extracted = extractFirstJsonObject(candidate);
+        if (!extracted) {
+            throw new Error(`Backend output is not valid JSON: ${candidate.slice(0, 200)}`);
+        }
+        parsed = JSON.parse(extracted);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error("Backend output JSON root must be an object");
+    }
+    const diagnostics = parsed.diagnostics;
+    if (!Array.isArray(diagnostics)) {
+        throw new Error("Backend output must contain diagnostics array");
+    }
+    return { diagnostics: diagnostics };
+}
+function createBackendRunner(config) {
+    const commandSpecs = resolveCommandSpecs(config);
+    return {
+        async runPrompt(input) {
+            let lastError;
+            for (const spec of commandSpecs) {
+                const commandName = [spec.executable, ...spec.argsPrefix].join(" ");
+                const baseArgs = [
+                    ...spec.argsPrefix,
+                    input.prompt,
+                    "--model",
+                    config.model,
+                    "--print",
+                    "--mode",
+                    "ask",
+                    "--output-format",
+                    "text"
+                ];
+                try {
+                    debugLog(config.debug, `${input.label}: backend attempt 1 via "${commandName}" (timeout ${input.timeoutMs}ms)`);
+                    const first = await executeBackendCommand(spec.executable, baseArgs, input.timeoutMs);
+                    debugLog(config.debug, `${input.label}: backend attempt 1 completed in ${first.elapsedMs}ms`);
+                    return parseBackendResult(first.stdout.trim());
+                }
+                catch (firstError) {
+                    debugLog(config.debug, `${input.label}: backend attempt 1 failed (${firstError instanceof Error ? firstError.message : String(firstError)})`);
+                    const retryPrompt = `${input.prompt}\n\n${STRICT_JSON_RETRY_INSTRUCTION}`;
+                    const retryArgs = [
+                        ...spec.argsPrefix,
+                        retryPrompt,
+                        "--model",
+                        config.model,
+                        "--print",
+                        "--mode",
+                        "ask",
+                        "--output-format",
+                        "text"
+                    ];
+                    try {
+                        debugLog(config.debug, `${input.label}: backend attempt 2 via "${commandName}" (timeout ${input.timeoutMs}ms)`);
+                        const second = await executeBackendCommand(spec.executable, retryArgs, input.timeoutMs);
+                        debugLog(config.debug, `${input.label}: backend attempt 2 completed in ${second.elapsedMs}ms`);
+                        return parseBackendResult(second.stdout.trim());
+                    }
+                    catch (secondError) {
+                        debugLog(config.debug, `${input.label}: backend attempt 2 failed (${secondError instanceof Error ? secondError.message : String(secondError)})`);
+                        lastError = secondError;
+                        if (isEnoentError(secondError)) {
+                            continue;
+                        }
+                        if (isEnoentError(firstError)) {
+                            continue;
+                        }
+                        throw firstError;
+                    }
+                }
+            }
+            throw lastError instanceof Error ? lastError : new Error(String(lastError));
+        },
+        async runRule(input) {
+            return this.runPrompt({
+                label: `Rule ${input.ruleId}`,
+                prompt: input.prompt,
+                timeoutMs: input.timeoutMs
+            });
+        }
+    };
+}

package/dist/cli.js ADDED Viewed

@@ -0,0 +1,93 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const main_1 = require("./main");
+const FLAGS_WITH_VALUES = new Set([
+    "--backend",
+    "--model",
+    "--config",
+    "--format",
+    "--base",
+    "--head",
+    "--fail-on"
+]);
+function isOutputFormat(value) {
+    return value === "text" || value === "json";
+}
+function isFailOn(value) {
+    return value === "error" || value === "warn" || value === "never";
+}
+function parseArgs(argv) {
+    const [command, ...rest] = argv;
+    if (!command || command !== "check") {
+        throw new Error("Usage: semlint check [--backend <name>] [--model <name>] [--config <path>] [--format <text|json>] [--base <ref>] [--head <ref>] [--fail-on <error|warn|never>] [--batch] [--debug]");
+    }
+    const options = {
+        command: "check",
+        debug: false
+    };
+    for (let i = 0; i < rest.length; i += 1) {
+        const token = rest[i];
+        if (token === "--debug") {
+            options.debug = true;
+            continue;
+        }
+        if (token === "--batch") {
+            options.batch = true;
+            continue;
+        }
+        if (!FLAGS_WITH_VALUES.has(token)) {
+            throw new Error(`Unknown flag: ${token}`);
+        }
+        const value = rest[i + 1];
+        if (!value || value.startsWith("--")) {
+            throw new Error(`Missing value for flag: ${token}`);
+        }
+        i += 1;
+        switch (token) {
+            case "--backend":
+                options.backend = value;
+                break;
+            case "--model":
+                options.model = value;
+                break;
+            case "--config":
+                options.configPath = value;
+                break;
+            case "--format":
+                if (!isOutputFormat(value)) {
+                    throw new Error(`Invalid --format value: ${value}`);
+                }
+                options.format = value;
+                break;
+            case "--base":
+                options.base = value;
+                break;
+            case "--head":
+                options.head = value;
+                break;
+            case "--fail-on":
+                if (!isFailOn(value)) {
+                    throw new Error(`Invalid --fail-on value: ${value}`);
+                }
+                options.failOn = value;
+                break;
+            default:
+                throw new Error(`Unsupported flag: ${token}`);
+        }
+    }
+    return options;
+}
+async function main() {
+    try {
+        const options = parseArgs(process.argv.slice(2));
+        const exitCode = await (0, main_1.runSemlint)(options);
+        process.exitCode = exitCode;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        process.exitCode = 2;
+    }
+}
+void main();

package/dist/config.js ADDED Viewed

@@ -0,0 +1,108 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveConfigPath = resolveConfigPath;
+exports.loadEffectiveConfig = loadEffectiveConfig;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const VALID_SEVERITIES = new Set(["error", "warn", "info"]);
+const DEFAULTS = {
+    backend: "cursor-cli",
+    model: "auto",
+    timeoutMs: 120000,
+    format: "text",
+    failOn: "error",
+    base: "origin/main",
+    head: "HEAD",
+    debug: false,
+    batchMode: false,
+    rulesDisable: [],
+    severityOverrides: {},
+    backendExecutables: {
+        "cursor-cli": "cursor"
+    }
+};
+function readJsonIfExists(filePath) {
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return undefined;
+    }
+    const raw = node_fs_1.default.readFileSync(filePath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`Config at ${filePath} must be a JSON object`);
+    }
+    return parsed;
+}
+function resolveConfigPath(explicitPath) {
+    if (explicitPath) {
+        return node_path_1.default.resolve(explicitPath);
+    }
+    const cwd = process.cwd();
+    const primary = node_path_1.default.join(cwd, "semlint.json");
+    if (node_fs_1.default.existsSync(primary)) {
+        return primary;
+    }
+    const secondary = node_path_1.default.join(cwd, ".semlint.json");
+    if (node_fs_1.default.existsSync(secondary)) {
+        return secondary;
+    }
+    return undefined;
+}
+function sanitizeSeverityOverrides(value) {
+    if (!value) {
+        return {};
+    }
+    const out = {};
+    for (const [ruleId, severity] of Object.entries(value)) {
+        if (typeof severity === "string" && VALID_SEVERITIES.has(severity)) {
+            out[ruleId] = severity;
+        }
+    }
+    return out;
+}
+function sanitizeBackendExecutables(value) {
+    const out = {
+        ...DEFAULTS.backendExecutables
+    };
+    if (!value) {
+        return out;
+    }
+    for (const [name, candidate] of Object.entries(value)) {
+        if (typeof candidate === "object" &&
+            candidate !== null &&
+            "executable" in candidate &&
+            typeof candidate.executable === "string" &&
+            candidate.executable.trim() !== "") {
+            out[name] = candidate.executable.trim();
+        }
+    }
+    return out;
+}
+function loadEffectiveConfig(options) {
+    const configPath = resolveConfigPath(options.configPath);
+    const parsed = configPath ? readJsonIfExists(configPath) : undefined;
+    const fileConfig = (parsed ?? {});
+    return {
+        backend: options.backend ?? fileConfig.backend ?? DEFAULTS.backend,
+        model: options.model ?? fileConfig.model ?? DEFAULTS.model,
+        timeoutMs: typeof fileConfig.budgets?.timeout_ms === "number"
+            ? fileConfig.budgets.timeout_ms
+            : DEFAULTS.timeoutMs,
+        format: options.format ?? fileConfig.output?.format ?? DEFAULTS.format,
+        failOn: options.failOn ?? DEFAULTS.failOn,
+        base: options.base ?? DEFAULTS.base,
+        head: options.head ?? DEFAULTS.head,
+        debug: options.debug || DEFAULTS.debug,
+        batchMode: options.batch ??
+            (typeof fileConfig.execution?.batch === "boolean"
+                ? fileConfig.execution.batch
+                : DEFAULTS.batchMode),
+        rulesDisable: Array.isArray(fileConfig.rules?.disable)
+            ? fileConfig.rules?.disable.filter((item) => typeof item === "string")
+            : DEFAULTS.rulesDisable,
+        severityOverrides: sanitizeSeverityOverrides((fileConfig.rules?.severity_overrides ?? undefined)),
+        backendExecutables: sanitizeBackendExecutables((fileConfig.backends ?? undefined))
+    };
+}

package/dist/diagnostics.js ADDED Viewed

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeDiagnostics = normalizeDiagnostics;
+exports.sortDiagnostics = sortDiagnostics;
+exports.hasBlockingDiagnostic = hasBlockingDiagnostic;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const VALID_SEVERITIES = new Set(["error", "warn", "info"]);
+function isPositiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 1;
+}
+function normalizeDiagnostics(ruleId, diagnostics, debug) {
+    const out = [];
+    for (const raw of diagnostics) {
+        if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+            if (debug) {
+                process.stderr.write(`[debug] Dropped diagnostic for ${ruleId}: not an object\n`);
+            }
+            continue;
+        }
+        const candidate = raw;
+        const severity = candidate.severity;
+        const file = candidate.file;
+        const line = candidate.line;
+        const message = candidate.message;
+        const candidateRuleId = candidate.rule_id;
+        if (typeof candidateRuleId !== "string" ||
+            candidateRuleId !== ruleId ||
+            typeof file !== "string" ||
+            file.trim() === "" ||
+            typeof message !== "string" ||
+            message.trim() === "" ||
+            typeof severity !== "string" ||
+            !VALID_SEVERITIES.has(severity) ||
+            !isPositiveInteger(line)) {
+            if (debug) {
+                process.stderr.write(`[debug] Dropped diagnostic for ${ruleId}: failed required field validation\n`);
+            }
+            continue;
+        }
+        const absolute = node_path_1.default.resolve(file);
+        if (!node_fs_1.default.existsSync(absolute)) {
+            if (debug) {
+                process.stderr.write(`[debug] Dropped diagnostic for ${ruleId}: file does not exist (${file})\n`);
+            }
+            continue;
+        }
+        out.push({
+            rule_id: candidateRuleId,
+            severity: severity,
+            message,
+            file,
+            line,
+            column: isPositiveInteger(candidate.column) ? candidate.column : undefined,
+            end_line: isPositiveInteger(candidate.end_line) ? candidate.end_line : undefined,
+            end_column: isPositiveInteger(candidate.end_column) ? candidate.end_column : undefined,
+            evidence: typeof candidate.evidence === "string" ? candidate.evidence : undefined,
+            confidence: typeof candidate.confidence === "number" ? candidate.confidence : undefined
+        });
+    }
+    return out;
+}
+const SEVERITY_ORDER = {
+    error: 3,
+    warn: 2,
+    info: 1
+};
+function sortDiagnostics(input) {
+    return [...input].sort((a, b) => {
+        const fileCompare = a.file.localeCompare(b.file);
+        if (fileCompare !== 0) {
+            return fileCompare;
+        }
+        if (a.line !== b.line) {
+            return a.line - b.line;
+        }
+        return SEVERITY_ORDER[b.severity] - SEVERITY_ORDER[a.severity];
+    });
+}
+function hasBlockingDiagnostic(diagnostics, threshold) {
+    if (threshold === "never") {
+        return false;
+    }
+    if (threshold === "warn") {
+        return diagnostics.some((d) => d.severity === "warn" || d.severity === "error");
+    }
+    return diagnostics.some((d) => d.severity === "error");
+}

package/dist/filter.js ADDED Viewed

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractChangedFilesFromDiff = extractChangedFilesFromDiff;
+exports.getRuleCandidateFiles = getRuleCandidateFiles;
+exports.shouldRunRule = shouldRunRule;
+exports.buildScopedDiff = buildScopedDiff;
+exports.buildRulePrompt = buildRulePrompt;
+const picomatch_1 = __importDefault(require("picomatch"));
+function unquoteDiffPath(raw) {
+    if (raw.startsWith("\"") && raw.endsWith("\"") && raw.length >= 2) {
+        return raw.slice(1, -1).replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
+    }
+    return raw;
+}
+function parseDiffGitHeader(line) {
+    const match = line.match(/^diff --git (?:"a\/((?:[^"\\]|\\.)+)"|a\/(\S+)) (?:"b\/((?:[^"\\]|\\.)+)"|b\/(\S+))$/);
+    if (!match) {
+        return undefined;
+    }
+    const aRaw = match[1] ?? match[2];
+    const bRaw = match[3] ?? match[4];
+    if (!aRaw || !bRaw) {
+        return undefined;
+    }
+    return {
+        aPath: unquoteDiffPath(aRaw),
+        bPath: unquoteDiffPath(bRaw)
+    };
+}
+function extractChangedFilesFromDiff(diff) {
+    const files = new Set();
+    const lines = diff.split("\n");
+    for (const line of lines) {
+        if (!line.startsWith("diff --git ")) {
+            continue;
+        }
+        const parsed = parseDiffGitHeader(line);
+        if (!parsed) {
+            continue;
+        }
+        const normalized = parsed.bPath;
+        if (normalized !== "/dev/null") {
+            files.add(normalized);
+        }
+    }
+    return Array.from(files);
+}
+function matchesAnyGlob(filePath, globs) {
+    return globs.some((glob) => (0, picomatch_1.default)(glob)(filePath));
+}
+function matchesAnyRegex(diff, regexes) {
+    for (const candidate of regexes) {
+        try {
+            const pattern = new RegExp(candidate, "m");
+            if (pattern.test(diff)) {
+                return true;
+            }
+        }
+        catch {
+            return false;
+        }
+    }
+    return false;
+}
+function getRuleCandidateFiles(rule, changedFiles) {
+    let fileCandidates = changedFiles;
+    if (rule.include_globs && rule.include_globs.length > 0) {
+        fileCandidates = changedFiles.filter((filePath) => matchesAnyGlob(filePath, rule.include_globs));
+        if (fileCandidates.length === 0) {
+            return [];
+        }
+    }
+    if (rule.exclude_globs && rule.exclude_globs.length > 0) {
+        fileCandidates = fileCandidates.filter((filePath) => !matchesAnyGlob(filePath, rule.exclude_globs));
+    }
+    return fileCandidates;
+}
+function shouldRunRule(rule, changedFiles, diff) {
+    const fileCandidates = getRuleCandidateFiles(rule, changedFiles);
+    if (fileCandidates.length === 0) {
+        return false;
+    }
+    if (rule.diff_regex && rule.diff_regex.length > 0 && !matchesAnyRegex(diff, rule.diff_regex)) {
+        return false;
+    }
+    return true;
+}
+function splitDiffIntoFileChunks(diff) {
+    const lines = diff.split("\n");
+    const chunks = [];
+    let currentLines = [];
+    let currentFile = "";
+    const flush = () => {
+        if (currentLines.length === 0) {
+            return;
+        }
+        chunks.push({
+            file: currentFile,
+            chunk: currentLines.join("\n")
+        });
+        currentLines = [];
+        currentFile = "";
+    };
+    for (const line of lines) {
+        if (line.startsWith("diff --git ")) {
+            flush();
+            const parsed = parseDiffGitHeader(line);
+            if (parsed) {
+                currentFile = parsed.bPath;
+            }
+        }
+        currentLines.push(line);
+    }
+    flush();
+    return chunks;
+}
+function buildScopedDiff(rule, fullDiff, changedFiles) {
+    const candidateFiles = new Set(getRuleCandidateFiles(rule, changedFiles));
+    if (candidateFiles.size === 0) {
+        return fullDiff;
+    }
+    const chunks = splitDiffIntoFileChunks(fullDiff);
+    const scoped = chunks
+        .filter((chunk) => chunk.file !== "" && candidateFiles.has(chunk.file))
+        .map((chunk) => chunk.chunk)
+        .join("\n");
+    return scoped.trim() === "" ? fullDiff : scoped;
+}
+function buildRulePrompt(rule, diff) {
+    return [
+        `RULE_ID: ${rule.id}`,
+        `RULE_TITLE: ${rule.title}`,
+        `SEVERITY_DEFAULT: ${rule.effectiveSeverity}`,
+        "",
+        "DIFF:",
+        diff,
+        "",
+        "INSTRUCTIONS:",
+        rule.prompt
+    ].join("\n");
+}

package/dist/git.js ADDED Viewed

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getGitDiff = getGitDiff;
+exports.getLocalBranchDiff = getLocalBranchDiff;
+const node_child_process_1 = require("node:child_process");
+const node_os_1 = require("node:os");
+function runGitCommand(args, okExitCodes = [0]) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)("git", args, {
+            stdio: ["ignore", "pipe", "pipe"]
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", (error) => reject(error));
+        child.on("close", (code) => {
+            const exitCode = code ?? 1;
+            if (!okExitCodes.includes(exitCode)) {
+                reject(new Error(`git ${args.join(" ")} failed with code ${exitCode}: ${stderr.trim()}`));
+                return;
+            }
+            resolve({
+                code: exitCode,
+                stdout,
+                stderr
+            });
+        });
+    });
+}
+async function getGitDiff(base, head) {
+    const result = await runGitCommand(["diff", base, head]);
+    return result.stdout;
+}
+function isMissingRefError(message) {
+    return /(not a valid object name|unknown revision|bad revision|no upstream configured|no upstream branch)/i.test(message);
+}
+async function resolveLocalComparisonBase() {
+    const candidates = ["@{upstream}", "origin/main", "main"];
+    for (const candidate of candidates) {
+        try {
+            const result = await runGitCommand(["merge-base", "HEAD", candidate]);
+            const mergeBase = result.stdout.trim();
+            if (mergeBase !== "") {
+                return mergeBase;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (!isMissingRefError(message)) {
+                throw error;
+            }
+            continue;
+        }
+    }
+    return "HEAD";
+}
+async function getUntrackedFiles() {
+    const result = await runGitCommand(["ls-files", "--others", "--exclude-standard"]);
+    return result.stdout
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+}
+async function getNoIndexDiffForFile(filePath) {
+    const result = await runGitCommand(["diff", "--no-index", "--", node_os_1.devNull, filePath], [0, 1]);
+    return result.stdout;
+}
+async function getLocalBranchDiff() {
+    const base = await resolveLocalComparisonBase();
+    const trackedDiff = await runGitCommand(["diff", base]);
+    const untrackedFiles = await getUntrackedFiles();
+    const untrackedDiffChunks = [];
+    for (const filePath of untrackedFiles) {
+        const fileDiff = await getNoIndexDiffForFile(filePath);
+        if (fileDiff.trim() !== "") {
+            untrackedDiffChunks.push(fileDiff);
+        }
+    }
+    return [trackedDiff.stdout, ...untrackedDiffChunks].filter((chunk) => chunk !== "").join("\n");
+}

package/dist/main.js ADDED Viewed

@@ -0,0 +1,186 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSemlint = runSemlint;
+const node_path_1 = __importDefault(require("node:path"));
+const backend_1 = require("./backend");
+const config_1 = require("./config");
+const diagnostics_1 = require("./diagnostics");
+const filter_1 = require("./filter");
+const git_1 = require("./git");
+const reporter_1 = require("./reporter");
+const rules_1 = require("./rules");
+const VERSION = "0.1.0";
+function debugLog(enabled, message) {
+    if (enabled) {
+        process.stderr.write(`[debug] ${message}\n`);
+    }
+}
+function timed(enabled, label, action) {
+    const startedAt = Date.now();
+    const result = action();
+    debugLog(enabled, `${label} in ${Date.now() - startedAt}ms`);
+    return result;
+}
+async function timedAsync(enabled, label, action) {
+    const startedAt = Date.now();
+    const result = await action();
+    debugLog(enabled, `${label} in ${Date.now() - startedAt}ms`);
+    return result;
+}
+function buildBatchPrompt(rules, diff) {
+    const ruleBlocks = rules
+        .map((rule) => [
+        `RULE_ID: ${rule.id}`,
+        `RULE_TITLE: ${rule.title}`,
+        `SEVERITY_DEFAULT: ${rule.effectiveSeverity}`,
+        "INSTRUCTIONS:",
+        rule.prompt
+    ].join("\n"))
+        .join("\n\n---\n\n");
+    return [
+        "BATCH_MODE: true",
+        "Evaluate all rules below against the DIFF in one pass.",
+        "Return valid JSON only with shape {\"diagnostics\":[...]}",
+        "Each diagnostic must include: rule_id, severity, message, file, line.",
+        "",
+        "RULES:",
+        ruleBlocks,
+        "",
+        "DIFF:",
+        diff
+    ].join("\n");
+}
+async function runSemlint(options) {
+    const startedAt = Date.now();
+    try {
+        const config = timed(options.debug, "Loaded effective config", () => (0, config_1.loadEffectiveConfig)(options));
+        const rulesDir = node_path_1.default.join(process.cwd(), "rules");
+        const rules = timed(config.debug, "Loaded and validated rules", () => (0, rules_1.loadRules)(rulesDir, config.rulesDisable, config.severityOverrides));
+        debugLog(config.debug, `Loaded ${rules.length} rule(s)`);
+        debugLog(config.debug, `Rule IDs: ${rules.map((rule) => rule.id).join(", ")}`);
+        const useLocalBranchDiff = !options.base && !options.head;
+        const diff = await timedAsync(config.debug, "Computed git diff", () => useLocalBranchDiff ? (0, git_1.getLocalBranchDiff)() : (0, git_1.getGitDiff)(config.base, config.head));
+        const changedFiles = timed(config.debug, "Parsed changed files from diff", () => (0, filter_1.extractChangedFilesFromDiff)(diff));
+        debugLog(config.debug, useLocalBranchDiff
+            ? "Using local branch diff (tracked + staged + unstaged + untracked)"
+            : `Using explicit ref diff (${config.base}..${config.head})`);
+        debugLog(config.debug, `Detected ${changedFiles.length} changed file(s)`);
+        const backend = timed(config.debug, "Initialized backend runner", () => (0, backend_1.createBackendRunner)(config));
+        const runnableRules = rules.filter((rule) => {
+            const filterStartedAt = Date.now();
+            const shouldRun = (0, filter_1.shouldRunRule)(rule, changedFiles, diff);
+            debugLog(config.debug, `Rule ${rule.id}: filter check in ${Date.now() - filterStartedAt}ms`);
+            if (!shouldRun) {
+                debugLog(config.debug, `Skipping rule ${rule.id}: filters did not match`);
+                return false;
+            }
+            return true;
+        });
+        const diagnostics = [];
+        const rulesRun = runnableRules.length;
+        let backendErrors = 0;
+        if (config.batchMode && runnableRules.length > 0) {
+            debugLog(config.debug, `Running ${runnableRules.length} rule(s) in batch mode`);
+            const combinedDiff = timed(config.debug, "Batch: combined scoped diff build", () => runnableRules
+                .map((rule) => (0, filter_1.buildScopedDiff)(rule, diff, changedFiles))
+                .filter((chunk) => chunk.trim() !== "")
+                .join("\n"));
+            const batchPrompt = timed(config.debug, "Batch: prompt build", () => buildBatchPrompt(runnableRules, combinedDiff || diff));
+            try {
+                const batchResult = await timedAsync(config.debug, "Batch: backend run", () => backend.runPrompt({
+                    label: "Batch",
+                    prompt: batchPrompt,
+                    timeoutMs: config.timeoutMs
+                }));
+                const groupedByRule = new Map();
+                for (const diagnostic of batchResult.diagnostics) {
+                    if (typeof diagnostic === "object" &&
+                        diagnostic !== null &&
+                        !Array.isArray(diagnostic) &&
+                        typeof diagnostic.rule_id === "string") {
+                        const ruleId = diagnostic.rule_id;
+                        const current = groupedByRule.get(ruleId) ?? [];
+                        current.push(diagnostic);
+                        groupedByRule.set(ruleId, current);
+                    }
+                    else {
+                        debugLog(config.debug, "Batch: dropped diagnostic without valid rule_id");
+                    }
+                }
+                const validRuleIds = new Set(runnableRules.map((rule) => rule.id));
+                for (const [ruleId] of groupedByRule) {
+                    if (!validRuleIds.has(ruleId)) {
+                        debugLog(config.debug, `Batch: dropped diagnostic for unknown rule_id ${ruleId}`);
+                    }
+                }
+                for (const rule of runnableRules) {
+                    const normalized = timed(config.debug, `Batch: diagnostics normalization for ${rule.id}`, () => (0, diagnostics_1.normalizeDiagnostics)(rule.id, groupedByRule.get(rule.id) ?? [], config.debug));
+                    diagnostics.push(...normalized);
+                }
+            }
+            catch (error) {
+                backendErrors += 1;
+                const message = error instanceof Error ? error.message : String(error);
+                debugLog(config.debug, `Batch backend error: ${message}`);
+            }
+        }
+        else {
+            debugLog(config.debug, `Running ${runnableRules.length} rule(s) in parallel`);
+            const runResults = await Promise.all(runnableRules.map(async (rule) => {
+                let backendError = false;
+                let normalized = [];
+                const ruleStartedAt = Date.now();
+                debugLog(config.debug, `Rule ${rule.id}: started`);
+                const scopedDiff = timed(config.debug, `Rule ${rule.id}: scoped diff build`, () => (0, filter_1.buildScopedDiff)(rule, diff, changedFiles));
+                const prompt = timed(config.debug, `Rule ${rule.id}: prompt build`, () => (0, filter_1.buildRulePrompt)(rule, scopedDiff));
+                try {
+                    const result = await timedAsync(config.debug, `Rule ${rule.id}: backend run`, () => backend.runRule({
+                        ruleId: rule.id,
+                        prompt,
+                        timeoutMs: config.timeoutMs
+                    }));
+                    normalized = timed(config.debug, `Rule ${rule.id}: diagnostics normalization`, () => (0, diagnostics_1.normalizeDiagnostics)(rule.id, result.diagnostics, config.debug));
+                }
+                catch (error) {
+                    backendError = true;
+                    const message = error instanceof Error ? error.message : String(error);
+                    debugLog(config.debug, `Backend error for rule ${rule.id}: ${message}`);
+                }
+                debugLog(config.debug, `Rule ${rule.id}: finished in ${Date.now() - ruleStartedAt}ms`);
+                return { backendError, normalized };
+            }));
+            for (const result of runResults) {
+                if (result.backendError) {
+                    backendErrors += 1;
+                }
+                diagnostics.push(...result.normalized);
+            }
+        }
+        const sorted = timed(config.debug, "Sorted diagnostics", () => (0, diagnostics_1.sortDiagnostics)(diagnostics));
+        const durationMs = Date.now() - startedAt;
+        const outputStartedAt = Date.now();
+        if (config.format === "json") {
+            process.stdout.write(`${(0, reporter_1.formatJsonOutput)(VERSION, sorted, { rulesRun, durationMs, backendErrors })}\n`);
+        }
+        else {
+            process.stdout.write(`${(0, reporter_1.formatTextOutput)(sorted)}\n`);
+        }
+        debugLog(config.debug, `Rendered output in ${Date.now() - outputStartedAt}ms`);
+        debugLog(config.debug, `Total run duration ${durationMs}ms`);
+        if (backendErrors > 0) {
+            return 2;
+        }
+        if ((0, diagnostics_1.hasBlockingDiagnostic)(sorted, config.failOn)) {
+            return 1;
+        }
+        return 0;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        process.stderr.write(`${message}\n`);
+        return 2;
+    }
+}

package/dist/reporter.js ADDED Viewed

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatJsonOutput = formatJsonOutput;
+exports.formatTextOutput = formatTextOutput;
+function formatJsonOutput(version, diagnostics, stats) {
+    const payload = {
+        tool: {
+            name: "semlint",
+            version
+        },
+        diagnostics,
+        stats: {
+            rules_run: stats.rulesRun,
+            duration_ms: stats.durationMs,
+            backend_errors: stats.backendErrors
+        }
+    };
+    return JSON.stringify(payload, null, 2);
+}
+function formatTextOutput(diagnostics) {
+    const lines = [];
+    let currentFile = "";
+    for (const diagnostic of diagnostics) {
+        if (diagnostic.file !== currentFile) {
+            if (lines.length > 0) {
+                lines.push("");
+            }
+            currentFile = diagnostic.file;
+            lines.push(currentFile);
+        }
+        const column = diagnostic.column ?? 1;
+        lines.push(`  ${diagnostic.line}:${column}  ${diagnostic.severity}  ${diagnostic.rule_id}  ${diagnostic.message}`);
+    }
+    const errors = diagnostics.filter((d) => d.severity === "error").length;
+    const warnings = diagnostics.filter((d) => d.severity === "warn").length;
+    const problems = diagnostics.length;
+    if (lines.length > 0) {
+        lines.push("");
+    }
+    lines.push(`✖ ${problems} problems (${errors} errors, ${warnings} warnings)`);
+    return lines.join("\n");
+}

package/dist/rules.js ADDED Viewed

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRules = loadRules;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const VALID_SEVERITIES = new Set(["error", "warn", "info"]);
+function assertNonEmptyString(value, fieldName, filePath) {
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new Error(`Invalid rule in ${filePath}: "${fieldName}" must be a non-empty string`);
+    }
+    return value;
+}
+function assertStringArray(value, fieldName, filePath) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+        throw new Error(`Invalid rule in ${filePath}: "${fieldName}" must be an array of strings`);
+    }
+    return value;
+}
+function validateRuleObject(raw, filePath) {
+    if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+        throw new Error(`Invalid rule in ${filePath}: root must be a JSON object`);
+    }
+    const obj = raw;
+    const severity = assertNonEmptyString(obj.severity_default, "severity_default", filePath);
+    if (!VALID_SEVERITIES.has(severity)) {
+        throw new Error(`Invalid rule in ${filePath}: "severity_default" must be one of error|warn|info`);
+    }
+    return {
+        id: assertNonEmptyString(obj.id, "id", filePath),
+        title: assertNonEmptyString(obj.title, "title", filePath),
+        severity_default: severity,
+        prompt: assertNonEmptyString(obj.prompt, "prompt", filePath),
+        include_globs: assertStringArray(obj.include_globs, "include_globs", filePath),
+        exclude_globs: assertStringArray(obj.exclude_globs, "exclude_globs", filePath),
+        diff_regex: assertStringArray(obj.diff_regex, "diff_regex", filePath)
+    };
+}
+function loadRules(rulesDir, disabledRuleIds, severityOverrides) {
+    if (!node_fs_1.default.existsSync(rulesDir)) {
+        return [];
+    }
+    if (!node_fs_1.default.statSync(rulesDir).isDirectory()) {
+        throw new Error(`Rules path is not a directory: ${rulesDir}`);
+    }
+    const entries = node_fs_1.default
+        .readdirSync(rulesDir)
+        .filter((name) => name.endsWith(".json"))
+        .sort((a, b) => a.localeCompare(b));
+    const seenIds = new Set();
+    const disabled = new Set(disabledRuleIds);
+    const loaded = [];
+    for (const fileName of entries) {
+        const filePath = node_path_1.default.join(rulesDir, fileName);
+        let parsed;
+        try {
+            parsed = JSON.parse(node_fs_1.default.readFileSync(filePath, "utf8"));
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`Failed to parse rule JSON in ${filePath}: ${message}`);
+        }
+        const validated = validateRuleObject(parsed, filePath);
+        if (seenIds.has(validated.id)) {
+            throw new Error(`Duplicate rule id detected: ${validated.id}`);
+        }
+        seenIds.add(validated.id);
+        if (disabled.has(validated.id)) {
+            continue;
+        }
+        const overrideSeverity = severityOverrides[validated.id];
+        const effectiveSeverity = overrideSeverity ?? validated.severity_default;
+        if (!VALID_SEVERITIES.has(effectiveSeverity)) {
+            throw new Error(`Invalid severity override for rule ${validated.id}`);
+        }
+        loaded.push({
+            ...validated,
+            sourcePath: filePath,
+            effectiveSeverity
+        });
+    }
+    return loaded.sort((a, b) => a.id.localeCompare(b.id));
+}

package/dist/types.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ "use strict";
2	+ Object.defineProperty(exports, "__esModule", { value: true });

package/package.json ADDED Viewed

@@ -0,0 +1,51 @@
+{
+  "name": "semlint-cli",
+  "version": "0.1.0",
+  "description": "Semantic lint CLI — runs LLM-backed rules on your git diff and returns CI-friendly exit codes",
+  "type": "commonjs",
+  "main": "dist/main.js",
+  "bin": {
+    "semlint": "dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "rules",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "pnpm run build",
+    "check": "node dist/cli.js check",
+    "start": "node dist/cli.js check",
+    "serve:docs": "serve docs"
+  },
+  "keywords": [
+    "lint",
+    "semantic",
+    "git",
+    "diff",
+    "ci",
+    "llm",
+    "cursor",
+    "code-review"
+  ],
+  "author": "bduron",
+  "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bduron/semlint.git"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "packageManager": "pnpm@10.29.2",
+  "dependencies": {
+    "picomatch": "^4.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "^25.3.0",
+    "@types/picomatch": "^4.0.2",
+    "serve": "^14.2.5",
+    "typescript": "^5.9.3"
+  }
+}

package/rules/SEMLINT_NAMING_001.json ADDED Viewed

@@ -0,0 +1,12 @@
+{
+  "id": "SEMLINT_NAMING_001",
+  "title": "Ambient naming convention consistency",
+  "severity_default": "warn",
+  "include_globs": ["src/**/*.ts"],
+  "exclude_globs": ["**/*.test.ts", "**/*.spec.ts"],
+  "diff_regex": [
+    "^[+-].*\\b(const|let|var|function|class|interface|type|enum)\\b",
+    "^[+-].*\\b[A-Za-z_][A-Za-z0-9_]*\\b"
+  ],
+  "prompt": "You are Semlint. Review ONLY the modified code in the provided DIFF and verify naming is consistent with the ambient naming conventions already used in surrounding code. Focus on identifier styles such as camelCase for variables/functions, PascalCase for classes/types/interfaces, and ALL_CAPS for constants where that convention is clearly established nearby. Flag only clear inconsistencies in newly added or renamed identifiers. Ignore untouched legacy naming unless directly impacted by the change. Return valid JSON only with shape {\"diagnostics\":[...]} and each diagnostic must include: rule_id, severity, message, file, line."
+}

package/rules/SEMLINT_PATTERN_002.json ADDED Viewed

@@ -0,0 +1,12 @@
+{
+  "id": "SEMLINT_PATTERN_002",
+  "title": "Ambient pattern is respected",
+  "severity_default": "warn",
+  "include_globs": ["src/**/*.ts"],
+  "exclude_globs": ["**/*.test.ts", "**/*.spec.ts"],
+  "diff_regex": [
+    "^[+-].*\\b(async|await|Promise|try|catch|throw|switch|map|filter|reduce|forEach)\\b",
+    "^[+-].*\\b(import|export|class|interface|type|function|return)\\b"
+  ],
+  "prompt": "You are Semlint. Review ONLY the modified code in the provided DIFF and check whether ambient implementation patterns are respected. Compare new or changed code against nearby established patterns for control flow, async handling, error propagation, data transformation, module boundaries, and function/class structure. Flag clear regressions where the proposed change deviates from consistent local patterns without obvious justification. Ignore untouched legacy code and acceptable intentional improvements. Return valid JSON only with shape {\"diagnostics\":[...]} and each diagnostic must include: rule_id, severity, message, file, line."
+}

package/rules/SEMLINT_SWE_003.json ADDED Viewed

@@ -0,0 +1,12 @@
+{
+  "id": "SEMLINT_SWE_003",
+  "title": "Obvious SWE mistakes",
+  "severity_default": "warn",
+  "include_globs": ["src/**/*.ts"],
+  "exclude_globs": ["**/*.test.ts", "**/*.spec.ts"],
+  "diff_regex": [
+    "^[+-].*\\b(any|as\\s+any|TODO|FIXME|console\\.log|@ts-ignore|throw\\s+new\\s+Error|catch\\s*\\()\\b",
+    "^[+-].*\\b(if|else|switch|return|await|Promise|map|forEach|reduce)\\b"
+  ],
+  "prompt": "You are Semlint. Review ONLY the modified code in the DIFF and find obvious software-engineering mistakes in the proposed change. Focus on clear issues such as dead code, side-effect misuse, swallowed errors, unsafe any-casts, accidental debug leftovers, contradictory conditions, and obvious maintainability hazards that are likely unintended (these are only examples, there are many more). Do not nitpick style or architecture unless the issue is clearly harmful. Report only high-signal findings tied to changed lines. Return valid JSON only with shape {\"diagnostics\":[...]} and each diagnostic must include: rule_id, severity, message, file, line."
+}