semlint-cli 0.1.5 → 0.1.7

package/dist/diff.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDiffGitHeader = parseDiffGitHeader;
+exports.splitDiffIntoFileChunks = splitDiffIntoFileChunks;
+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 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;
+}

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

@@ -8,28 +8,9 @@ exports.getRuleCandidateFiles = getRuleCandidateFiles;
 exports.shouldRunRule = shouldRunRule;
 exports.buildScopedDiff = buildScopedDiff;
 exports.buildRulePrompt = buildRulePrompt;
+const diff_1 = require("./diff");
 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)
-    };
-}
+const prompts_1 = require("./prompts");
 function extractChangedFilesFromDiff(diff) {
     const files = new Set();
     const lines = diff.split("\n");
@@ -37,7 +18,7 @@ function extractChangedFilesFromDiff(diff) {
         if (!line.startsWith("diff --git ")) {
             continue;
         }
-        const parsed = parseDiffGitHeader(line);
+        const parsed = (0, diff_1.parseDiffGitHeader)(line);
         if (!parsed) {
             continue;
         }
@@ -48,9 +29,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 +45,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;
 }
@@ -88,41 +68,12 @@ function shouldRunRule(rule, changedFiles, diff) {
     }
     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 chunks = (0, diff_1.splitDiffIntoFileChunks)(fullDiff);
     const scoped = chunks
         .filter((chunk) => chunk.file !== "" && candidateFiles.has(chunk.file))
         .map((chunk) => chunk.chunk)
@@ -130,41 +81,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
         },
@@ -62,13 +87,21 @@ function scaffoldConfig(force = false) {
         execution: {
             batch: false
         },
+        security: {
+            secret_guard: true,
+            allow_patterns: [],
+            ignore_files: [".gitignore", ".cursorignore", ".semlintignore"],
+            allow_files: []
+        },
         rules: {
             disable: [],
             severity_overrides: {}
         },
         backends: {
             [detected.backend]: {
-                executable: detected.executable
+                executable: detected.executable,
+                args: detected.args,
+                model: detected.model
             }
         }
     };
@@ -80,16 +113,23 @@ function scaffoldConfig(force = false) {
         node_fs_1.default.mkdirSync(rulesDir, { recursive: true });
         process.stdout.write(picocolors_1.default.green(`Created ${node_path_1.default.join(".semlint", "rules")}/\n`));
     }
-    const exampleRulePath = node_path_1.default.join(rulesDir, "SEMLINT_EXAMPLE_001.json");
-    if (!node_fs_1.default.existsSync(exampleRulePath)) {
-        const exampleRule = {
-            id: "SEMLINT_EXAMPLE_001",
-            title: "My first rule",
-            severity_default: "warn",
-            prompt: "Describe what the agent should check in the changed code. Example: flag when new functions lack JSDoc, or when error handling is missing."
-        };
-        node_fs_1.default.writeFileSync(exampleRulePath, `${JSON.stringify(exampleRule, null, 2)}\n`, "utf8");
-        process.stdout.write(picocolors_1.default.green(`Created ${node_path_1.default.join(".semlint", "rules", "SEMLINT_EXAMPLE_001.json")} `) + picocolors_1.default.dim(`(edit the title and prompt to define your rule)\n`));
+    const bundledRulesDir = node_path_1.default.resolve(__dirname, "..", ".semlint", "rules");
+    if (!node_fs_1.default.existsSync(bundledRulesDir) || !node_fs_1.default.statSync(bundledRulesDir).isDirectory()) {
+        process.stderr.write(picocolors_1.default.yellow(`No bundled rules found at ${bundledRulesDir}. Add rule files manually under ${node_path_1.default.join(".semlint", "rules")}.\n`));
+        return 0;
+    }
+    const bundledRules = node_fs_1.default
+        .readdirSync(bundledRulesDir)
+        .filter((name) => name.endsWith(".json"))
+        .sort((a, b) => a.localeCompare(b));
+    for (const fileName of bundledRules) {
+        const source = node_path_1.default.join(bundledRulesDir, fileName);
+        const target = node_path_1.default.join(rulesDir, fileName);
+        if (!force && node_fs_1.default.existsSync(target)) {
+            continue;
+        }
+        node_fs_1.default.copyFileSync(source, target);
+        process.stdout.write(picocolors_1.default.green(`Copied ${node_path_1.default.join(".semlint", "rules", fileName)}\n`));
     }
     return 0;
 }