skill-checker 0.1.0 → 0.1.2

package/dist/cli.js

@@ -1,4 +1,12 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/cli.ts
+import { createRequire } from "module";
 import { Command } from "commander";
 
 // src/parser.ts
@@ -50,7 +58,8 @@ function parseSkill(dirPath) {
   const hasSkillMd = existsSync(skillMdPath);
   const raw = hasSkillMd ? readFileSync(skillMdPath, "utf-8") : "";
   const { frontmatter, frontmatterValid, body, bodyStartLine } = parseFrontmatter(raw);
-  const files = enumerateFiles(absDir);
+  const warnings = [];
+  const files = enumerateFiles(absDir, warnings);
   return {
     dirPath: absDir,
     raw,
@@ -59,7 +68,8 @@ function parseSkill(dirPath) {
     body,
     bodyLines: body.split("\n"),
     bodyStartLine,
-    files
+    files,
+    warnings
   };
 }
 function parseFrontmatter(raw) {
@@ -92,11 +102,20 @@ function parseFrontmatter(raw) {
     };
   }
 }
-function enumerateFiles(dirPath, maxDepth = 5) {
+var SKIP_DIRS = /* @__PURE__ */ new Set([".git"]);
+var WARN_SKIP_DIRS = /* @__PURE__ */ new Set(["node_modules"]);
+var MAX_DEPTH = 15;
+var FULL_READ_LIMIT = 5e6;
+var PARTIAL_READ_LIMIT = 512 * 1024;
+function enumerateFiles(dirPath, warnings) {
   const files = [];
   if (!existsSync(dirPath)) return files;
   function walk(currentDir, depth) {
-    if (depth > maxDepth) return;
+    if (depth > MAX_DEPTH) {
+      const rel = currentDir.slice(dirPath.length + 1) || currentDir;
+      warnings.push(`Depth limit (${MAX_DEPTH}) exceeded at: ${rel}. Contents not scanned.`);
+      return;
+    }
     let entries;
     try {
       entries = readdirSync(currentDir, { withFileTypes: true });
@@ -106,7 +125,12 @@ function enumerateFiles(dirPath, maxDepth = 5) {
     for (const entry of entries) {
       const fullPath = join(currentDir, entry.name);
       if (entry.isDirectory()) {
-        if (entry.name.startsWith(".") || entry.name === "node_modules") continue;
+        if (SKIP_DIRS.has(entry.name)) continue;
+        if (WARN_SKIP_DIRS.has(entry.name)) {
+          const rel = fullPath.slice(dirPath.length + 1);
+          warnings.push(`Skipped directory: ${rel}. May contain unscanned files.`);
+          continue;
+        }
         walk(fullPath, depth + 1);
         continue;
       }
@@ -120,10 +144,25 @@ function enumerateFiles(dirPath, maxDepth = 5) {
       const isBinary = BINARY_EXTENSIONS.has(ext);
       const relativePath = fullPath.slice(dirPath.length + 1);
       let content;
-      if (!isBinary && stats.size < 1e6) {
-        try {
-          content = readFileSync(fullPath, "utf-8");
-        } catch {
+      if (!isBinary) {
+        if (stats.size <= FULL_READ_LIMIT) {
+          try {
+            content = readFileSync(fullPath, "utf-8");
+          } catch {
+          }
+        } else if (stats.size <= 5e7) {
+          try {
+            const fd = __require("fs").openSync(fullPath, "r");
+            const buf = Buffer.alloc(PARTIAL_READ_LIMIT);
+            const bytesRead = __require("fs").readSync(fd, buf, 0, PARTIAL_READ_LIMIT, 0);
+            __require("fs").closeSync(fd);
+            content = buf.slice(0, bytesRead).toString("utf-8");
+            warnings.push(`Large file partially scanned (first ${PARTIAL_READ_LIMIT} bytes): ${relativePath} (${stats.size} bytes total)`);
+          } catch {
+            warnings.push(`Large file could not be read: ${relativePath} (${stats.size} bytes)`);
+          }
+        } else {
+          warnings.push(`File too large to scan: ${relativePath} (${stats.size} bytes). Content not checked.`);
         }
       }
       files.push({
@@ -247,6 +286,15 @@ var structuralChecks = {
         });
       }
     }
+    for (const warning of skill.warnings) {
+      results.push({
+        id: "STRUCT-008",
+        category: "STRUCT",
+        severity: "MEDIUM",
+        title: "Scan coverage warning",
+        message: warning
+      });
+    }
     return results;
   }
 };
@@ -297,6 +345,14 @@ function isInDocumentationContext(lines, lineIndex) {
   }
   return false;
 }
+function isLicenseFile(filePath) {
+  const name = filePath.split("/").pop()?.toUpperCase() ?? "";
+  const base = name.replace(/\.[^.]+$/, "");
+  return /^(LICENSE|LICENCE|COPYING|NOTICE|AUTHORS|PATENTS)$/.test(base);
+}
+function isLocalhostURL(url) {
+  return /^https?:\/\/(localhost|127\.0\.0\.1|0\.0\.0\.0|\[::1\])/i.test(url);
+}
 function parseURLPath(url) {
   try {
     const u = new URL(url);
@@ -891,6 +947,66 @@ function dedup(results) {
   });
 }
 
+// src/types.ts
+var SEVERITY_SCORES = {
+  CRITICAL: 25,
+  HIGH: 10,
+  MEDIUM: 3,
+  LOW: 1
+};
+function computeGrade(score) {
+  if (score >= 90) return "A";
+  if (score >= 75) return "B";
+  if (score >= 60) return "C";
+  if (score >= 40) return "D";
+  return "F";
+}
+var REDUCE_MAP = {
+  CRITICAL: "HIGH",
+  HIGH: "MEDIUM",
+  MEDIUM: "LOW",
+  LOW: "LOW"
+};
+function reduceSeverity(original, reason) {
+  let reduced = REDUCE_MAP[original];
+  if (original === "CRITICAL" && reduced === "LOW") {
+    reduced = "MEDIUM";
+  }
+  return {
+    severity: reduced,
+    reducedFrom: original,
+    annotation: `[reduced: ${reason}]`
+  };
+}
+var DEFAULT_CONFIG = {
+  policy: "balanced",
+  overrides: {},
+  ignore: []
+};
+function getHookAction(policy, severity) {
+  const matrix = {
+    strict: {
+      CRITICAL: "deny",
+      HIGH: "deny",
+      MEDIUM: "ask",
+      LOW: "report"
+    },
+    balanced: {
+      CRITICAL: "deny",
+      HIGH: "ask",
+      MEDIUM: "report",
+      LOW: "report"
+    },
+    permissive: {
+      CRITICAL: "ask",
+      HIGH: "report",
+      MEDIUM: "report",
+      LOW: "report"
+    }
+  };
+  return matrix[policy][severity];
+}
+
 // src/checks/code-safety.ts
 var EVAL_PATTERNS = [
   /\beval\s*\(/,
@@ -974,6 +1090,7 @@ var codeSafetyChecks = {
         const line = lines[i];
         const lineNum = i + 1;
         const loc = `${source}:${lineNum}`;
+        const cbCtx = { lines, index: i };
         checkPatterns(results, line, EVAL_PATTERNS, {
           id: "CODE-001",
           severity: "CRITICAL",
@@ -995,14 +1112,16 @@ var codeSafetyChecks = {
           severity: "CRITICAL",
           title: "Destructive file operation",
           loc,
-          lineNum
+          lineNum,
+          codeBlockCtx: cbCtx
         });
         checkPatterns(results, line, NETWORK_PATTERNS, {
           id: "CODE-004",
           severity: "HIGH",
           title: "Hardcoded external URL/network request",
           loc,
-          lineNum
+          lineNum,
+          codeBlockCtx: cbCtx
         });
         checkPatterns(results, line, FILE_WRITE_PATTERNS, {
           id: "CODE-005",
@@ -1016,7 +1135,8 @@ var codeSafetyChecks = {
           severity: "MEDIUM",
           title: "Environment variable access",
           loc,
-          lineNum
+          lineNum,
+          codeBlockCtx: cbCtx
         });
         checkPatterns(results, line, DYNAMIC_CODE_PATTERNS, {
           id: "CODE-010",
@@ -1026,8 +1146,7 @@ var codeSafetyChecks = {
           lineNum
         });
         {
-          const srcLines = text.split("\n");
-          const isDoc = isInDocumentationContext(srcLines, i);
+          const isDoc = isInDocumentationContext(lines, i);
           if (!isDoc) {
             checkPatterns(results, line, PERMISSION_PATTERNS, {
               id: "CODE-012",
@@ -1048,14 +1167,24 @@ var codeSafetyChecks = {
 function checkPatterns(results, line, patterns, opts) {
   for (const pattern of patterns) {
     if (pattern.test(line)) {
+      let severity = opts.severity;
+      let reducedFrom;
+      let msgSuffix = "";
+      if (opts.codeBlockCtx && isInCodeBlock(opts.codeBlockCtx.lines, opts.codeBlockCtx.index)) {
+        const r = reduceSeverity(severity, "in code block");
+        severity = r.severity;
+        reducedFrom = r.reducedFrom;
+        msgSuffix = ` ${r.annotation}`;
+      }
       results.push({
         id: opts.id,
         category: "CODE",
-        severity: opts.severity,
+        severity,
         title: opts.title,
-        message: `At ${opts.loc}: ${line.trim().slice(0, 120)}`,
+        message: `At ${opts.loc}: ${line.trim().slice(0, 120)}${msgSuffix}`,
         line: opts.lineNum,
-        snippet: line.trim().slice(0, 120)
+        snippet: line.trim().slice(0, 120),
+        reducedFrom
       });
       return;
     }
@@ -1138,22 +1267,144 @@ function scanObfuscation(results, text, source) {
   }
 }
 
+// src/ioc/index.ts
+import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir } from "os";
+
+// src/ioc/indicators.ts
+var DEFAULT_IOC = {
+  version: "2026.03.06",
+  updated: "2026-03-06",
+  c2_ips: [
+    "91.92.242.30",
+    "91.92.242.39",
+    "185.220.101.1",
+    "185.220.101.2",
+    "45.155.205.233"
+  ],
+  malicious_hashes: {
+    // NOTE: Never add the SHA-256 of an empty file (e3b0c44298fc...b855)
+    // as it causes false positives on any empty file.
+    "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2": "clawhavoc-exfiltrator"
+  },
+  malicious_domains: [
+    "webhook.site",
+    "requestbin.com",
+    "pipedream.com",
+    "pipedream.net",
+    "hookbin.com",
+    "beeceptor.com",
+    "ngrok.io",
+    "ngrok-free.app",
+    "serveo.net",
+    "localtunnel.me",
+    "bore.pub",
+    "interact.sh",
+    "oast.fun",
+    "oastify.com",
+    "dnslog.cn",
+    "ceye.io",
+    "burpcollaborator.net",
+    "pastebin.com",
+    "paste.ee",
+    "hastebin.com",
+    "ghostbin.com",
+    "evil.com",
+    "malware.com",
+    "exploit.in"
+  ],
+  typosquat: {
+    known_patterns: [
+      "clawhub1",
+      "cllawhub",
+      "clawhab",
+      "moltbot",
+      "claw-hub",
+      "clawhub-pro"
+    ],
+    protected_names: [
+      "clawhub",
+      "secureclaw",
+      "openclaw",
+      "clawbot",
+      "claude",
+      "anthropic",
+      "skill-checker"
+    ]
+  },
+  malicious_publishers: [
+    "clawhavoc",
+    "phantom-tracker",
+    "solana-wallet-drainer"
+  ]
+};
+
+// src/ioc/index.ts
+var cachedIOC = null;
+function loadIOC() {
+  if (cachedIOC) return cachedIOC;
+  const ioc = structuredClone(DEFAULT_IOC);
+  const overridePath = join2(
+    homedir(),
+    ".config",
+    "skill-checker",
+    "ioc-override.json"
+  );
+  if (existsSync2(overridePath)) {
+    try {
+      const raw = readFileSync2(overridePath, "utf-8");
+      const ext = JSON.parse(raw);
+      mergeIOC(ioc, ext);
+    } catch {
+    }
+  }
+  cachedIOC = ioc;
+  return ioc;
+}
+function mergeIOC(base, ext) {
+  if (ext.c2_ips) {
+    base.c2_ips = dedupe([...base.c2_ips, ...ext.c2_ips]);
+  }
+  if (ext.malicious_hashes) {
+    Object.assign(base.malicious_hashes, ext.malicious_hashes);
+  }
+  if (ext.malicious_domains) {
+    base.malicious_domains = dedupe([
+      ...base.malicious_domains,
+      ...ext.malicious_domains
+    ]);
+  }
+  if (ext.typosquat) {
+    if (ext.typosquat.known_patterns) {
+      base.typosquat.known_patterns = dedupe([
+        ...base.typosquat.known_patterns,
+        ...ext.typosquat.known_patterns
+      ]);
+    }
+    if (ext.typosquat.protected_names) {
+      base.typosquat.protected_names = dedupe([
+        ...base.typosquat.protected_names,
+        ...ext.typosquat.protected_names
+      ]);
+    }
+  }
+  if (ext.malicious_publishers) {
+    base.malicious_publishers = dedupe([
+      ...base.malicious_publishers,
+      ...ext.malicious_publishers
+    ]);
+  }
+  if (ext.version) base.version = ext.version;
+  if (ext.updated) base.updated = ext.updated;
+}
+function dedupe(arr) {
+  return [...new Set(arr)];
+}
+
 // src/checks/supply-chain.ts
-var SUSPICIOUS_DOMAINS = [
-  "evil.com",
-  "malware.com",
-  "exploit.in",
-  "darkweb.onion",
-  "pastebin.com",
-  // often used for payload hosting
-  "ngrok.io",
-  // tunneling service
-  "requestbin.com",
-  "webhook.site",
-  "pipedream.net",
-  "burpcollaborator.net",
-  "interact.sh",
-  "oastify.com"
+var FALLBACK_SUSPICIOUS_DOMAINS = [
+  "darkweb.onion"
 ];
 var MCP_SERVER_PATTERN = /\bmcp[-_]?server\b/i;
 var NPX_Y_PATTERN = /\bnpx\s+-y\s+/;
@@ -1162,23 +1413,47 @@ var PIP_INSTALL_PATTERN = /\bpip3?\s+install\b/;
 var GIT_CLONE_PATTERN = /\bgit\s+clone\b/;
 var URL_PATTERN = /https?:\/\/[^\s"'`<>)\]]+/g;
 var IP_URL_PATTERN = /https?:\/\/(?:\d{1,3}\.){3}\d{1,3}/;
+function extractHostname(url) {
+  const afterProto = url.replace(/^https?:\/\//, "");
+  const hostPort = afterProto.split("/")[0].split("?")[0].split("#")[0];
+  const host = hostPort.split(":")[0];
+  return host.toLowerCase();
+}
+function hostnameMatchesDomain(hostname, domain) {
+  const d = domain.toLowerCase();
+  return hostname === d || hostname.endsWith("." + d);
+}
 var supplyChainChecks = {
   name: "Supply Chain",
   category: "SUPPLY",
   run(skill) {
     const results = [];
     const allText = getAllText(skill);
+    const ioc = loadIOC();
+    const suspiciousDomains = ioc.malicious_domains.length > 0 ? ioc.malicious_domains : FALLBACK_SUSPICIOUS_DOMAINS;
     for (let i = 0; i < allText.length; i++) {
       const { line, lineNum, source } = allText[i];
       if (MCP_SERVER_PATTERN.test(line)) {
+        let severity = "HIGH";
+        let reducedFrom;
+        let msgSuffix = "";
+        const srcLines = getLinesForSource(skill, source);
+        const localIdx = getLocalIndex(source, lineNum, skill.bodyStartLine);
+        if (localIdx >= 0 && isInCodeBlock(srcLines, localIdx)) {
+          const r = reduceSeverity(severity, "in code block");
+          severity = r.severity;
+          reducedFrom = r.reducedFrom;
+          msgSuffix = ` ${r.annotation}`;
+        }
         results.push({
           id: "SUPPLY-001",
           category: "SUPPLY",
-          severity: "HIGH",
+          severity,
           title: "MCP server reference",
-          message: `${source}:${lineNum}: References an MCP server. Verify it is from a trusted source.`,
+          message: `${source}:${lineNum}: References an MCP server. Verify it is from a trusted source.${msgSuffix}`,
           line: lineNum,
-          snippet: line.trim().slice(0, 120)
+          snippet: line.trim().slice(0, 120),
+          reducedFrom
         });
       }
       if (NPX_Y_PATTERN.test(line)) {
@@ -1200,14 +1475,26 @@ var supplyChainChecks = {
           globalIdx
         );
         if (!isDoc) {
+          let severity = "HIGH";
+          let reducedFrom;
+          let msgSuffix = "";
+          const srcLines = getLinesForSource(skill, source);
+          const localIdx = getLocalIndex(source, lineNum, skill.bodyStartLine);
+          if (localIdx >= 0 && isInCodeBlock(srcLines, localIdx)) {
+            const r = reduceSeverity(severity, "in code block");
+            severity = r.severity;
+            reducedFrom = r.reducedFrom;
+            msgSuffix = ` ${r.annotation}`;
+          }
           results.push({
             id: "SUPPLY-003",
             category: "SUPPLY",
-            severity: "HIGH",
+            severity,
             title: "Package installation command",
-            message: `${source}:${lineNum}: Installs packages. Verify package names are legitimate.`,
+            message: `${source}:${lineNum}: Installs packages. Verify package names are legitimate.${msgSuffix}`,
             line: lineNum,
-            snippet: line.trim().slice(0, 120)
+            snippet: line.trim().slice(0, 120),
+            reducedFrom
           });
         }
       }
@@ -1225,16 +1512,30 @@ var supplyChainChecks = {
       const urls = line.match(URL_PATTERN) || [];
       for (const url of urls) {
         if (url.startsWith("http://")) {
+          if (isLicenseFile(source)) continue;
+          if (isLocalhostURL(url)) continue;
           if (!isNamespaceOrSchemaURI(url, line)) {
             const isNetworkCtx = isInNetworkRequestContext(line);
+            let severity = isNetworkCtx ? "HIGH" : "MEDIUM";
+            let reducedFrom;
+            let msgSuffix = "";
+            const srcLines = getLinesForSource(skill, source);
+            const localIdx = getLocalIndex(source, lineNum, skill.bodyStartLine);
+            if (localIdx >= 0 && isInCodeBlock(srcLines, localIdx)) {
+              const r = reduceSeverity(severity, "in code block");
+              severity = r.severity;
+              reducedFrom = r.reducedFrom;
+              msgSuffix = ` ${r.annotation}`;
+            }
             results.push({
               id: "SUPPLY-004",
               category: "SUPPLY",
-              severity: isNetworkCtx ? "HIGH" : "MEDIUM",
+              severity,
               title: "Non-HTTPS URL",
-              message: `${source}:${lineNum}: Uses insecure HTTP: ${url}`,
+              message: `${source}:${lineNum}: Uses insecure HTTP: ${url}${msgSuffix}`,
               line: lineNum,
-              snippet: url
+              snippet: url,
+              reducedFrom
             });
           }
         }
@@ -1251,8 +1552,9 @@ var supplyChainChecks = {
             });
           }
         }
-        for (const domain of SUSPICIOUS_DOMAINS) {
-          if (url.includes(domain)) {
+        const hostname = extractHostname(url);
+        for (const domain of suspiciousDomains) {
+          if (hostnameMatchesDomain(hostname, domain)) {
             results.push({
               id: "SUPPLY-007",
               category: "SUPPLY",
@@ -1270,6 +1572,15 @@ var supplyChainChecks = {
     return results;
   }
 };
+function getLinesForSource(skill, source) {
+  if (source === "SKILL.md") return skill.bodyLines;
+  const file = skill.files.find((f) => f.path === source);
+  return file?.content?.split("\n") ?? [];
+}
+function getLocalIndex(source, lineNum, bodyStartLine) {
+  if (source === "SKILL.md") return lineNum - bodyStartLine;
+  return lineNum - 1;
+}
 function getAllText(skill) {
   const result = [];
   for (let i = 0; i < skill.bodyLines.length; i++) {
@@ -1449,143 +1760,9 @@ var resourceChecks = {
   }
 };
 
-// src/ioc/index.ts
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
-import { homedir } from "os";
-
-// src/ioc/indicators.ts
-var DEFAULT_IOC = {
-  version: "2026.03.06",
-  updated: "2026-03-06",
-  c2_ips: [
-    "91.92.242.30",
-    "91.92.242.39",
-    "185.220.101.1",
-    "185.220.101.2",
-    "45.155.205.233"
-  ],
-  malicious_hashes: {
-    "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855": "clawhavoc-empty-payload",
-    "a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2c3d4e5f6a1b2": "clawhavoc-exfiltrator"
-  },
-  malicious_domains: [
-    "webhook.site",
-    "requestbin.com",
-    "pipedream.com",
-    "pipedream.net",
-    "hookbin.com",
-    "beeceptor.com",
-    "ngrok.io",
-    "ngrok-free.app",
-    "serveo.net",
-    "localtunnel.me",
-    "bore.pub",
-    "interact.sh",
-    "oast.fun",
-    "oastify.com",
-    "dnslog.cn",
-    "ceye.io",
-    "burpcollaborator.net",
-    "pastebin.com",
-    "paste.ee",
-    "hastebin.com",
-    "ghostbin.com",
-    "evil.com",
-    "malware.com",
-    "exploit.in"
-  ],
-  typosquat: {
-    known_patterns: [
-      "clawhub1",
-      "cllawhub",
-      "clawhab",
-      "moltbot",
-      "claw-hub",
-      "clawhub-pro"
-    ],
-    protected_names: [
-      "clawhub",
-      "secureclaw",
-      "openclaw",
-      "clawbot",
-      "claude",
-      "anthropic",
-      "skill-checker"
-    ]
-  },
-  malicious_publishers: [
-    "clawhavoc",
-    "phantom-tracker",
-    "solana-wallet-drainer"
-  ]
-};
-
-// src/ioc/index.ts
-var cachedIOC = null;
-function loadIOC() {
-  if (cachedIOC) return cachedIOC;
-  const ioc = structuredClone(DEFAULT_IOC);
-  const overridePath = join2(
-    homedir(),
-    ".config",
-    "skill-checker",
-    "ioc-override.json"
-  );
-  if (existsSync2(overridePath)) {
-    try {
-      const raw = readFileSync2(overridePath, "utf-8");
-      const ext = JSON.parse(raw);
-      mergeIOC(ioc, ext);
-    } catch {
-    }
-  }
-  cachedIOC = ioc;
-  return ioc;
-}
-function mergeIOC(base, ext) {
-  if (ext.c2_ips) {
-    base.c2_ips = dedupe([...base.c2_ips, ...ext.c2_ips]);
-  }
-  if (ext.malicious_hashes) {
-    Object.assign(base.malicious_hashes, ext.malicious_hashes);
-  }
-  if (ext.malicious_domains) {
-    base.malicious_domains = dedupe([
-      ...base.malicious_domains,
-      ...ext.malicious_domains
-    ]);
-  }
-  if (ext.typosquat) {
-    if (ext.typosquat.known_patterns) {
-      base.typosquat.known_patterns = dedupe([
-        ...base.typosquat.known_patterns,
-        ...ext.typosquat.known_patterns
-      ]);
-    }
-    if (ext.typosquat.protected_names) {
-      base.typosquat.protected_names = dedupe([
-        ...base.typosquat.protected_names,
-        ...ext.typosquat.protected_names
-      ]);
-    }
-  }
-  if (ext.malicious_publishers) {
-    base.malicious_publishers = dedupe([
-      ...base.malicious_publishers,
-      ...ext.malicious_publishers
-    ]);
-  }
-  if (ext.version) base.version = ext.version;
-  if (ext.updated) base.updated = ext.updated;
-}
-function dedupe(arr) {
-  return [...new Set(arr)];
-}
-
 // src/ioc/matcher.ts
 import { createHash } from "crypto";
-import { readFileSync as readFileSync3 } from "fs";
+import { openSync, readSync, closeSync, statSync as statSync2 } from "fs";
 import { join as join3 } from "path";
 
 // src/utils/levenshtein.ts
@@ -1618,6 +1795,7 @@ function levenshtein(a, b) {
 }
 
 // src/ioc/matcher.ts
+var EMPTY_FILE_HASH = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
 var IPV4_PATTERN = /\b(\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})\b/g;
 function isPrivateIP(ip) {
   const parts = ip.split(".").map(Number);
@@ -1630,6 +1808,24 @@ function isPrivateIP(ip) {
   if (parts[0] === 169 && parts[1] === 254) return true;
   return false;
 }
+var HASH_CHUNK_SIZE = 64 * 1024;
+function computeFileHash(filePath) {
+  const hash = createHash("sha256");
+  const fd = openSync(filePath, "r");
+  try {
+    const buf = Buffer.alloc(HASH_CHUNK_SIZE);
+    let bytesRead;
+    do {
+      bytesRead = readSync(fd, buf, 0, HASH_CHUNK_SIZE, null);
+      if (bytesRead > 0) {
+        hash.update(buf.subarray(0, bytesRead));
+      }
+    } while (bytesRead > 0);
+  } finally {
+    closeSync(fd);
+  }
+  return hash.digest("hex");
+}
 function matchMaliciousHashes(skill, ioc) {
   const matches = [];
   const hashKeys = Object.keys(ioc.malicious_hashes);
@@ -1637,8 +1833,10 @@ function matchMaliciousHashes(skill, ioc) {
   for (const file of skill.files) {
     const filePath = join3(skill.dirPath, file.path);
     try {
-      const content = readFileSync3(filePath);
-      const hash = createHash("sha256").update(content).digest("hex");
+      const stat = statSync2(filePath);
+      if (stat.size === 0) continue;
+      const hash = computeFileHash(filePath);
+      if (hash === EMPTY_FILE_HASH) continue;
       if (ioc.malicious_hashes[hash]) {
         matches.push({
           file: file.path,
@@ -1788,49 +1986,6 @@ function runAllChecks(skill) {
   return results;
 }
 
-// src/types.ts
-var SEVERITY_SCORES = {
-  CRITICAL: 25,
-  HIGH: 10,
-  MEDIUM: 3,
-  LOW: 1
-};
-function computeGrade(score) {
-  if (score >= 90) return "A";
-  if (score >= 75) return "B";
-  if (score >= 60) return "C";
-  if (score >= 40) return "D";
-  return "F";
-}
-var DEFAULT_CONFIG = {
-  policy: "balanced",
-  overrides: {},
-  ignore: []
-};
-function getHookAction(policy, severity) {
-  const matrix = {
-    strict: {
-      CRITICAL: "deny",
-      HIGH: "deny",
-      MEDIUM: "ask",
-      LOW: "report"
-    },
-    balanced: {
-      CRITICAL: "deny",
-      HIGH: "ask",
-      MEDIUM: "report",
-      LOW: "report"
-    },
-    permissive: {
-      CRITICAL: "ask",
-      HIGH: "report",
-      MEDIUM: "report",
-      LOW: "report"
-    }
-  };
-  return matrix[policy][severity];
-}
-
 // src/scanner.ts
 function scanSkillDirectory(dirPath, config = DEFAULT_CONFIG) {
   const skill = parseSkill(dirPath);
@@ -1845,6 +2000,7 @@ function buildReport(skill, config) {
     return r;
   });
   results = results.filter((r) => !config.ignore.includes(r.id));
+  results = deduplicateResults(results);
   const score = calculateScore(results);
   const grade = computeGrade(score);
   const summary = {
@@ -1864,6 +2020,40 @@ function buildReport(skill, config) {
     summary
   };
 }
+function deduplicateResults(results) {
+  const groups = /* @__PURE__ */ new Map();
+  const severityOrder = {
+    CRITICAL: 4,
+    HIGH: 3,
+    MEDIUM: 2,
+    LOW: 1
+  };
+  for (const r of results) {
+    const sourceFile = extractSourceFile(r.message);
+    const key = `${r.id}::${sourceFile}`;
+    const group = groups.get(key);
+    if (group) {
+      group.push(r);
+    } else {
+      groups.set(key, [r]);
+    }
+  }
+  const deduped = [];
+  for (const group of groups.values()) {
+    group.sort((a, b) => severityOrder[b.severity] - severityOrder[a.severity]);
+    const best = { ...group[0] };
+    if (group.length > 1) {
+      best.occurrences = group.length;
+      best.message += ` (${group.length} occurrences in this file)`;
+    }
+    deduped.push(best);
+  }
+  return deduped;
+}
+function extractSourceFile(message) {
+  const m = message.match(/^(?:At\s+)?([^:]+):\d+:/);
+  return m?.[1] ?? "unknown";
+}
 function calculateScore(results) {
   let score = 100;
   for (const r of results) {
@@ -2050,7 +2240,7 @@ function buildReportSummary(report) {
 }
 
 // src/config.ts
-import { readFileSync as readFileSync4, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
 import { join as join4, resolve as resolve2 } from "path";
 import { parse as parseYaml2 } from "yaml";
 var CONFIG_FILENAMES = [
@@ -2092,7 +2282,7 @@ function loadConfig(startDir, configPath) {
 }
 function parseConfigFile(path) {
   try {
-    const raw = readFileSync4(path, "utf-8");
+    const raw = readFileSync3(path, "utf-8");
     const parsed = parseYaml2(raw);
     if (!parsed || typeof parsed !== "object") {
       return { ...DEFAULT_CONFIG };
@@ -2132,10 +2322,12 @@ function normalizeSeverity(value) {
 }
 
 // src/cli.ts
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
 var program = new Command();
 program.name("skill-checker").description(
   "Security checker for Claude Code skills - detect injection, malicious code, and supply chain risks"
-).version("0.1.0");
+).version(pkg.version);
 program.command("scan").description("Scan a skill directory for security issues").argument("<path>", "Path to the skill directory").option("-f, --format <format>", "Output format: terminal, json, hook", "terminal").option("-p, --policy <policy>", "Policy: strict, balanced, permissive").option("-c, --config <path>", "Path to config file").action(
   (path, opts) => {
     const config = loadConfig(path, opts.config);