Add configurable lint ignores

Author: f0d010c

README.md

@@ -50,8 +50,8 @@ Commands that write files are explicit:
 For cautious use, pin the npm version, review the source, and start with read-only commands:
 
 ```bash
-npx agent-skillforge@0.3.0 lint .
-npx agent-skillforge@0.3.0 compat . --target portable
+npx agent-skillforge@0.3.1 lint .
+npx agent-skillforge@0.3.1 compat . --target portable
 ```
 
 ## Install
@@ -95,7 +95,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
-      - uses: f0d010c/skillforge@v0.3.0
+      - uses: f0d010c/skillforge@v0.3.1
         with:
           path: .
           profile: source
@@ -104,7 +104,7 @@ jobs:
 For marketplace-ready checks, use:
 
 ```yaml
-      - uses: f0d010c/skillforge@v0.3.0
+      - uses: f0d010c/skillforge@v0.3.1
         with:
           path: .
           profile: marketplace
@@ -186,6 +186,30 @@ skillforge pack ./my-plugin
 
 Default lint mode focuses on deterministic publish-readiness problems. Use `--strict` to include advisory checks such as trigger-description quality, large skill bodies, unreferenced scripts, and plugin name/folder mismatch.
 
+## Configuration
+
+Add `skillforge.json` at the repo or package root to tune checks:
+
+```json
+{
+  "name": "my-agent-skill-pack",
+  "lint": {
+    "ignore": [
+      "templates/**",
+      "tests/fixtures/**",
+      "examples/broken-on-purpose/**"
+    ]
+  },
+  "checks": {
+    "maxSkillMdLines": 500,
+    "requireOpenAiYaml": false,
+    "allowScripts": true
+  }
+}
+```
+
+Use `lint.ignore` for intentional fixtures, vendored examples, generated output, or template folders that should not be treated as publishable skills/plugins.
+
 ## Compatibility
 
 Use `compat` to check whether a skill/package is likely to work in a specific agent ecosystem.

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-skillforge",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "description": "Creator tooling for agent skills and plugins.",
   "type": "module",
   "bin": {

package.json

@@ -0,0 +1,11 @@
+{
+  "name": "agent-skillforge",
+  "lint": {
+    "allowEmptyCollection": true,
+    "ignore": [
+      "examples/real-world-cases/**",
+      "templates/**",
+      "tests/fixtures/**"
+    ]
+  }
+}

skillforge.json

@@ -14,7 +14,7 @@ const program = new Command();
 program
   .name("agent-skillforge")
   .description("Creator tooling for agent skills and plugins.")
-  .version("0.3.0")
+  .version("0.3.1")
   .exitOverride();
 
 program

src/cli.ts

@@ -1,8 +1,10 @@
 import path from "node:path";
 import fs from "fs-extra";
 import { lintPath } from "../lib/lint.js";
+import { loadConfig } from "../lib/config.js";
 import { parseMarkdownFrontmatter } from "../lib/frontmatter.js";
-import type { Issue, IssueImpact, IssueLevel } from "../types.js";
+import { defaultIgnoredDirs, isIgnoredPath } from "../lib/ignore.js";
+import type { Issue, IssueImpact, IssueLevel, SkillForgeConfig } from "../types.js";
 
 export type CompatTarget = "codex" | "claude" | "portable";
 export type CompatFormat = "text" | "json";
@@ -113,6 +115,8 @@ async function scriptPortabilityIssues(root: string): Promise<Issue[]> {
 
 async function findSkillFiles(root: string): Promise<string[]> {
   const found: string[] = [];
+  const config = await loadConfig(root).catch((): SkillForgeConfig => ({}));
+  const ignorePatterns = config.lint?.ignore ?? [];
   async function walk(dir: string, depth: number): Promise<void> {
     if (depth > 5) return;
     const skillPath = path.join(dir, "SKILL.md");
@@ -121,10 +125,10 @@ async function findSkillFiles(root: string): Promise<string[]> {
       return;
     }
     for (const entry of await fs.readdir(dir)) {
-      if (["node_modules", "dist", ".git", ".next", "coverage"].includes(entry)) continue;
+      if (defaultIgnoredDirs.has(entry)) continue;
       const full = path.join(dir, entry);
       const stat = await fs.stat(full);
-      if (stat.isDirectory()) await walk(full, depth + 1);
+      if (stat.isDirectory() && !isIgnoredPath(root, full, ignorePatterns)) await walk(full, depth + 1);
     }
   }
   await walk(root, 0);

src/commands/compat.ts

@@ -2,8 +2,10 @@ import path from "node:path";
 import fs from "fs-extra";
 import { loadConfig } from "../lib/config.js";
 import { parseMarkdownFrontmatter } from "../lib/frontmatter.js";
+import { defaultIgnoredDirs, isIgnoredPath } from "../lib/ignore.js";
 import { lintPath } from "../lib/lint.js";
 import { countErrors } from "../lib/reporters.js";
+import type { SkillForgeConfig } from "../types.js";
 
 export async function smokeCommand(targetPath: string): Promise<{ output: string; exitCode: number }> {
   const absolute = path.resolve(targetPath);
@@ -58,13 +60,16 @@ async function promptMatchScore(root: string, prompt: string): Promise<number> {
 async function findSkillFiles(root: string): Promise<string[]> {
   const direct = path.join(root, "SKILL.md");
   if (await fs.pathExists(direct)) return [direct];
+  const config = await loadConfig(root).catch((): SkillForgeConfig => ({}));
+  const ignorePatterns = config.lint?.ignore ?? [];
   const files: string[] = [];
   async function walk(dir: string, depth: number): Promise<void> {
     if (depth > 5) return;
     for (const entry of await fs.readdir(dir)) {
-      if (["node_modules", "dist", ".git"].includes(entry)) continue;
+      if (defaultIgnoredDirs.has(entry)) continue;
       const full = path.join(dir, entry);
       if (!(await fs.stat(full)).isDirectory()) continue;
+      if (isIgnoredPath(root, full, ignorePatterns)) continue;
       const skill = path.join(full, "SKILL.md");
       if (await fs.pathExists(skill)) files.push(skill);
       else await walk(full, depth + 1);

src/commands/smoke.ts

@@ -20,6 +20,12 @@ const configSchema = z.object({
       requireOpenAiYaml: z.boolean().optional(),
       allowScripts: z.boolean().optional()
     })
+    .optional(),
+  lint: z
+    .object({
+      ignore: z.array(z.string().min(1)).optional(),
+      allowEmptyCollection: z.boolean().optional()
+    })
     .optional()
 });
 

src/lib/config.ts

@@ -0,0 +1,55 @@
+import path from "node:path";
+
+export const defaultIgnoredDirs = new Set(["node_modules", "dist", ".git", ".next", "coverage", "tmp-e2e"]);
+
+export function isIgnoredPath(root: string, target: string, patterns: string[] = []): boolean {
+  const relative = toPosix(path.relative(root, target));
+  if (!relative || relative.startsWith("..")) return false;
+  return patterns.some((pattern) => matchesPattern(relative, pattern));
+}
+
+function matchesPattern(relative: string, rawPattern: string): boolean {
+  const pattern = normalizePattern(rawPattern);
+  if (!pattern) return false;
+
+  if (pattern.endsWith("/**")) {
+    const base = pattern.slice(0, -3);
+    return relative === base || relative.startsWith(`${base}/`);
+  }
+
+  if (!pattern.includes("*")) {
+    return relative === pattern || relative.startsWith(`${pattern}/`);
+  }
+
+  return globToRegExp(pattern).test(relative);
+}
+
+function normalizePattern(pattern: string): string {
+  return toPosix(pattern).replace(/^\.\/+/, "").replace(/\/+$/, "");
+}
+
+function toPosix(value: string): string {
+  return value.replaceAll(path.sep, "/").replaceAll("\\", "/");
+}
+
+function globToRegExp(pattern: string): RegExp {
+  let source = "^";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    const next = pattern[index + 1];
+    if (char === "*" && next === "*") {
+      source += ".*";
+      index += 1;
+    } else if (char === "*") {
+      source += "[^/]*";
+    } else {
+      source += escapeRegExp(char);
+    }
+  }
+  source += "$";
+  return new RegExp(source);
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[\\^$+?.()|[\]{}]/g, "\\$&");
+}

src/lib/ignore.ts

@@ -5,6 +5,7 @@ import { z } from "zod";
 import type { Issue, LintOptions, LintResult, SkillForgeConfig } from "../types.js";
 import { loadConfig } from "./config.js";
 import { parseMarkdownFrontmatter } from "./frontmatter.js";
+import { defaultIgnoredDirs, isIgnoredPath } from "./ignore.js";
 import { hyphenName } from "./paths.js";
 
 const skillFrontmatterSchema = z.object({
@@ -71,7 +72,6 @@ const pluginManifestSchema = z
   })
   .passthrough();
 
-const ignoredDirs = new Set(["node_modules", "dist", ".git", ".next", "coverage", "tmp-e2e"]);
 const advisoryCodes = new Set([
   "plugin.name.mismatch",
   "skill.description.vague",
@@ -99,18 +99,33 @@ export async function lintPath(targetPath: string, options: LintOptions = {}): P
     return applyLintOptions(direct, lintOptions);
   }
 
-  const children = await discoverLintTargets(absolute);
+  const collectionIssues: Issue[] = [];
+  const collectionConfig = await loadConfig(absolute).catch((error): SkillForgeConfig => {
+    collectionIssues.push({ level: "error", impact: "blocking", code: "config.invalid", message: String(error), file: path.join(absolute, "skillforge.json") });
+    return {};
+  });
+  const collectionOptions = { ...lintOptions, ignore: [...(lintOptions.ignore ?? []), ...(collectionConfig.lint?.ignore ?? [])] };
+  const children = await discoverLintTargets(absolute, collectionOptions.ignore);
   if (children.length === 0) {
+    if (collectionConfig.lint?.allowEmptyCollection) {
+      return {
+        targetPath: absolute,
+        kind: "collection",
+        profile: lintOptions.profile,
+        checkedPaths: [],
+        issues: filterIssues(collectionIssues, collectionOptions)
+      };
+    }
     return direct;
   }
 
-  const results = await Promise.all(children.map((child) => lintSingle(child, lintOptions)));
+  const results = await Promise.all(children.map((child) => lintSingle(child, collectionOptions)));
   return {
     targetPath: absolute,
     kind: "collection",
     profile: lintOptions.profile,
     checkedPaths: results.map((result) => result.targetPath),
-    issues: filterIssues(results.flatMap((result) => result.issues), lintOptions)
+    issues: filterIssues([...collectionIssues, ...results.flatMap((result) => result.issues)], collectionOptions)
   };
 }
 
@@ -177,15 +192,16 @@ async function lintSingle(root: string, options: LintOptions): Promise<LintResul
   return { targetPath: root, kind: isPlugin ? "plugin" : isSkill ? "skill" : "unknown", profile: options.profile, issues };
 }
 
-async function discoverLintTargets(root: string): Promise<string[]> {
+async function discoverLintTargets(root: string, ignorePatterns: string[] = []): Promise<string[]> {
   const found = new Set<string>();
   async function walk(dir: string, depth: number): Promise<void> {
     if (depth > 5) return;
     for (const entry of await fs.readdir(dir)) {
-      if (ignoredDirs.has(entry)) continue;
+      if (defaultIgnoredDirs.has(entry)) continue;
       const full = path.join(dir, entry);
       const stat = await fs.stat(full);
       if (!stat.isDirectory()) continue;
+      if (isIgnoredPath(root, full, ignorePatterns)) continue;
       if ((await fs.pathExists(path.join(full, "SKILL.md"))) || (await fs.pathExists(path.join(full, ".codex-plugin", "plugin.json")))) {
         found.add(full);
         continue;