semlint-cli 0.1.5 → 0.1.6

package/README.md

@@ -75,7 +75,6 @@ Unknown fields are ignored.
 ```json
 {
   "backend": "cursor-cli",
-  "model": "auto",
   "budgets": {
     "timeout_ms": 120000
   },
@@ -93,7 +92,9 @@ Unknown fields are ignored.
   },
   "backends": {
     "cursor-cli": {
-      "executable": "agent"
+      "executable": "cursor",
+      "model": "auto",
+      "args": ["agent", "{prompt}", "--model", "{model}", "--print", "--mode", "ask", "--output-format", "text"]
     }
   }
 }
@@ -138,16 +139,32 @@ Invalid rules cause runtime failure with exit code `2`.
 
 ## Backend contract
 
-For backend `cursor-cli`, Semlint executes:
+Semlint is fully config-driven at runtime. For the selected `backend`, it executes:
 
-```bash
-cursor agent "<prompt>" --model <model> --print --output-format text
-```
+- `backends.<backend>.executable` as the binary
+- `backends.<backend>.model` as the backend-specific model (unless `--model` is passed)
+- `backends.<backend>.args` as the argument template
+
+`args` supports placeholder tokens:
 
-For `cursor-cli`, Semlint always uses `cursor agent` directly.
-Other backend names still resolve executables from config:
+- `{prompt}`: replaced with the generated prompt
+- `{model}`: replaced with the configured model
 
-- `backends.<backend>.executable` if provided
+Placeholders are exact-match substitutions on whole args. Backends must be fully configured in `semlint.json`; there are no runtime fallbacks.
+
+Example:
+
+```json
+{
+  "backends": {
+    "cursor-cli": {
+      "executable": "cursor",
+      "model": "auto",
+      "args": ["agent", "{prompt}", "--model", "{model}", "--print", "--mode", "ask", "--output-format", "text"]
+    }
+  }
+}
+```
 
 Backend stdout must be valid JSON with shape:
 
@@ -168,6 +185,17 @@ Backend stdout must be valid JSON with shape:
 If parsing fails, Semlint retries once with appended instruction:
 `Return valid JSON only.`
 
+If backend execution still fails and Semlint is running in an interactive terminal (TTY), it automatically performs one interactive passthrough run so you can satisfy backend setup prompts (for example auth/workspace trust), then retries machine parsing once.
+
+## Prompt files
+
+Core system prompts are externalized under `prompts/` so prompt behavior is easy to inspect and iterate:
+
+- `prompts/common-contract.md`: shared output schema and base rules used by both modes
+- `prompts/rule.md`: single-rule evaluation prompt
+- `prompts/batch.md`: batch evaluation prompt
+- `prompts/retry-json.md`: strict JSON retry instruction
+
 ## Batch mode
 
 Use batch mode to reduce cost by evaluating all runnable rules in a single backend call:

package/dist/adapters.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BUILTIN_ADAPTERS = void 0;
+exports.BUILTIN_ADAPTERS = {
+    "cursor-cli": {
+        defaultExecutable: "cursor",
+        buildArgs: (prompt, model) => [
+            "agent",
+            prompt,
+            "--model",
+            model,
+            "--print",
+            "--mode",
+            "ask",
+            "--output-format",
+            "text"
+        ]
+    },
+    "claude-code": {
+        defaultExecutable: "claude",
+        buildArgs: (prompt, model) => [prompt, "--model", model, "--output-format", "json"]
+    },
+    "codex-cli": {
+        defaultExecutable: "codex",
+        buildArgs: (prompt, model) => [prompt, "--model", model]
+    }
+};

package/dist/backend.js

@@ -2,34 +2,39 @@
 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(" ");
+const prompts_1 = require("./prompts");
+const utils_1 = require("./utils");
+const STRICT_JSON_RETRY_INSTRUCTION = (0, prompts_1.getStrictJsonRetryInstruction)();
 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 logBackendCommand(label, executable, args, prompt) {
+    const printableParts = [executable, ...args.map((arg) => (arg === prompt ? "<prompt-redacted>" : arg))];
+    process.stderr.write(`[semlint] ${label}: ${printableParts.join(" ")}\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`);
+    const configuredBackend = config.backendConfigs[config.backend];
+    if (!configuredBackend) {
+        throw new Error(`Backend "${config.backend}" is not configured. Add it under backends.${config.backend} in semlint.json (run "semlint init" to scaffold a complete config).`);
     }
-    return [{ executable: configuredExecutable, argsPrefix: [] }];
+    return [
+        {
+            executable: configuredBackend.executable,
+            args: configuredBackend.args
+        }
+    ];
+}
+function interpolateArgs(args, prompt, model) {
+    return args.map((arg) => {
+        if (arg === "{prompt}")
+            return prompt;
+        if (arg === "{model}")
+            return model;
+        return arg;
+    });
 }
 function executeBackendCommand(executable, args, timeoutMs) {
     return new Promise((resolve, reject) => {
@@ -68,6 +73,26 @@ function executeBackendCommand(executable, args, timeoutMs) {
         });
     });
 }
+function executeBackendCommandInteractive(executable, args) {
+    return new Promise((resolve, reject) => {
+        const child = (0, node_child_process_1.spawn)(executable, args, {
+            stdio: "inherit"
+        });
+        child.on("error", (error) => {
+            reject(error);
+        });
+        child.on("close", (code) => {
+            if (code !== 0) {
+                reject(new Error(`Interactive backend command failed with code ${code}`));
+                return;
+            }
+            resolve();
+        });
+    });
+}
+function canUseInteractiveRecovery() {
+    return Boolean(process.stdin.isTTY && process.stdout.isTTY && process.stderr.isTTY);
+}
 function extractFirstJsonObject(raw) {
     let start = -1;
     let depth = 0;
@@ -137,62 +162,73 @@ function parseBackendResult(raw) {
 }
 function createBackendRunner(config) {
     const commandSpecs = resolveCommandSpecs(config);
+    async function runWithRetry(spec, input) {
+        const commandName = spec.executable;
+        const firstPrompt = input.prompt;
+        const firstArgs = interpolateArgs(spec.args, firstPrompt, config.model);
+        let interactiveRecoveryAttempted = false;
+        try {
+            if (config.debug) {
+                logBackendCommand(`${input.label} attempt 1`, spec.executable, firstArgs, firstPrompt);
+            }
+            (0, utils_1.debugLog)(config.debug, `${input.label}: backend attempt 1 via "${commandName}" (timeout ${input.timeoutMs}ms)`);
+            const first = await executeBackendCommand(spec.executable, firstArgs, input.timeoutMs);
+            (0, utils_1.debugLog)(config.debug, `${input.label}: backend attempt 1 completed in ${first.elapsedMs}ms`);
+            return parseBackendResult(first.stdout.trim());
+        }
+        catch (firstError) {
+            (0, utils_1.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 = interpolateArgs(spec.args, retryPrompt, config.model);
+            try {
+                if (config.debug) {
+                    logBackendCommand(`${input.label} attempt 2`, spec.executable, retryArgs, retryPrompt);
+                }
+                (0, utils_1.debugLog)(config.debug, `${input.label}: backend attempt 2 via "${commandName}" (timeout ${input.timeoutMs}ms)`);
+                const second = await executeBackendCommand(spec.executable, retryArgs, input.timeoutMs);
+                (0, utils_1.debugLog)(config.debug, `${input.label}: backend attempt 2 completed in ${second.elapsedMs}ms`);
+                return parseBackendResult(second.stdout.trim());
+            }
+            catch (secondError) {
+                (0, utils_1.debugLog)(config.debug, `${input.label}: backend attempt 2 failed (${secondError instanceof Error ? secondError.message : String(secondError)})`);
+                if (!interactiveRecoveryAttempted &&
+                    !isEnoentError(firstError) &&
+                    !isEnoentError(secondError) &&
+                    canUseInteractiveRecovery()) {
+                    interactiveRecoveryAttempted = true;
+                    process.stderr.write("[semlint] Backend requires interactive setup. Switching to interactive passthrough once...\n");
+                    await executeBackendCommandInteractive(spec.executable, firstArgs);
+                    (0, utils_1.debugLog)(config.debug, `${input.label}: interactive setup completed; retrying backend in machine mode`);
+                    const recovered = await executeBackendCommand(spec.executable, firstArgs, input.timeoutMs);
+                    return parseBackendResult(recovered.stdout.trim());
+                }
+                if (isEnoentError(secondError) || isEnoentError(firstError)) {
+                    return null;
+                }
+                throw firstError;
+            }
+        }
+    }
     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;
+                    const result = await runWithRetry(spec, input);
+                    if (result) {
+                        return result;
                     }
+                    continue;
                 }
+                catch (error) {
+                    lastError = error;
+                    throw error;
+                }
+            }
+            if (lastError) {
+                throw lastError instanceof Error ? lastError : new Error(String(lastError));
             }
-            throw lastError instanceof Error ? lastError : new Error(String(lastError));
+            throw new Error(`No backend command could be executed for "${config.backend}"`);
         },
         async runRule(input) {
             return this.runPrompt({

package/dist/config.js

@@ -7,7 +7,7 @@ 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 utils_1 = require("./utils");
 const DEFAULTS = {
     backend: "cursor-cli",
     model: "auto",
@@ -20,9 +20,7 @@ const DEFAULTS = {
     batchMode: false,
     rulesDisable: [],
     severityOverrides: {},
-    backendExecutables: {
-        "cursor-cli": "cursor"
-    }
+    backendConfigs: {}
 };
 function readJsonIfExists(filePath) {
     if (!node_fs_1.default.existsSync(filePath)) {
@@ -54,39 +52,51 @@ 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;
+    return Object.fromEntries(Object.entries(value).flatMap(([ruleId, severity]) => typeof severity === "string" && utils_1.VALID_SEVERITIES.has(severity)
+        ? [[ruleId, severity]]
+        : []));
 }
-function sanitizeBackendExecutables(value) {
-    const out = {
-        ...DEFAULTS.backendExecutables
-    };
+function sanitizeBackendConfigs(value) {
     if (!value) {
-        return out;
+        return {};
     }
-    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 Object.fromEntries(Object.entries(value).flatMap(([name, candidate]) => {
+        if (typeof candidate !== "object" || candidate === null) {
+            return [];
+        }
+        const executable = "executable" in candidate && typeof candidate.executable === "string"
+            ? candidate.executable.trim()
+            : "";
+        const args = "args" in candidate ? candidate.args : undefined;
+        const model = "model" in candidate && typeof candidate.model === "string"
+            ? candidate.model.trim()
+            : undefined;
+        if (!executable || !Array.isArray(args) || args.some((arg) => typeof arg !== "string")) {
+            return [];
         }
+        const normalizedArgs = args;
+        if (!normalizedArgs.includes("{prompt}")) {
+            return [];
+        }
+        return [[name, { executable, args: normalizedArgs, model: model && model !== "" ? model : undefined }]];
+    }));
+}
+function ensureSelectedBackendIsConfigured(backend, backendConfigs) {
+    if (!(backend in backendConfigs)) {
+        throw new Error(`Backend "${backend}" is not configured. Add it under backends.${backend} with executable and args (including "{prompt}") in semlint.json.`);
     }
-    return out;
 }
 function loadEffectiveConfig(options) {
     const configPath = resolveConfigPath(options.configPath);
     const parsed = configPath ? readJsonIfExists(configPath) : undefined;
     const fileConfig = (parsed ?? {});
+    const backend = options.backend ?? fileConfig.backend ?? DEFAULTS.backend;
+    const backendConfigs = sanitizeBackendConfigs((fileConfig.backends ?? undefined));
+    ensureSelectedBackendIsConfigured(backend, backendConfigs);
+    const backendModel = backendConfigs[backend]?.model;
     return {
-        backend: options.backend ?? fileConfig.backend ?? DEFAULTS.backend,
-        model: options.model ?? fileConfig.model ?? DEFAULTS.model,
+        backend,
+        model: options.model ?? backendModel ?? DEFAULTS.model,
         timeoutMs: typeof fileConfig.budgets?.timeout_ms === "number"
             ? fileConfig.budgets.timeout_ms
             : DEFAULTS.timeoutMs,
@@ -103,6 +113,6 @@ function loadEffectiveConfig(options) {
             ? fileConfig.rules?.disable.filter((item) => typeof item === "string")
             : DEFAULTS.rulesDisable,
         severityOverrides: sanitizeSeverityOverrides((fileConfig.rules?.severity_overrides ?? undefined)),
-        backendExecutables: sanitizeBackendExecutables((fileConfig.backends ?? undefined))
+        backendConfigs
     };
 }

package/dist/diagnostics.js

@@ -8,23 +8,19 @@ 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;
-}
+const utils_1 = require("./utils");
 /**
  * @param resolveRoot - Directory to resolve diagnostic file paths against (e.g. git repo root).
  *   Git diff paths are repo-relative; resolving from repo root ensures paths exist when running from subdirs.
  */
 function normalizeDiagnostics(ruleId, diagnostics, debug, resolveRoot) {
-    const out = [];
     const baseDir = resolveRoot && resolveRoot.length > 0 ? resolveRoot : process.cwd();
-    for (const raw of diagnostics) {
+    return diagnostics.flatMap((raw) => {
         if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
             if (debug) {
                 process.stderr.write(`[debug] Dropped diagnostic for ${ruleId}: not an object\n`);
             }
-            continue;
+            return [];
         }
         const candidate = raw;
         const severity = candidate.severity;
@@ -39,34 +35,34 @@ function normalizeDiagnostics(ruleId, diagnostics, debug, resolveRoot) {
             typeof message !== "string" ||
             message.trim() === "" ||
             typeof severity !== "string" ||
-            !VALID_SEVERITIES.has(severity) ||
-            !isPositiveInteger(line)) {
+            !utils_1.VALID_SEVERITIES.has(severity) ||
+            !(0, utils_1.isPositiveInteger)(line)) {
             if (debug) {
                 process.stderr.write(`[debug] Dropped diagnostic for ${ruleId}: failed required field validation\n`);
             }
-            continue;
+            return [];
         }
-        const absolute = node_path_1.default.resolve(baseDir, file);
-        if (!node_fs_1.default.existsSync(absolute)) {
+        if (!node_fs_1.default.existsSync(node_path_1.default.resolve(baseDir, file))) {
             if (debug) {
                 process.stderr.write(`[debug] Dropped diagnostic for ${ruleId}: file does not exist (${file})\n`);
             }
-            continue;
+            return [];
         }
-        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;
+        return [
+            {
+                rule_id: candidateRuleId,
+                severity: severity,
+                message,
+                file,
+                line,
+                column: (0, utils_1.isPositiveInteger)(candidate.column) ? candidate.column : undefined,
+                end_line: (0, utils_1.isPositiveInteger)(candidate.end_line) ? candidate.end_line : undefined,
+                end_column: (0, utils_1.isPositiveInteger)(candidate.end_column) ? candidate.end_column : undefined,
+                evidence: typeof candidate.evidence === "string" ? candidate.evidence : undefined,
+                confidence: typeof candidate.confidence === "number" ? candidate.confidence : undefined
+            }
+        ];
+    });
 }
 const SEVERITY_ORDER = {
     error: 3,

package/dist/dispatch.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBatchDispatch = runBatchDispatch;
+exports.runParallelDispatch = runParallelDispatch;
+const diagnostics_1 = require("./diagnostics");
+const filter_1 = require("./filter");
+const prompts_1 = require("./prompts");
+const utils_1 = require("./utils");
+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 (0, prompts_1.renderBatchPrompt)({ ruleBlocks, diff });
+}
+async function runBatchDispatch(input) {
+    const { rules, diff, changedFiles, backend, config, repoRoot } = input;
+    const diagnostics = [];
+    let backendErrors = 0;
+    (0, utils_1.debugLog)(config.debug, `Running ${rules.length} rule(s) in batch mode`);
+    const combinedDiff = rules
+        .map((rule) => (0, filter_1.buildScopedDiff)(rule, diff, changedFiles))
+        .filter((chunk) => chunk.trim() !== "")
+        .join("\n");
+    const batchPrompt = buildBatchPrompt(rules, combinedDiff || diff);
+    try {
+        const batchResult = await backend.runPrompt({
+            label: "Batch",
+            prompt: batchPrompt,
+            timeoutMs: config.timeoutMs
+        });
+        const groupedByRule = batchResult.diagnostics.reduce((acc, diagnostic) => {
+            if (typeof diagnostic === "object" &&
+                diagnostic !== null &&
+                !Array.isArray(diagnostic) &&
+                typeof diagnostic.rule_id === "string") {
+                const ruleId = diagnostic.rule_id;
+                acc.set(ruleId, [...(acc.get(ruleId) ?? []), diagnostic]);
+                return acc;
+            }
+            (0, utils_1.debugLog)(config.debug, "Batch: dropped diagnostic without valid rule_id");
+            return acc;
+        }, new Map());
+        const validRuleIds = new Set(rules.map((rule) => rule.id));
+        Array.from(groupedByRule.keys())
+            .filter((ruleId) => !validRuleIds.has(ruleId))
+            .forEach((ruleId) => {
+            (0, utils_1.debugLog)(config.debug, `Batch: dropped diagnostic for unknown rule_id ${ruleId}`);
+        });
+        const normalized = rules.flatMap((rule) => (0, diagnostics_1.normalizeDiagnostics)(rule.id, groupedByRule.get(rule.id) ?? [], config.debug, repoRoot));
+        diagnostics.push(...normalized);
+    }
+    catch (error) {
+        backendErrors += 1;
+        const message = error instanceof Error ? error.message : String(error);
+        (0, utils_1.debugLog)(config.debug, `Batch backend error: ${message}`);
+    }
+    return { diagnostics, backendErrors };
+}
+async function runParallelDispatch(input) {
+    const { rules, diff, changedFiles, backend, config, repoRoot } = input;
+    (0, utils_1.debugLog)(config.debug, `Running ${rules.length} rule(s) in parallel`);
+    const runResults = await Promise.all(rules.map(async (rule) => {
+        const ruleStartedAt = Date.now();
+        (0, utils_1.debugLog)(config.debug, `Rule ${rule.id}: started`);
+        const scopedDiff = (0, filter_1.buildScopedDiff)(rule, diff, changedFiles);
+        const prompt = (0, filter_1.buildRulePrompt)(rule, scopedDiff);
+        try {
+            const result = await backend.runRule({
+                ruleId: rule.id,
+                prompt,
+                timeoutMs: config.timeoutMs
+            });
+            const normalized = (0, diagnostics_1.normalizeDiagnostics)(rule.id, result.diagnostics, config.debug, repoRoot);
+            (0, utils_1.debugLog)(config.debug, `Rule ${rule.id}: finished in ${Date.now() - ruleStartedAt}ms`);
+            return { backendError: false, normalized };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            (0, utils_1.debugLog)(config.debug, `Backend error for rule ${rule.id}: ${message}`);
+            (0, utils_1.debugLog)(config.debug, `Rule ${rule.id}: finished in ${Date.now() - ruleStartedAt}ms`);
+            return { backendError: true, normalized: [] };
+        }
+    }));
+    return {
+        diagnostics: runResults.flatMap((result) => result.normalized),
+        backendErrors: runResults.filter((result) => result.backendError).length
+    };
+}

package/dist/filter.js

@@ -9,6 +9,7 @@ exports.shouldRunRule = shouldRunRule;
 exports.buildScopedDiff = buildScopedDiff;
 exports.buildRulePrompt = buildRulePrompt;
 const picomatch_1 = __importDefault(require("picomatch"));
+const prompts_1 = require("./prompts");
 function unquoteDiffPath(raw) {
     if (raw.startsWith("\"") && raw.endsWith("\"") && raw.length >= 2) {
         return raw.slice(1, -1).replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
@@ -48,9 +49,6 @@ function extractChangedFilesFromDiff(diff) {
     }
     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 {
@@ -67,14 +65,16 @@ function matchesAnyRegex(diff, regexes) {
 }
 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));
+    const includeMatcher = rule.include_globs && rule.include_globs.length > 0 ? (0, picomatch_1.default)(rule.include_globs) : null;
+    const excludeMatcher = rule.exclude_globs && rule.exclude_globs.length > 0 ? (0, picomatch_1.default)(rule.exclude_globs) : null;
+    if (includeMatcher) {
+        fileCandidates = changedFiles.filter((filePath) => includeMatcher(filePath));
         if (fileCandidates.length === 0) {
             return [];
         }
     }
-    if (rule.exclude_globs && rule.exclude_globs.length > 0) {
-        fileCandidates = fileCandidates.filter((filePath) => !matchesAnyGlob(filePath, rule.exclude_globs));
+    if (excludeMatcher) {
+        fileCandidates = fileCandidates.filter((filePath) => !excludeMatcher(filePath));
     }
     return fileCandidates;
 }
@@ -130,41 +130,11 @@ function buildScopedDiff(rule, fullDiff, changedFiles) {
     return scoped.trim() === "" ? fullDiff : scoped;
 }
 function buildRulePrompt(rule, diff) {
-    return [
-        "You are Semlint, an expert semantic code reviewer.",
-        "Analyze ONLY the modified code present in the DIFF below.",
-        "Return JSON only (no markdown, no prose, no code fences).",
-        "Output schema:",
-        "{",
-        "  \"diagnostics\": [",
-        "    {",
-        "      \"rule_id\": string,",
-        "      \"severity\": \"error\" | \"warn\" | \"info\",",
-        "      \"message\": string,",
-        "      \"file\": string,",
-        "      \"line\": number,",
-        "      \"column\"?: number,",
-        "      \"end_line\"?: number,",
-        "      \"end_column\"?: number,",
-        "      \"evidence\"?: string,",
-        "      \"confidence\"?: number",
-        "    }",
-        "  ]",
-        "}",
-        "Rules:",
-        "- If there are no findings, return {\"diagnostics\":[]}.",
-        "- Each diagnostic must reference a changed file from the DIFF.",
-        "- Use the provided RULE_ID exactly in every diagnostic.",
-        "- Keep messages concise and actionable.",
-        "",
-        `RULE_ID: ${rule.id}`,
-        `RULE_TITLE: ${rule.title}`,
-        `SEVERITY_DEFAULT: ${rule.effectiveSeverity}`,
-        "",
-        "INSTRUCTIONS:",
-        rule.prompt,
-        "",
-        "DIFF:",
+    return (0, prompts_1.renderRulePrompt)({
+        ruleId: rule.id,
+        ruleTitle: rule.title,
+        severityDefault: rule.effectiveSeverity,
+        instructions: rule.prompt,
         diff
-    ].join("\n");
+    });
 }

package/dist/init.js

@@ -8,6 +8,23 @@ const picocolors_1 = __importDefault(require("picocolors"));
 const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const node_child_process_1 = require("node:child_process");
+const SCAFFOLD_BACKENDS = {
+    "cursor-cli": {
+        executable: "cursor",
+        args: ["agent", "{prompt}", "--model", "{model}", "--print", "--mode", "ask", "--output-format", "text"],
+        model: "auto"
+    },
+    "claude-code": {
+        executable: "claude",
+        args: ["{prompt}", "--model", "{model}", "--output-format", "json"],
+        model: "auto"
+    },
+    "codex-cli": {
+        executable: "codex",
+        args: ["{prompt}", "--model", "{model}"],
+        model: "auto"
+    }
+};
 function commandExists(command) {
     const result = (0, node_child_process_1.spawnSync)(command, ["--version"], {
         stdio: "ignore"
@@ -34,12 +51,21 @@ function detectBackend() {
     ];
     for (const candidate of candidates) {
         if (commandExists(candidate.executable)) {
-            return candidate;
+            const scaffold = SCAFFOLD_BACKENDS[candidate.backend];
+            return {
+                backend: candidate.backend,
+                executable: scaffold.executable,
+                args: scaffold.args,
+                model: scaffold.model,
+                reason: candidate.reason
+            };
         }
     }
     return {
         backend: "cursor-cli",
-        executable: "cursor",
+        executable: SCAFFOLD_BACKENDS["cursor-cli"].executable,
+        args: SCAFFOLD_BACKENDS["cursor-cli"].args,
+        model: SCAFFOLD_BACKENDS["cursor-cli"].model,
         reason: "no known agent CLI detected, using default Cursor setup"
     };
 }
@@ -52,7 +78,6 @@ function scaffoldConfig(force = false) {
     const detected = detectBackend();
     const scaffold = {
         backend: detected.backend,
-        model: "auto",
         budgets: {
             timeout_ms: 120000
         },
@@ -68,7 +93,9 @@ function scaffoldConfig(force = false) {
         },
         backends: {
             [detected.backend]: {
-                executable: detected.executable
+                executable: detected.executable,
+                args: detected.args,
+                model: detected.model
             }
         }
     };

package/dist/main.js

@@ -7,79 +7,28 @@ exports.runSemlint = runSemlint;
 const picocolors_1 = __importDefault(require("picocolors"));
 const nanospinner_1 = require("nanospinner");
 const node_path_1 = __importDefault(require("node:path"));
+const package_json_1 = require("../package.json");
 const backend_1 = require("./backend");
 const config_1 = require("./config");
 const diagnostics_1 = require("./diagnostics");
+const dispatch_1 = require("./dispatch");
 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(`${picocolors_1.default.gray(`[debug] ${message}`)}\n`);
-    }
-}
+const utils_1 = require("./utils");
 function timed(enabled, label, action) {
     const startedAt = Date.now();
     const result = action();
-    debugLog(enabled, `${label} in ${Date.now() - startedAt}ms`);
+    (0, utils_1.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`);
+    (0, utils_1.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 [
-        "You are Semlint, an expert semantic code reviewer.",
-        "BATCH_MODE: true",
-        "Evaluate all rules below against the DIFF in one pass.",
-        "Analyze ONLY the modified code present in the DIFF below.",
-        "Return JSON only (no markdown, no prose, no code fences).",
-        "Output schema:",
-        "{",
-        "  \"diagnostics\": [",
-        "    {",
-        "      \"rule_id\": string,",
-        "      \"severity\": \"error\" | \"warn\" | \"info\",",
-        "      \"message\": string,",
-        "      \"file\": string,",
-        "      \"line\": number,",
-        "      \"column\"?: number,",
-        "      \"end_line\"?: number,",
-        "      \"end_column\"?: number,",
-        "      \"evidence\"?: string,",
-        "      \"confidence\"?: number",
-        "    }",
-        "  ]",
-        "}",
-        "Rules:",
-        "- If there are no findings, return {\"diagnostics\":[]}.",
-        "- Each diagnostic must reference a changed file from the DIFF.",
-        "- rule_id must match one of the RULE_ID values listed below.",
-        "- Keep messages concise and actionable.",
-        "- Deduplicate semantically equivalent findings before returning output.",
-        "- When duplicates exist, keep a single diagnostic from the rule that semantically matches the issue best, even if that selected diagnostic has lower severity.",
-        "",
-        "RULES:",
-        ruleBlocks,
-        "",
-        "DIFF:",
-        diff
-    ].join("\n");
-}
 async function runSemlint(options) {
     const startedAt = Date.now();
     let spinner = null;
@@ -87,28 +36,28 @@ async function runSemlint(options) {
         const config = timed(options.debug, "Loaded effective config", () => (0, config_1.loadEffectiveConfig)(options));
         const rulesDir = node_path_1.default.join(process.cwd(), ".semlint", "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(", ")}`);
+        (0, utils_1.debugLog)(config.debug, `Loaded ${rules.length} rule(s)`);
+        (0, utils_1.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
+        (0, utils_1.debugLog)(config.debug, useLocalBranchDiff
             ? "Using local branch diff (staged + unstaged + untracked only)"
             : `Using explicit ref diff (${config.base}..${config.head})`);
-        debugLog(config.debug, `Detected ${changedFiles.length} changed file(s)`);
+        (0, utils_1.debugLog)(config.debug, `Detected ${changedFiles.length} changed file(s)`);
         const repoRoot = await timedAsync(config.debug, "Resolved git repo root", () => (0, git_1.getRepoRoot)());
         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`);
+            (0, utils_1.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`);
+                (0, utils_1.debugLog)(config.debug, `Skipping rule ${rule.id}: filters did not match`);
                 return false;
             }
             return true;
         });
-        const diagnostics = [];
+        let diagnostics = [];
         const rulesRun = runnableRules.length;
         let backendErrors = 0;
         if (config.format !== "json" && rulesRun > 0) {
@@ -122,82 +71,27 @@ async function runSemlint(options) {
             config.format !== "json" && rulesRun > 0
                 ? (0, nanospinner_1.createSpinner)(`Analyzing ${changedFiles.length} file${changedFiles.length === 1 ? "" : "s"} with ${config.backend} in ${config.batchMode ? "batch" : "parallel"} mode...`).start()
                 : null;
-        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
+        if (runnableRules.length > 0) {
+            const dispatchLabel = config.batchMode ? "batch" : "parallel";
+            const result = await timedAsync(config.debug, `Dispatch (${dispatchLabel})`, () => config.batchMode
+                ? (0, dispatch_1.runBatchDispatch)({
+                    rules: runnableRules,
+                    diff,
+                    changedFiles,
+                    backend,
+                    config,
+                    repoRoot
+                })
+                : (0, dispatch_1.runParallelDispatch)({
+                    rules: runnableRules,
+                    diff,
+                    changedFiles,
+                    backend,
+                    config,
+                    repoRoot
                 }));
-                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, repoRoot));
-                    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, repoRoot));
-                }
-                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);
-            }
+            diagnostics = result.diagnostics;
+            backendErrors = result.backendErrors;
         }
         const sorted = timed(config.debug, "Sorted diagnostics", () => (0, diagnostics_1.sortDiagnostics)(diagnostics));
         const durationMs = Date.now() - startedAt;
@@ -211,13 +105,13 @@ async function runSemlint(options) {
         }
         const outputStartedAt = Date.now();
         if (config.format === "json") {
-            process.stdout.write(`${(0, reporter_1.formatJsonOutput)(VERSION, sorted, { rulesRun, durationMs, backendErrors })}\n`);
+            process.stdout.write(`${(0, reporter_1.formatJsonOutput)(package_json_1.version, sorted, { rulesRun, durationMs, backendErrors })}\n`);
         }
         else {
             process.stdout.write(`${(0, reporter_1.formatTextOutput)(sorted, { rulesRun, durationMs, backendErrors })}\n`);
         }
-        debugLog(config.debug, `Rendered output in ${Date.now() - outputStartedAt}ms`);
-        debugLog(config.debug, `Total run duration ${durationMs}ms`);
+        (0, utils_1.debugLog)(config.debug, `Rendered output in ${Date.now() - outputStartedAt}ms`);
+        (0, utils_1.debugLog)(config.debug, `Total run duration ${durationMs}ms`);
         if (backendErrors > 0) {
             return 2;
         }

package/dist/prompts.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStrictJsonRetryInstruction = getStrictJsonRetryInstruction;
+exports.renderRulePrompt = renderRulePrompt;
+exports.renderBatchPrompt = renderBatchPrompt;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const promptCache = new Map();
+function readPromptFile(fileName) {
+    const cached = promptCache.get(fileName);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const promptPath = node_path_1.default.resolve(__dirname, "..", "prompts", fileName);
+    const content = node_fs_1.default.readFileSync(promptPath, "utf8").trim();
+    promptCache.set(fileName, content);
+    return content;
+}
+function renderTemplate(template, values) {
+    return Object.entries(values).reduce((current, [key, value]) => current.replace(new RegExp(`\\{\\{${key}\\}\\}`, "g"), value), template);
+}
+function getStrictJsonRetryInstruction() {
+    return readPromptFile("retry-json.md").replace(/\s+/g, " ").trim();
+}
+function renderRulePrompt(values) {
+    const commonContract = readPromptFile("common-contract.md");
+    return renderTemplate(readPromptFile("rule.md"), {
+        COMMON_CONTRACT: commonContract,
+        RULE_ID: values.ruleId,
+        RULE_TITLE: values.ruleTitle,
+        SEVERITY_DEFAULT: values.severityDefault,
+        INSTRUCTIONS: values.instructions,
+        DIFF: values.diff
+    });
+}
+function renderBatchPrompt(values) {
+    const commonContract = readPromptFile("common-contract.md");
+    return renderTemplate(readPromptFile("batch.md"), {
+        COMMON_CONTRACT: commonContract,
+        RULE_BLOCKS: values.ruleBlocks,
+        DIFF: values.diff
+    });
+}

package/dist/reporter.js

@@ -31,19 +31,18 @@ function formatJsonOutput(version, diagnostics, stats) {
     return JSON.stringify(payload, null, 2);
 }
 function formatTextOutput(diagnostics, stats) {
-    const lines = [];
-    let currentFile = "";
-    for (const diagnostic of diagnostics) {
-        if (diagnostic.file !== currentFile) {
-            if (lines.length > 0) {
-                lines.push("");
-            }
-            currentFile = diagnostic.file;
-            lines.push(picocolors_1.default.underline(currentFile));
-        }
-        const column = diagnostic.column ?? 1;
-        lines.push(`  ${picocolors_1.default.dim(`${diagnostic.line}:${column}`)}  ${formatSeverity(diagnostic.severity)}  ${picocolors_1.default.gray(diagnostic.rule_id)}  ${diagnostic.message}`);
-    }
+    const groupedByFile = diagnostics.reduce((acc, diagnostic) => {
+        acc.set(diagnostic.file, [...(acc.get(diagnostic.file) ?? []), diagnostic]);
+        return acc;
+    }, new Map());
+    const lines = Array.from(groupedByFile.entries()).flatMap(([file, fileDiagnostics], fileIndex) => [
+        ...(fileIndex > 0 ? [""] : []),
+        picocolors_1.default.underline(file),
+        ...fileDiagnostics.map((diagnostic) => {
+            const column = diagnostic.column ?? 1;
+            return `  ${picocolors_1.default.dim(`${diagnostic.line}:${column}`)}  ${formatSeverity(diagnostic.severity)}  ${picocolors_1.default.gray(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;

package/dist/rules.js

@@ -6,7 +6,7 @@ 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"]);
+const utils_1 = require("./utils");
 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`);
@@ -28,7 +28,7 @@ function validateRuleObject(raw, filePath) {
     }
     const obj = raw;
     const severity = assertNonEmptyString(obj.severity_default, "severity_default", filePath);
-    if (!VALID_SEVERITIES.has(severity)) {
+    if (!utils_1.VALID_SEVERITIES.has(severity)) {
         throw new Error(`Invalid rule in ${filePath}: "severity_default" must be one of error|warn|info`);
     }
     return {
@@ -52,10 +52,10 @@ function loadRules(rulesDir, disabledRuleIds, severityOverrides) {
         .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 seenIds = new Set();
+    return entries
+        .map((fileName) => {
         const filePath = node_path_1.default.join(rulesDir, fileName);
         let parsed;
         try {
@@ -70,19 +70,17 @@ function loadRules(rulesDir, disabledRuleIds, severityOverrides) {
             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)) {
+        if (!utils_1.VALID_SEVERITIES.has(effectiveSeverity)) {
             throw new Error(`Invalid severity override for rule ${validated.id}`);
         }
-        loaded.push({
+        return {
             ...validated,
             sourcePath: filePath,
             effectiveSeverity
-        });
-    }
-    return loaded.sort((a, b) => a.id.localeCompare(b.id));
+        };
+    })
+        .filter((rule) => !disabled.has(rule.id))
+        .sort((a, b) => a.id.localeCompare(b.id));
 }

package/dist/utils.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VALID_SEVERITIES = void 0;
+exports.isPositiveInteger = isPositiveInteger;
+exports.debugLog = debugLog;
+const picocolors_1 = __importDefault(require("picocolors"));
+exports.VALID_SEVERITIES = new Set(["error", "warn", "info"]);
+function isPositiveInteger(value) {
+    return typeof value === "number" && Number.isInteger(value) && value >= 1;
+}
+function debugLog(enabled, message) {
+    if (enabled) {
+        process.stderr.write(`${picocolors_1.default.gray(`[debug] ${message}`)}\n`);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semlint-cli",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Semantic lint CLI — runs LLM-backed rules on your git diff and returns CI-friendly exit codes",
   "type": "commonjs",
   "main": "dist/main.js",
@@ -9,6 +9,7 @@
   },
   "files": [
     "dist",
+    "prompts",
     "rules",
     "README.md"
   ],

package/prompts/batch.md

@@ -0,0 +1,16 @@
+You are Semlint, an expert semantic code reviewer.
+BATCH_MODE: true
+Evaluate all rules below against the DIFF in one pass.
+Start from the modified/added code in the DIFF. You may inspect adjacent files/functions referenced by the changed code when necessary to verify patterns or behavior, but keep findings anchored to changed files and lines.
+Return JSON only (no markdown, no prose, no code fences).
+{{COMMON_CONTRACT}}
+- rule_id must match one of the RULE_ID values listed below.
+- Keep messages concise and actionable.
+- Deduplicate semantically equivalent findings before returning output.
+- When duplicates exist, keep a single diagnostic from the rule that semantically matches the issue best, even if that selected diagnostic has lower severity.
+
+RULES:
+{{RULE_BLOCKS}}
+
+DIFF:
+{{DIFF}}

package/prompts/common-contract.md

@@ -0,0 +1,20 @@
+Output schema:
+{
+  "diagnostics": [
+    {
+      "rule_id": string,
+      "severity": "error" | "warn" | "info",
+      "message": string,
+      "file": string,
+      "line": number,
+      "column"?: number,
+      "end_line"?: number,
+      "end_column"?: number,
+      "evidence"?: string,
+      "confidence"?: number
+    }
+  ]
+}
+Rules:
+- If there are no findings, return {"diagnostics":[]}.
+- Each diagnostic must reference a changed file from the DIFF.

package/prompts/retry-json.md

@@ -0,0 +1,5 @@
+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}]}

package/prompts/rule.md

@@ -0,0 +1,16 @@
+You are Semlint, an expert semantic code reviewer.
+Analyze ONLY the modified code present in the DIFF below.
+Return JSON only (no markdown, no prose, no code fences).
+{{COMMON_CONTRACT}}
+- Use the provided RULE_ID exactly in every diagnostic.
+- Keep messages concise and actionable.
+
+RULE_ID: {{RULE_ID}}
+RULE_TITLE: {{RULE_TITLE}}
+SEVERITY_DEFAULT: {{SEVERITY_DEFAULT}}
+
+INSTRUCTIONS:
+{{INSTRUCTIONS}}
+
+DIFF:
+{{DIFF}}