@intentius/chant 0.0.5 → 0.0.9

package/bin/chant

@@ -0,0 +1,20 @@
+#!/bin/sh
+# Cross-runtime CLI wrapper. Tries bun first, falls back to npx tsx.
+set -e
+
+# Resolve symlinks to find the real script location
+SELF="$0"
+while [ -L "$SELF" ]; do
+  DIR="$(cd "$(dirname "$SELF")" && pwd)"
+  SELF="$(readlink "$SELF")"
+  # Handle relative symlink targets
+  case "$SELF" in /*) ;; *) SELF="$DIR/$SELF" ;; esac
+done
+SCRIPT_DIR="$(cd "$(dirname "$SELF")" && pwd)"
+MAIN_TS="$SCRIPT_DIR/../src/cli/main.ts"
+
+if command -v bun >/dev/null 2>&1; then
+  exec bun "$MAIN_TS" "$@"
+else
+  exec npx tsx "$MAIN_TS" "$@"
+fi

package/package.json

@@ -1,23 +1,24 @@
 {
   "name": "@intentius/chant",
-  "version": "0.0.5",
+  "version": "0.0.9",
   "license": "Apache-2.0",
   "type": "module",
-  "files": ["src/"],
+  "files": ["src/", "bin/"],
   "publishConfig": {
-  "access": "public"
-},
-"bin": {
-  "chant": "./src/cli/main.ts"
-},
-"exports": {
-  ".": "./src/index.ts",
-  "./cli": "./src/cli/index.ts",
-  "./cli/*": "./src/cli/*",
-  "./*": "./src/*"
-},
-"dependencies": {
-  "fflate": "^0.8.2",
-  "zod": "^4.3.6"
-}
+    "access": "public"
+  },
+  "bin": {
+    "chant": "./bin/chant"
+  },
+  "exports": {
+    ".": "./src/index.ts",
+    "./cli": "./src/cli/index.ts",
+    "./cli/*": "./src/cli/*",
+    "./*": "./src/*"
+  },
+  "dependencies": {
+    "fflate": "^0.8.2",
+    "picomatch": "^4.0.3",
+    "zod": "^4.3.6"
+  }
 }

package/src/bench.test.ts

@@ -131,7 +131,7 @@ describe("performance benchmarks", () => {
     for (const size of sizes) {
       await withTestDir(async (dir) => {
         const files = await generateFixture(dir, size);
-        const { avg } = await benchmark(() => runLint(files, coreRules), 3);
+        const { avg } = await benchmark(() => runLint(files, coreRules).then(r => r.diagnostics), 3);
         output.push(`  ${pad(size.name, 10)} ${fmt(avg)} (avg of 3 runs)`);
       });
     }

package/src/cli/commands/__fixtures__/init-lexicon-output/src/plugin.ts

@@ -42,31 +42,6 @@ export const fixturePlugin: LexiconPlugin = {
     console.error(`Packaged ${stats.resources} resources, ${stats.ruleCount} rules, ${stats.skillCount} skills`);
   },
 
-  async rollback(options?: { restore?: string; verbose?: boolean }): Promise<void> {
-    const { listSnapshots, restoreSnapshot } = await import("./codegen/rollback");
-    const { join, dirname } = await import("path");
-    const { fileURLToPath } = await import("url");
-
-    const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
-    const snapshotsDir = join(pkgDir, ".snapshots");
-
-    if (options?.restore) {
-      const generatedDir = join(pkgDir, "src", "generated");
-      restoreSnapshot(String(options.restore), generatedDir);
-      console.error(`Restored snapshot: ${options.restore}`);
-    } else {
-      const snapshots = listSnapshots(snapshotsDir);
-      if (snapshots.length === 0) {
-        console.error("No snapshots available.");
-      } else {
-        console.error(`Available snapshots (${snapshots.length}):`);
-        for (const s of snapshots) {
-          console.error(`  ${s.timestamp}  ${s.resources} resources  ${s.path}`);
-        }
-      }
-    }
-  },
-
   // ── Optional extensions (uncomment and implement as needed) ───
 
   // lintRules(): LintRule[] {

package/src/cli/commands/__snapshots__/init-lexicon.test.ts.snap

@@ -152,31 +152,6 @@ export const fixturePlugin: LexiconPlugin = {
     console.error(\`Packaged \${stats.resources} resources, \${stats.ruleCount} rules, \${stats.skillCount} skills\`);
   },
 
-  async rollback(options?: { restore?: string; verbose?: boolean }): Promise<void> {
-    const { listSnapshots, restoreSnapshot } = await import("./codegen/rollback");
-    const { join, dirname } = await import("path");
-    const { fileURLToPath } = await import("url");
-
-    const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
-    const snapshotsDir = join(pkgDir, ".snapshots");
-
-    if (options?.restore) {
-      const generatedDir = join(pkgDir, "src", "generated");
-      restoreSnapshot(String(options.restore), generatedDir);
-      console.error(\`Restored snapshot: \${options.restore}\`);
-    } else {
-      const snapshots = listSnapshots(snapshotsDir);
-      if (snapshots.length === 0) {
-        console.error("No snapshots available.");
-      } else {
-        console.error(\`Available snapshots (\${snapshots.length}):\`);
-        for (const s of snapshots) {
-          console.error(\`  \${s.timestamp}  \${s.resources} resources  \${s.path}\`);
-        }
-      }
-    }
-  },
-
   // ── Optional extensions (uncomment and implement as needed) ───
 
   // lintRules(): LintRule[] {

package/src/cli/commands/build.ts

@@ -5,7 +5,7 @@ import { runPostSynthChecks } from "../../lint/post-synth";
 import type { PostSynthCheck } from "../../lint/post-synth";
 import { formatError, formatWarning, formatSuccess, formatBold, formatInfo } from "../format";
 import { writeFileSync } from "fs";
-import { resolve } from "path";
+import { resolve, dirname, join } from "path";
 import { watchDirectory, formatTimestamp, formatChangedFiles } from "../watch";
 
 /**
@@ -172,7 +172,6 @@ export async function buildCommand(options: BuildOptions): Promise<BuildResult>
 
         // Write additional files (e.g. nested stack templates) alongside the primary output
         if (additionalFiles.size > 0) {
-          const { dirname, join } = require("path");
           const outputDir = dirname(outputPath);
           for (const [filename, content] of additionalFiles) {
             let fileContent = content;

package/src/cli/commands/doctor.ts

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, readdirSync } from "fs";
 import { execSync } from "child_process";
-import { join, resolve } from "path";
+import { join, resolve, dirname } from "path";
+import { fileURLToPath } from "url";
 import { checkVersionCompatibility } from "../../lexicon-manifest";
 import { debug } from "../debug";
 import { loadPlugins, resolveProjectLexicons } from "../plugins";
@@ -109,8 +110,12 @@ export async function doctorCommand(path: string): Promise<DoctorReport> {
         try {
           const manifest = JSON.parse(readFileSync(manifestPath, "utf-8"));
           if (manifest.chantVersion) {
-            // Use a placeholder current version for now
-            const currentVersion = "0.1.0";
+            let currentVersion = "0.0.8";
+            try {
+              const pkgDir = dirname(dirname(dirname(dirname(dirname(fileURLToPath(import.meta.url))))));
+              const corePkg = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf-8"));
+              currentVersion = corePkg.version ?? currentVersion;
+            } catch { /* fallback */ }
             if (!checkVersionCompatibility(manifest.chantVersion, currentVersion)) {
               checks.push({ name: `lexicon-${lex}-compat`, status: "warn", message: `Lexicon ${lex} requires chant ${manifest.chantVersion}` });
             } else {

package/src/cli/commands/import.ts

@@ -1,4 +1,4 @@
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from "fs";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, readdirSync } from "fs";
 import { join, resolve, basename } from "path";
 import { formatSuccess, formatWarning, formatError } from "../format";
 import type { TemplateIR, ResourceIR, TemplateParser } from "../../import/parser";
@@ -266,7 +266,7 @@ export async function importCommand(options: ImportOptions): Promise<ImportResul
 
   // Check output directory
   if (existsSync(outputDir) && !options.force) {
-    const files = require("fs").readdirSync(outputDir);
+    const files = readdirSync(outputDir);
     if (files.length > 0) {
       warnings.push(`Output directory ${outputDir} is not empty. Use --force to overwrite.`);
     }

package/src/cli/commands/init-lexicon.test.ts

@@ -40,7 +40,6 @@ describe("initLexiconCommand", () => {
       "src/codegen/generate-cli.ts",
       "src/codegen/naming.ts",
       "src/codegen/package.ts",
-      "src/codegen/rollback.ts",
       "src/codegen/docs.ts",
       "src/spec/fetch.ts",
       "src/spec/parse.ts",
@@ -65,7 +64,6 @@ describe("initLexiconCommand", () => {
       "docs/src/content/docs/index.mdx",
       "src/generated/.gitkeep",
       "examples/getting-started/.gitkeep",
-      ".snapshots/.gitkeep",
     ];
 
     for (const file of expectedFiles) {
@@ -83,7 +81,6 @@ describe("initLexiconCommand", () => {
     expect(pluginContent).toContain("async validate(");
     expect(pluginContent).toContain("async coverage(");
     expect(pluginContent).toContain("async package(");
-    expect(pluginContent).toContain("async rollback(");
   });
 
   test("package name uses the provided lexicon name", async () => {

package/src/cli/commands/init-lexicon.ts

@@ -106,31 +106,6 @@ export const ${names.pluginVarName}: LexiconPlugin = {
     console.error(\`Packaged \${stats.resources} resources, \${stats.ruleCount} rules, \${stats.skillCount} skills\`);
   },
 
-  async rollback(options?: { restore?: string; verbose?: boolean }): Promise<void> {
-    const { listSnapshots, restoreSnapshot } = await import("./codegen/rollback");
-    const { join, dirname } = await import("path");
-    const { fileURLToPath } = await import("url");
-
-    const pkgDir = dirname(dirname(fileURLToPath(import.meta.url)));
-    const snapshotsDir = join(pkgDir, ".snapshots");
-
-    if (options?.restore) {
-      const generatedDir = join(pkgDir, "src", "generated");
-      restoreSnapshot(String(options.restore), generatedDir);
-      console.error(\`Restored snapshot: \${options.restore}\`);
-    } else {
-      const snapshots = listSnapshots(snapshotsDir);
-      if (snapshots.length === 0) {
-        console.error("No snapshots available.");
-      } else {
-        console.error(\`Available snapshots (\${snapshots.length}):\`);
-        for (const s of snapshots) {
-          console.error(\`  \${s.timestamp}  \${s.resources} resources  \${s.path}\`);
-        }
-      }
-    }
-  },
-
   // ── Optional extensions (uncomment and implement as needed) ───
 
   // lintRules(): LintRule[] {
@@ -382,55 +357,6 @@ export async function packageLexicon(options?: { verbose?: boolean; force?: bool
 `;
 }
 
-function generateCodegenRollbackTs(): string {
-  return `import { existsSync, readdirSync, readFileSync, mkdirSync, writeFileSync, cpSync } from "fs";
-import { join, basename } from "path";
-
-export interface Snapshot {
-  timestamp: string;
-  resources: number;
-  path: string;
-}
-
-/**
- * List available generation snapshots.
- */
-export function listSnapshots(snapshotsDir: string): Snapshot[] {
-  if (!existsSync(snapshotsDir)) return [];
-
-  return readdirSync(snapshotsDir)
-    .filter((d) => !d.startsWith("."))
-    .sort()
-    .reverse()
-    .map((dir) => {
-      const fullPath = join(snapshotsDir, dir);
-      const metaPath = join(fullPath, "meta.json");
-      let resources = 0;
-      if (existsSync(metaPath)) {
-        try {
-          const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
-          resources = meta.resources ?? 0;
-        } catch {}
-      }
-      return { timestamp: dir, resources, path: fullPath };
-    });
-}
-
-/**
- * Restore a snapshot to the generated directory.
- */
-export function restoreSnapshot(timestamp: string, generatedDir: string): void {
-  const snapshotsDir = join(generatedDir, "..", "..", ".snapshots");
-  const snapshotDir = join(snapshotsDir, timestamp);
-  if (!existsSync(snapshotDir)) {
-    throw new Error(\`Snapshot not found: \${timestamp}\`);
-  }
-  mkdirSync(generatedDir, { recursive: true });
-  cpSync(snapshotDir, generatedDir, { recursive: true });
-}
-`;
-}
-
 function generateCodegenDocsTs(name: string): string {
   return `import { docsPipeline, writeDocsSite } from "@intentius/chant/codegen/docs";
 
@@ -735,8 +661,7 @@ package: generate validate
 }
 
 function generateGitignore(): string {
-  return `.snapshots/
-dist/
+  return `dist/
 node_modules/
 .cache/
 `;
@@ -899,7 +824,6 @@ export async function initLexiconCommand(options: InitLexiconOptions): Promise<I
     "docs/src/content",
     "docs/src/content/docs",
     "examples/getting-started",
-    ".snapshots",
   ];
 
   for (const dir of dirs) {
@@ -918,7 +842,6 @@ export async function initLexiconCommand(options: InitLexiconOptions): Promise<I
     "src/codegen/generate-cli.ts": generateCodegenGenerateCliTs(),
     "src/codegen/naming.ts": generateCodegenNamingTs(),
     "src/codegen/package.ts": generateCodegenPackageTs(name),
-    "src/codegen/rollback.ts": generateCodegenRollbackTs(),
     "src/codegen/docs.ts": generateCodegenDocsTs(name),
     "src/spec/fetch.ts": generateSpecFetchTs(),
     "src/spec/parse.ts": generateSpecParseTs(),
@@ -947,7 +870,6 @@ export async function initLexiconCommand(options: InitLexiconOptions): Promise<I
   const gitkeeps = [
     "src/generated/.gitkeep",
     "examples/getting-started/.gitkeep",
-    ".snapshots/.gitkeep",
   ];
 
   for (const gk of gitkeeps) {

package/src/cli/commands/init.test.ts

@@ -176,7 +176,7 @@ describe("initCommand", () => {
     });
   });
 
-  test("does not generate barrel file", async () => {
+  test("does not generate re-export file", async () => {
     await withTestDir(async (testDir) => {
       const options: InitOptions = {
         path: testDir,
@@ -187,9 +187,9 @@ describe("initCommand", () => {
 
       await initCommand(options);
 
-      // No _.ts barrel — direct imports are used instead
-      const barrelPath = join(testDir, "src", "_.ts");
-      expect(existsSync(barrelPath)).toBe(false);
+      // No _.ts re-export — direct imports are used instead
+      const reexportPath = join(testDir, "src", "_.ts");
+      expect(existsSync(reexportPath)).toBe(false);
 
       // No index.ts either
       const indexPath = join(testDir, "src", "index.ts");
@@ -309,5 +309,45 @@ describe("initCommand", () => {
       expect(existsSync(newDir)).toBe(true);
     });
   });
+
+  test("gitlab init creates src files", async () => {
+    await withTestDir(async (testDir) => {
+      const options: InitOptions = {
+        path: testDir,
+        lexicon: "gitlab",
+        skipMcp: true,
+        skipInstall: true,
+      };
+
+      const result = await initCommand(options);
+
+      expect(result.success).toBe(true);
+      expect(result.createdFiles).toContain("src/config.ts");
+      expect(result.createdFiles).toContain("src/pipeline.ts");
+
+      const pkg = JSON.parse(readFileSync(join(testDir, "package.json"), "utf-8"));
+      expect(pkg.scripts.build).toContain("gitlab");
+    });
+  });
+
+  test("gitlab init with --template passes template to plugin", async () => {
+    await withTestDir(async (testDir) => {
+      const options: InitOptions = {
+        path: testDir,
+        lexicon: "gitlab",
+        template: "node-pipeline",
+        skipMcp: true,
+        skipInstall: true,
+      };
+
+      const result = await initCommand(options);
+
+      expect(result.success).toBe(true);
+      expect(result.createdFiles).toContain("src/pipeline.ts");
+
+      const pipeline = readFileSync(join(testDir, "src", "pipeline.ts"), "utf-8");
+      expect(pipeline).toContain("NodePipeline");
+    });
+  });
 });
 

package/src/cli/commands/init.ts

@@ -1,11 +1,23 @@
 import { existsSync, mkdirSync, writeFileSync, readdirSync, readFileSync } from "fs";
-import { join, resolve } from "path";
+import { join, resolve, dirname } from "path";
+import { fileURLToPath } from "url";
 import { homedir } from "os";
 import { createInterface } from "readline";
 import { z } from "zod";
 import { formatSuccess, formatWarning } from "../format";
 import { loadPlugin } from "../plugins";
 
+/** Read the current chant package version from our own package.json. */
+function getChantVersion(): string {
+  try {
+    const pkgDir = dirname(dirname(dirname(dirname(dirname(fileURLToPath(import.meta.url))))));
+    const pkg = JSON.parse(readFileSync(join(pkgDir, "package.json"), "utf-8"));
+    return pkg.version ?? "0.0.8";
+  } catch {
+    return "0.0.8";
+  }
+}
+
 /**
  * Schema for validating generated package.json — catches template bugs early.
  */
@@ -25,6 +37,8 @@ export interface InitOptions {
   path?: string;
   /** Lexicon to use */
   lexicon: string;
+  /** Template name (e.g. "node-pipeline", "docker-build") */
+  template?: string;
   /** Force init even in non-empty directory */
   force?: boolean;
   /** Skip MCP config generation */
@@ -81,20 +95,22 @@ function getMcpConfigDir(ide: "claude-code" | "cursor" | "generic"): string {
 /**
  * Generate package.json content
  */
-function generatePackageJson(lexicon: string): string {
+function generatePackageJson(lexicon: string, extraScripts?: Record<string, string>): string {
+  const ver = getChantVersion();
   const dependencies: Record<string, string> = {
-    "@intentius/chant": "^0.1.0",
-    [`@intentius/chant-lexicon-${lexicon}`]: "^0.1.0",
+    "@intentius/chant": `^${ver}`,
+    [`@intentius/chant-lexicon-${lexicon}`]: `^${ver}`,
   };
 
   const pkg = {
     name: "chant-project",
-    version: "0.1.0",
+    version: ver,
     type: "module" as const,
     scripts: {
       build: `chant build src --lexicon ${lexicon}`,
       lint: "chant lint src",
       dev: `chant build src --lexicon ${lexicon} --watch`,
+      ...extraScripts,
     },
     dependencies,
     devDependencies: {
@@ -301,6 +317,17 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
     mkdirSync(targetDir, { recursive: true });
   }
 
+  // Load plugin early to get template set (used for scripts + source files)
+  let templateSet: import("../../lexicon").InitTemplateSet | undefined;
+  try {
+    const plugin = await loadPlugin(options.lexicon);
+    if (plugin.initTemplates) {
+      templateSet = plugin.initTemplates(options.template);
+    }
+  } catch {
+    // Plugin not yet installed — no source files to scaffold
+  }
+
   // Create src directory
   const srcDir = join(targetDir, "src");
   if (!existsSync(srcDir)) {
@@ -310,7 +337,7 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
   // Generate package.json
   writeIfNotExists(
     join(targetDir, "package.json"),
-    generatePackageJson(options.lexicon),
+    generatePackageJson(options.lexicon, templateSet?.scripts),
     "package.json",
     createdFiles,
     warnings,
@@ -343,24 +370,29 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
     warnings,
   );
 
-  // Generate source files from plugin (if available)
-  let sourceFiles: Record<string, string> = {};
-  try {
-    const plugin = await loadPlugin(options.lexicon);
-    if (plugin.initTemplates) {
-      sourceFiles = plugin.initTemplates();
+  // Write source files from plugin template set
+  if (templateSet) {
+    for (const [filename, content] of Object.entries(templateSet.src)) {
+      writeIfNotExists(
+        join(srcDir, filename),
+        content,
+        `src/${filename}`,
+        createdFiles,
+        warnings,
+      );
+    }
+    // Write root scaffold files (e.g. index.js, test.js, Dockerfile)
+    if (templateSet.root) {
+      for (const [filename, content] of Object.entries(templateSet.root)) {
+        writeIfNotExists(
+          join(targetDir, filename),
+          content,
+          filename,
+          createdFiles,
+          warnings,
+        );
+      }
     }
-  } catch {
-    // Plugin not yet installed — no source files to scaffold
-  }
-  for (const [filename, content] of Object.entries(sourceFiles)) {
-    writeIfNotExists(
-      join(srcDir, filename),
-      content,
-      `src/${filename}`,
-      createdFiles,
-      warnings,
-    );
   }
 
   // Scaffold .chant/types/core/ with embedded type definitions
@@ -426,18 +458,29 @@ export async function initCommand(options: InitOptions): Promise<InitResult> {
   }
 
   // Install skills from the lexicon's plugin
+  // Write to both .chant/skills/ (chant's own location) and .claude/skills/ (Claude Code discovery)
   try {
     const plugin = await loadPlugin(options.lexicon);
     if (plugin.skills) {
       const skills = plugin.skills();
       if (skills.length > 0) {
-        const skillsDir = join(targetDir, ".chant", "skills", options.lexicon);
-        mkdirSync(skillsDir, { recursive: true });
+        // .chant/skills/ — chant's own skill storage
+        const chantSkillsDir = join(targetDir, ".chant", "skills", options.lexicon);
+        mkdirSync(chantSkillsDir, { recursive: true });
         for (const skill of skills) {
-          const skillPath = join(skillsDir, `${skill.name}.md`);
+          const skillPath = join(chantSkillsDir, `${skill.name}.md`);
           writeFileSync(skillPath, skill.content);
           createdFiles.push(`.chant/skills/${options.lexicon}/${skill.name}.md`);
         }
+
+        // .claude/skills/ — Claude Code skill discovery format
+        for (const skill of skills) {
+          const claudeSkillDir = join(targetDir, ".claude", "skills", skill.name);
+          mkdirSync(claudeSkillDir, { recursive: true });
+          const claudeSkillPath = join(claudeSkillDir, "SKILL.md");
+          writeFileSync(claudeSkillPath, skill.content);
+          createdFiles.push(`.claude/skills/${skill.name}/SKILL.md`);
+        }
       }
     }
   } catch {

package/src/cli/commands/lint.ts

@@ -243,19 +243,25 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
 
   // Run lint — use per-file rules when overrides are present
   let diagnostics: LintDiagnostic[];
+  let suppressed: Array<LintDiagnostic & { reason?: string }> = [];
   if (options.rules) {
-    diagnostics = await runLint(files, options.rules, undefined);
+    const result = await runLint(files, options.rules, undefined);
+    diagnostics = result.diagnostics;
+    suppressed = result.suppressed;
   } else if (hasOverrides) {
     diagnostics = [];
     for (const file of files) {
       const relativePath = file.slice(infraPath.length + 1);
       const { rules: fileRules, ruleOptions } = getDefaultRules(infraPath, relativePath, allRules);
-      const fileDiagnostics = await runLint([file], fileRules, ruleOptions);
-      diagnostics.push(...fileDiagnostics);
+      const result = await runLint([file], fileRules, ruleOptions);
+      diagnostics.push(...result.diagnostics);
+      suppressed.push(...result.suppressed);
     }
   } else {
     const { rules, ruleOptions } = getDefaultRules(infraPath, undefined, allRules);
-    diagnostics = await runLint(files, rules, ruleOptions);
+    const result = await runLint(files, rules, ruleOptions);
+    diagnostics = result.diagnostics;
+    suppressed = result.suppressed;
   }
 
   // Apply fixes if requested
@@ -277,23 +283,26 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
     }
 
     // Re-lint after fixes to get updated diagnostics
-    let postFixDiagnostics: LintDiagnostic[];
     if (options.rules) {
-      postFixDiagnostics = await runLint(files, options.rules, undefined);
+      const postResult = await runLint(files, options.rules, undefined);
+      diagnostics = postResult.diagnostics;
+      suppressed = postResult.suppressed;
     } else if (hasOverrides) {
-      postFixDiagnostics = [];
+      diagnostics = [];
+      suppressed = [];
       for (const file of files) {
         const relativePath = file.slice(infraPath.length + 1);
         const { rules: fileRules, ruleOptions } = getDefaultRules(infraPath, relativePath, allRules);
-        const fileDiagnostics = await runLint([file], fileRules, ruleOptions);
-        postFixDiagnostics.push(...fileDiagnostics);
+        const postResult = await runLint([file], fileRules, ruleOptions);
+        diagnostics.push(...postResult.diagnostics);
+        suppressed.push(...postResult.suppressed);
       }
     } else {
       const { rules, ruleOptions } = getDefaultRules(infraPath, undefined, allRules);
-      postFixDiagnostics = await runLint(files, rules, ruleOptions);
+      const postResult = await runLint(files, rules, ruleOptions);
+      diagnostics = postResult.diagnostics;
+      suppressed = postResult.suppressed;
     }
-    diagnostics.length = 0;
-    diagnostics.push(...postFixDiagnostics);
   }
 
   // Count errors and warnings
@@ -308,6 +317,11 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
     }
   }
 
+  // Collect all loaded rules for SARIF enrichment
+  const allLoadedRules = options.rules
+    ? options.rules
+    : [...allRules.values()];
+
   // Format output
   let output: string;
   switch (options.format) {
@@ -315,7 +329,7 @@ export async function lintCommand(options: LintOptions): Promise<LintResult> {
       output = formatJson(diagnostics);
       break;
     case "sarif":
-      output = formatSarif(diagnostics);
+      output = formatSarif(diagnostics, allLoadedRules, suppressed);
       break;
     case "stylish":
     default:

package/src/cli/commands/list.ts

@@ -51,8 +51,8 @@ export async function listCommand(options: ListOptions): Promise<ListResult> {
   for (const [name, decl] of result.entities) {
     entities.push({
       name,
-      lexicon: decl.lexicon,
-      entityType: decl.entityType,
+      lexicon: decl.lexicon ?? "",
+      entityType: decl.entityType ?? "",
       kind: decl.kind ?? "resource",
     });
   }