@intentius/chant 0.0.8 → 0.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "license": "Apache-2.0",
   "type": "module",
   "files": ["src/", "bin/"],

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/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/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

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/handlers/init.ts

@@ -16,6 +16,7 @@ export async function runInit(ctx: CommandContext): Promise<number> {
   const result = await initCommand({
     path: args.path === "." ? undefined : args.path,
     lexicon: args.lexicon,
+    template: args.template,
     force: args.force,
     skipInstall: true,
   });

package/src/cli/lsp/server.ts

@@ -362,7 +362,7 @@ export class LspServer {
 
       if (rules.length === 0) return [];
 
-      const diagnostics = await runLint([filePath], rules);
+      const { diagnostics } = await runLint([filePath], rules);
       return toLspDiagnostics(diagnostics);
     } catch {
       return [];

package/src/cli/main.ts

@@ -27,6 +27,7 @@ export function parseArgs(args: string[]): ParsedArgs {
     force: undefined,
     fix: false,
     lexicon: undefined,
+    template: undefined,
     watch: false,
     verbose: false,
     help: false,
@@ -44,6 +45,8 @@ export function parseArgs(args: string[]): ParsedArgs {
       result.format = args[++i];
     } else if (arg === "--lexicon" || arg === "-d") {
       result.lexicon = args[++i];
+    } else if (arg === "--template" || arg === "-t") {
+      result.template = args[++i];
     } else if (arg === "--force") {
       result.force = true;
     } else if (arg === "--fix") {
@@ -107,6 +110,7 @@ Options:
                         - list: text (default) or json
                         - lint: stylish (default), json, or sarif
   -d, --lexicon <name>  Build only the specified lexicon (e.g. aws, gitlab)
+  -t, --template <name> Init template (e.g. node-pipeline, docker-build)
   --fix                 Auto-fix fixable issues (lint command)
   --force               Force overwrite existing files (import command)
   -w, --watch           Watch for changes and rebuild/re-lint (build, lint)

package/src/cli/mcp/server.test.ts

@@ -378,10 +378,10 @@ describe("McpServer", () => {
     test("matches plugin init templates", async () => {
       const plugin = createMockPlugin({
         name: "test-lex",
-        initTemplates: () => ({
+        initTemplates: () => ({ src: {
           "config.ts": "export const config = {};",
           "data-bucket.ts": "export const dataBucket = {};",
-        }),
+        } }),
       });
 
       const s = new McpServer([plugin]);
@@ -397,6 +397,32 @@ describe("McpServer", () => {
       expect(parsed.files.length).toBe(1);
       expect(parsed.files[0].filename).toBe("data-bucket.ts");
     });
+
+    test("passes template name to initTemplates", async () => {
+      const plugin = createMockPlugin({
+        name: "test-lex",
+        initTemplates: (template?: string) => {
+          if (template === "special") {
+            return { src: { "special.ts": "export const special = {};" } };
+          }
+          return { src: { "default.ts": "export const def = {};" } };
+        },
+      });
+
+      const s = new McpServer([plugin]);
+      const response = await s.handleRequest({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "tools/call",
+        params: { name: "scaffold", arguments: { pattern: "special", lexicon: "test-lex", template: "special" } },
+      });
+
+      const parsed = JSON.parse((response.result as { content: Array<{ text: string }> }).content[0].text);
+      expect(parsed.lexicon).toBe("test-lex");
+      expect(parsed.template).toBe("special");
+      expect(parsed.files.length).toBe(1);
+      expect(parsed.files[0].filename).toBe("special.ts");
+    });
   });
 
   // -----------------------------------------------------------------------

package/src/cli/mcp/tools/scaffold.ts

@@ -17,6 +17,10 @@ export const scaffoldTool = {
         type: "string",
         description: "Lexicon to use for scaffolding (e.g. 'aws', 'gitlab'). Auto-detected if omitted.",
       },
+      template: {
+        type: "string",
+        description: "Named init template (e.g. 'node-pipeline', 'docker-build'). When provided, returns the template's source files instead of pattern-matching.",
+      },
     },
     required: ["pattern"],
   },
@@ -31,6 +35,7 @@ export function createScaffoldHandler(
   return async (params) => {
     const pattern = params.pattern as string;
     const lexiconName = params.lexicon as string | undefined;
+    const templateName = params.template as string | undefined;
 
     // Try to find a matching plugin
     const candidates = lexiconName
@@ -39,14 +44,27 @@ export function createScaffoldHandler(
 
     // Search plugin init templates for a pattern match
     for (const plugin of candidates) {
-      const templates = plugin.initTemplates?.();
-      if (!templates) continue;
+      const templateSet = plugin.initTemplates?.(templateName);
+      if (!templateSet) continue;
+
+      // If a named template was requested, return all its source files
+      if (templateName) {
+        const files = Object.entries(templateSet.src).map(([filename, content]) => ({ filename, content }));
+        if (files.length > 0) {
+          return {
+            lexicon: plugin.name,
+            pattern,
+            template: templateName,
+            files,
+          };
+        }
+      }
 
       // Match template filenames against the pattern (case-insensitive substring)
       const lowerPattern = pattern.toLowerCase();
       const matched: Array<{ filename: string; content: string }> = [];
 
-      for (const [filename, content] of Object.entries(templates)) {
+      for (const [filename, content] of Object.entries(templateSet.src)) {
         if (filename.toLowerCase().includes(lowerPattern)) {
           matched.push({ filename, content });
         }

package/src/cli/registry.ts

@@ -14,6 +14,7 @@ export interface ParsedArgs {
   force?: boolean;
   fix: boolean;
   lexicon?: string;
+  template?: string;
   watch: boolean;
   verbose: boolean;
   help: boolean;