calllint 0.4.0 → 0.5.0

package/dist/index.js

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { readFileSync as readFileSync5 } from "node:fs";
+import { readFileSync as readFileSync6 } from "node:fs";
+import { execFileSync } from "node:child_process";
 
 // src/args.ts
 var EXIT = {
@@ -71,10 +72,12 @@ TARGETS
   github:<owner/repo>[@ref]   A GitHub repo (requires --online)
 
 SCAN OPTIONS
+  --changed          Scan only the agent-tool configs changed in the git diff
   --json             Emit the ScanReport JSON (stable, emoji-free)
   --compact          One line per server
   --no-emoji         Plain-text symbols (good for CI logs)
   --sarif            Emit SARIF 2.1.0 (GitHub Code Scanning / CI)
+  --markdown         Emit Markdown for PR comments / GitHub Step Summary
   --html             Emit a self-contained HTML report
   --policy <file>    Use a policy file (default: built-in defaults)
   --stdin            Read config JSON from stdin
@@ -88,6 +91,7 @@ VERIFY OPTIONS
 
 EXAMPLES
   calllint scan .cursor/mcp.json
+  calllint scan --changed --markdown
   cat .cursor/mcp.json | calllint scan --stdin --json
   calllint scan ./mcp.json --ci --no-emoji
   calllint diagnostics ./mcp.json --json
@@ -102,7 +106,7 @@ function helpCommand() {
 }
 
 // src/commands/scan.ts
-import { join as join4, resolve } from "node:path";
+import { join as join4, resolve as resolve2 } from "node:path";
 
 // ../../packages/policy/src/defaultPolicy.ts
 function defaultPolicy() {
@@ -168,6 +172,12 @@ function validateOverride(o, index, issues) {
       message: "must be a valid ISO timestamp (overrides must expire)"
     });
   }
+  if (o.owner !== void 0 && (typeof o.owner !== "string" || !o.owner.trim())) {
+    issues.push({
+      path: `${base}.owner`,
+      message: "must be a non-empty string when present"
+    });
+  }
   const allow = Array.isArray(o.allow) ? o.allow : [];
   const allowsDangerous = allow.some(
     (s) => typeof s === "string" && DANGEROUS_SYMBOLS.has(s)
@@ -255,7 +265,7 @@ function applyPolicy(rawVerdict, serverName, blockingFindings, policy, now) {
   return {
     verdict: "REVIEW",
     changed: true,
-    note: `Policy decision: override for "${serverName}" (expires ${override.expiresAt}) \u2014 ${override.reason}`
+    note: `Policy decision: override for "${serverName}" (expires ${override.expiresAt}${override.owner ? `, owner: ${override.owner}` : ""}) \u2014 ${override.reason}`
   };
 }
 function shouldFailCi(verdict, policy) {
@@ -2304,6 +2314,92 @@ function renderSarif(summary) {
   return JSON.stringify(sarif, null, 2);
 }
 
+// ../../packages/report-renderer/src/renderMarkdown.ts
+function renderMarkdown(summary) {
+  const out = [];
+  const c = summary.counts;
+  out.push(`## CallLint: ${summary.verdict} \u2014 ${summary.publicVerdictLabel}`);
+  out.push("");
+  out.push(
+    `CallLint statically checked \`${summary.configPath}\` before the agent tool runs. It never executes, installs, or connects to the server it judges.`
+  );
+  out.push("");
+  out.push("| Server | Verdict | Risk class | Findings |");
+  out.push("| --- | --- | --- | --- |");
+  for (const r of summary.reports) {
+    out.push(
+      `| ${mdCell(r.target.name)} | ${r.verdict} | ${r.riskClass} | ${r.findings.length} |`
+    );
+  }
+  out.push(
+    `| **TOTAL** | **${summary.verdict}** | \u2014 | BLOCK ${c.BLOCK} \xB7 UNKNOWN ${c.UNKNOWN} \xB7 REVIEW ${c.REVIEW} \xB7 SAFE ${c.SAFE} |`
+  );
+  out.push("");
+  for (const r of summary.reports) {
+    renderServer2(out, r);
+  }
+  out.push("---");
+  out.push("");
+  out.push(
+    "> CallLint does not prove runtime safety. `SAFE` means no blockers observed under current evidence; `UNKNOWN` is never `SAFE`. Verdicts are heuristic decision support, not a safety guarantee."
+  );
+  return out.join("\n");
+}
+function renderServer2(out, r) {
+  out.push(`### ${r.target.name} \u2014 ${r.verdict}`);
+  out.push("");
+  if (r.summary) {
+    out.push(r.summary);
+    out.push("");
+  }
+  if (r.findings.length === 0) {
+    out.push("_No findings._");
+    out.push("");
+  } else {
+    for (const f of r.findings) {
+      renderFinding(out, f);
+    }
+  }
+  renderRecommendation(out, r.policy);
+  out.push("");
+}
+function renderFinding(out, f) {
+  const tag = f.blocker ? "BLOCKER" : f.severity.toUpperCase();
+  out.push(`#### ${tag}: ${f.title}`);
+  out.push("");
+  out.push(`- Risk: ${f.symbol} \xB7 ${f.riskClass} \xB7 ${f.mode} \xB7 confidence ${f.confidence}`);
+  const ev = f.evidence[0];
+  if (ev) {
+    const loc = ev.path ? ` \`${ev.path}\`${ev.line ? `:${ev.line}` : ""}` : "";
+    const shown = ev.snippet ?? ev.value ?? ev.key;
+    out.push(`- Evidence:${loc}`);
+    if (shown) {
+      out.push("");
+      out.push("  ```text");
+      for (const line of String(shown).split("\n")) out.push(`  ${line}`);
+      out.push("  ```");
+    }
+  }
+  out.push("");
+  out.push(`Why it matters: ${f.impact}`);
+  out.push("");
+  out.push(`Recommended fix: ${f.fix}`);
+  if (f.falsePositiveNote) {
+    out.push("");
+    out.push(`Note: ${f.falsePositiveNote}`);
+  }
+  out.push("");
+}
+function renderRecommendation(out, p) {
+  out.push("Policy recommendation:");
+  out.push(`- Autonomous use: ${p.autonomousUse}`);
+  out.push(`- Manual approval: ${p.manualApproval}`);
+  out.push(`- Sandbox: ${p.sandbox}`);
+}
+function mdCell(s) {
+  return s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+}
+
 // ../../packages/report-renderer/src/renderDiagnostics.ts
 function verdictContributionFor(f) {
   if (f.blocker) return "blocker";
@@ -2552,8 +2648,25 @@ function resolveConfigInput(args, deps) {
   return { text: readFileSync3(resolved, "utf8"), configPath: resolved };
 }
 
+// src/commands/changedConfigs.ts
+import { basename as basename2, resolve } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+function changedConfigPaths(cwd, diff) {
+  let raw;
+  try {
+    raw = diff();
+  } catch {
+    return [];
+  }
+  const knownLeaves = new Set(DEFAULT_CONFIG_PATHS.map((p) => basename2(p)));
+  const knownPaths = new Set(DEFAULT_CONFIG_PATHS);
+  return raw.split("\n").map((l) => l.trim()).filter(
+    (f) => f.length > 0 && (knownPaths.has(f) || DEFAULT_CONFIG_PATHS.some((p) => f.endsWith("/" + p)) || knownLeaves.has(basename2(f)))
+  ).map((f) => resolve(cwd, f)).filter((abs) => existsSync3(abs));
+}
+
 // src/commands/surfaces.ts
-import { existsSync as existsSync3, readFileSync as readFileSync4, statSync } from "node:fs";
+import { existsSync as existsSync4, readFileSync as readFileSync4, statSync } from "node:fs";
 import { join as join3 } from "node:path";
 var SURFACE_SIZE_CAP = 256 * 1024;
 var SURFACE_FILES = [
@@ -2576,7 +2689,7 @@ function readCapped(path) {
 }
 function readDocumentSurfaces(dir) {
   const surfaces = [];
-  if (!existsSync3(dir)) return surfaces;
+  if (!existsSync4(dir)) return surfaces;
   for (const { file, kind } of SURFACE_FILES) {
     const got = readCapped(join3(dir, file));
     if (got) surfaces.push({ path: file, kind, text: got.text, truncated: got.truncated });
@@ -2602,7 +2715,11 @@ function readDocumentSurfaces(dir) {
 }
 
 // src/commands/scan.ts
+import { readFileSync as readFileSync5 } from "node:fs";
 function scanCommand(args, deps) {
+  if (flagBool(args.flags, "changed")) {
+    return scanChangedCommand(args, deps);
+  }
   const policyPath = flagStr(args.flags, "policy");
   let policy;
   try {
@@ -2619,8 +2736,11 @@ function scanCommand(args, deps) {
     return { stdout: "", stderr: input.error, exitCode: input.exitCode };
   }
   const { text, configPath } = input;
+  return scanOneConfig(text, configPath, policy, args, deps);
+}
+function scanOneConfig(text, configPath, policy, args, deps) {
   const surfaceDir = flagStr(args.flags, "surface-dir");
-  const surfaces = surfaceDir ? readDocumentSurfaces(resolve(deps.cwd, surfaceDir)) : void 0;
+  const surfaces = surfaceDir ? readDocumentSurfaces(resolve2(deps.cwd, surfaceDir)) : void 0;
   let summary;
   try {
     summary = scanConfigText(text, configPath, {
@@ -2646,16 +2766,59 @@ function scanCommand(args, deps) {
     } catch {
     }
   }
-  const style = flagBool(args.flags, "no-emoji") ? NO_EMOJI_STYLE : DEFAULT_STYLE;
-  let stdout;
-  if (flagBool(args.flags, "json")) stdout = renderJson(summary);
-  else if (flagBool(args.flags, "sarif")) stdout = renderSarif(summary);
-  else if (flagBool(args.flags, "html")) stdout = renderHtml(summary);
-  else if (flagBool(args.flags, "compact")) stdout = renderCompact(summary, style);
-  else stdout = renderTerminal(summary, style);
+  const stdout = renderSummary(summary, args);
   const exitCode = flagBool(args.flags, "ci") ? exitCodeFor(summary, policy) : EXIT.OK;
   return { stdout, exitCode };
 }
+function renderSummary(summary, args) {
+  const style = flagBool(args.flags, "no-emoji") ? NO_EMOJI_STYLE : DEFAULT_STYLE;
+  if (flagBool(args.flags, "json")) return renderJson(summary);
+  if (flagBool(args.flags, "sarif")) return renderSarif(summary);
+  if (flagBool(args.flags, "markdown")) return renderMarkdown(summary);
+  if (flagBool(args.flags, "html")) return renderHtml(summary);
+  if (flagBool(args.flags, "compact")) return renderCompact(summary, style);
+  return renderTerminal(summary, style);
+}
+function scanChangedCommand(args, deps) {
+  const policyPath = flagStr(args.flags, "policy");
+  let policy;
+  try {
+    policy = loadPolicyOrDefault(policyPath);
+  } catch (err) {
+    return {
+      stdout: "",
+      stderr: err instanceof Error ? err.message : String(err),
+      exitCode: EXIT.ERROR
+    };
+  }
+  if (!deps.getChangedFilesDiff) {
+    return {
+      stdout: "",
+      stderr: "--changed needs a git diff source. Run inside a git repository, or scan a path directly.",
+      exitCode: EXIT.USAGE
+    };
+  }
+  const paths = changedConfigPaths(deps.cwd, deps.getChangedFilesDiff);
+  if (paths.length === 0) {
+    return {
+      stdout: "No agent-tool configs changed in the git diff. Nothing to scan.",
+      exitCode: EXIT.OK
+    };
+  }
+  const results = paths.map((p) => {
+    const text = readFileSync5(p, "utf8");
+    return scanOneConfig(text, p, policy, args, deps);
+  });
+  const exitCode = results.reduce((worst, r) => Math.max(worst, r.exitCode), EXIT.OK);
+  let stdout;
+  if (flagBool(args.flags, "json")) {
+    stdout = "[" + results.map((r) => r.stdout).join(",\n") + "]";
+  } else {
+    stdout = results.map((r) => r.stdout).join("\n\n---\n\n");
+  }
+  const stderr = results.map((r) => r.stderr).filter(Boolean).join("\n");
+  return { stdout, exitCode, ...stderr ? { stderr } : {} };
+}
 
 // src/commands/diagnostics.ts
 function diagnosticsCommand(args, deps) {
@@ -2737,13 +2900,13 @@ function explainCommand(args, deps) {
 }
 
 // src/commands/policy.ts
-import { existsSync as existsSync4, writeFileSync as writeFileSync2 } from "node:fs";
+import { existsSync as existsSync5, writeFileSync as writeFileSync2 } from "node:fs";
 import { join as join6 } from "node:path";
 function policyCommand(args, deps) {
   const sub = args.positionals[0];
   if (sub === "init") {
     const path = join6(deps.cwd, "calllint.policy.json");
-    if (existsSync4(path) && !flagBool(args.flags, "force")) {
+    if (existsSync5(path) && !flagBool(args.flags, "force")) {
       return {
         stdout: "",
         stderr: `${path} already exists. Use --force to overwrite.`,
@@ -2868,7 +3031,8 @@ function run(argv, deps) {
         now: deps.now,
         generatedAt: deps.generatedAt,
         writeCacheFile: deps.writeCacheFile,
-        online: deps.online
+        online: deps.online,
+        getChangedFilesDiff: deps.getChangedFilesDiff
       });
     case "diagnostics":
       return diagnosticsCommand(args, {
@@ -3112,6 +3276,7 @@ function shouldBreathe(argv, deps = {}) {
   const { flags } = parseArgs(argv);
   if (flagBool(flags, "json")) return false;
   if (flagBool(flags, "sarif")) return false;
+  if (flagBool(flags, "markdown")) return false;
   if (flagBool(flags, "html")) return false;
   if (flagBool(flags, "compact")) return false;
   if (flagBool(flags, "no-color")) return false;
@@ -3141,7 +3306,18 @@ async function breathe(argv, deps = {}) {
 // src/index.ts
 function readStdin() {
   try {
-    return readFileSync5(0, "utf8");
+    return readFileSync6(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+function gitChangedFiles(cwd) {
+  try {
+    return execFileSync("git", ["diff", "--name-only", "HEAD"], {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
   } catch {
     return "";
   }
@@ -3178,7 +3354,8 @@ async function main() {
     readStdin,
     now,
     generatedAt,
-    online
+    online,
+    getChangedFilesDiff: () => gitChangedFiles(process.cwd())
   });
   if (result.stdout) process.stdout.write(result.stdout + "\n");
   if (result.stderr) process.stderr.write(result.stderr + "\n");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "calllint",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Evidence-backed security verdicts for MCP servers and agent tools. Lint agent tool-call risk before tools run — SAFE / REVIEW / BLOCK / UNKNOWN, with evidence. Never executes the server it judges.",
   "keywords": [
     "mcp",