@konvert7/klint 0.7.1 → 0.8.0

package/core/arch.ts

@@ -78,7 +78,9 @@ function resolveLayerPrefixes(
   layers: Record<string, string[]> | undefined,
   root: string
 ): string[] {
-  return resolveGlobs(ref, layers).map((g) => globToPrefix(g, root));
+  return resolveGlobs(ref, layers)
+    .filter((g) => !g.startsWith("!"))
+    .map((g) => globToPrefix(g, root));
 }
 
 function resolveLayerFiles(
@@ -87,8 +89,18 @@ function resolveLayerFiles(
   root: string,
   allFiles: string[]
 ): string[] {
-  const prefixes = resolveLayerPrefixes(ref, layers, root);
-  return allFiles.filter((f) => prefixes.some((p) => f === p || f.startsWith(`${p}/`)));
+  const globs = resolveGlobs(ref, layers);
+  const includePrefixes = globs
+    .filter((g) => !g.startsWith("!"))
+    .map((g) => globToPrefix(g, root));
+  const excludePrefixes = globs
+    .filter((g) => g.startsWith("!"))
+    .map((g) => globToPrefix(g.slice(1), root));
+  return allFiles.filter(
+    (f) =>
+      includePrefixes.some((p) => f === p || f.startsWith(`${p}/`)) &&
+      !excludePrefixes.some((p) => f === p || f.startsWith(`${p}/`))
+  );
 }
 
 function inPrefixes(absPath: string, prefixes: string[]): boolean {
@@ -196,16 +208,29 @@ export function runArchRules(
   for (const rule of arch.forbidden ?? []) {
     const severity: Severity = rule.severity ?? "error";
     const inFiles = resolveLayerFiles(rule.in, layers, root, allFiles);
-    scanLinesForPattern(
-      inFiles,
-      rule.pattern,
-      fileContents,
-      root,
-      "arch/forbidden",
-      rule.message,
-      severity,
-      violations
-    );
+    if ("jsx-element" in rule) {
+      scanJsxElements(
+        inFiles,
+        toArray(rule["jsx-element"]),
+        fileContents,
+        root,
+        "arch/forbidden",
+        rule.message,
+        severity,
+        violations
+      );
+    } else {
+      scanLinesForPattern(
+        inFiles,
+        rule.pattern,
+        fileContents,
+        root,
+        "arch/forbidden",
+        rule.message,
+        severity,
+        violations
+      );
+    }
   }
 
   for (const rule of arch.singleton ?? []) {
@@ -215,21 +240,70 @@ export function runArchRules(
       ? resolveLayerFiles(rule.in, layers, root, allFiles)
       : allFiles;
     const scope = inFiles.filter((f) => f !== onlyFile);
-    scanLinesForPattern(
-      scope,
-      rule.pattern,
-      fileContents,
-      root,
-      "arch/singleton",
-      rule.message,
-      severity,
-      violations
-    );
+    if ("jsx-element" in rule) {
+      scanJsxElements(
+        scope,
+        toArray(rule["jsx-element"]),
+        fileContents,
+        root,
+        "arch/singleton",
+        rule.message,
+        severity,
+        violations
+      );
+    } else {
+      scanLinesForPattern(
+        scope,
+        rule.pattern,
+        fileContents,
+        root,
+        "arch/singleton",
+        rule.message,
+        severity,
+        violations
+      );
+    }
   }
 
   return violations;
 }
 
+function toArray<T>(v: T | T[]): T[] {
+  return Array.isArray(v) ? v : [v];
+}
+
+function scanJsxElements(
+  files: string[],
+  tagNames: string[],
+  fileContents: Map<string, string>,
+  root: string,
+  ruleName: string,
+  message: string,
+  severity: Severity,
+  violations: Violation[]
+): void {
+  const targets = new Set(tagNames);
+  for (const file of files) {
+    if (!/\.(tsx|jsx)$/.test(file)) continue;
+    const content = fileContents.get(file);
+    if (!content) continue;
+    walkAst(file, content, (node, src) => {
+      if (!ts.isJsxOpeningElement(node) && !ts.isJsxSelfClosingElement(node)) return;
+      const tagName = node.tagName;
+      if (!ts.isIdentifier(tagName)) return;
+      if (!targets.has(tagName.text)) return;
+      const { line } = src.getLineAndCharacterOfPosition(tagName.getStart());
+      violations.push({
+        file: relative(root, file).replaceAll("\\", "/"),
+        line: line + 1,
+        message,
+        rule: ruleName,
+        severity,
+      });
+    });
+  }
+}
+
 function scanLinesForPattern(
   files: string[],
   pattern: string,

package/core/config.schema.ts

@@ -110,7 +110,7 @@ const ArchImportRuleSchema = z
     ],
   });
 
-const ArchForbiddenRuleSchema = z
+const ArchForbiddenPatternRuleSchema = z
   .object({
     pattern: z
       .string()
@@ -127,17 +127,38 @@ const ArchForbiddenRuleSchema = z
       ),
     severity: ArchSeveritySchema.optional(),
   })
-  .strict()
+  .strict();
+
+const ArchForbiddenJsxRuleSchema = z
+  .object({
+    "jsx-element": StringOrStringArray.describe(
+      "JSX intrinsic element name(s) to forbid (e.g. `button`, `input`, `label`). AST-matched on opening and self-closing tag names — robust to whitespace, attributes, and naming collisions like `<buttonGroup>`."
+    ),
+    in: StringOrStringArray.describe(
+      "Layer name(s) or glob(s) the element is forbidden in. Files outside the scope are not checked."
+    ),
+    message: z
+      .string()
+      .describe(
+        "Required error message explaining why the raw element is forbidden. Typically points at the design-system replacement (e.g. `Use <Button /> from @/components/ui/button`)."
+      ),
+    severity: ArchSeveritySchema.optional(),
+  })
+  .strict();
+
+const ArchForbiddenRuleSchema = z
+  .union([ArchForbiddenPatternRuleSchema, ArchForbiddenJsxRuleSchema])
   .describe(
-    "A forbidden-pattern rule. Blocks literal substrings (console.log, process.exit, raw SDK fetches, etc.) inside specific layers."
+    "A forbidden-pattern rule. Blocks either a literal substring (`pattern:`) or a JSX element (`jsx-element:`) inside specific layers."
   )
   .meta({
     examples: [
       'arch:\n  forbidden:\n    - pattern: "console.log("\n      in: core\n      message: "Leaks into the agent event stream"',
+      'arch:\n  forbidden:\n    - jsx-element: ["button", "input", "label"]\n      in: ["src/app/**/*.tsx", "src/components/**/*.tsx", "!src/components/ui/**"]\n      message: "Use the design-system primitives in @/components/ui/* instead of raw HTML elements."',
     ],
   });
 
-const ArchSingletonRuleSchema = z
+const ArchSingletonPatternRuleSchema = z
   .object({
     pattern: z
       .string()
@@ -152,20 +173,36 @@ const ArchSingletonRuleSchema = z
     in: StringOrStringArray.optional().describe(
       "Optional scope. Limit the scan to these layers/globs; defaults to all files in `include`."
     ),
-    message: z
+    message: z.string(),
+    severity: ArchSeveritySchema.optional(),
+  })
+  .strict();
+
+const ArchSingletonJsxRuleSchema = z
+  .object({
+    "jsx-element": StringOrStringArray.describe(
+      "JSX intrinsic element name(s) allowed only inside the `only` file. AST-matched on tag names."
+    ),
+    only: z
       .string()
       .describe(
-        "Required error message explaining why the pattern must stay singleton (security boundary, module-of-record, etc.)."
+        "The single file path where the element is allowed (typically the design-system primitive that wraps it)."
       ),
+    in: StringOrStringArray.optional(),
+    message: z.string(),
     severity: ArchSeveritySchema.optional(),
   })
-  .strict()
+  .strict();
+
+const ArchSingletonRuleSchema = z
+  .union([ArchSingletonPatternRuleSchema, ArchSingletonJsxRuleSchema])
   .describe(
-    "A singleton-location rule. Pins a pattern to exactly one file — the only honest way to enforce a module of record."
+    "A singleton-location rule. Pins a pattern or JSX element to exactly one file — the only honest way to enforce a module of record or a design-system primitive."
   )
   .meta({
     examples: [
       'arch:\n  singleton:\n    - pattern: "process.env.API_KEY"\n      only: "src/lib/auth.ts"\n      message: "API key access must funnel through the auth module."',
+      'arch:\n  singleton:\n    - jsx-element: "button"\n      only: "src/components/ui/button.tsx"\n      in: ["src/**/*.tsx"]\n      message: "Raw <button> belongs only to the Button primitive."',
     ],
   });
 

package/core/runner.ts

@@ -17,7 +17,8 @@ function walk(dir: string): string[] {
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
     const full = join(dir, entry.name);
     if (entry.isDirectory()) out.push(...walk(full));
-    else if (entry.name.endsWith(".ts")) out.push(full.replaceAll("\\", "/"));
+    else if (/\.(tsx?|jsx?|mts|cts)$/.test(entry.name))
+      out.push(full.replaceAll("\\", "/"));
   }
   return out;
 }

package/core/types.ts

@@ -63,15 +63,23 @@ interface ArchImportRule {
   severity?: Exclude<Severity, "off">;
 }
 
-interface ArchForbiddenRule {
-  pattern: string;
+interface ArchForbiddenRuleBase {
   in: string | string[];
   message: string;
   severity?: Exclude<Severity, "off">;
 }
 
-interface ArchSingletonRule {
+interface ArchForbiddenPatternRule extends ArchForbiddenRuleBase {
   pattern: string;
+}
+
+interface ArchForbiddenJsxRule extends ArchForbiddenRuleBase {
+  "jsx-element": string | string[];
+}
+
+type ArchForbiddenRule = ArchForbiddenPatternRule | ArchForbiddenJsxRule;
+
+interface ArchSingletonRuleBase {
   only: string;
   message: string;
   /** Limit scan to these files/layers. Defaults to all files. */
@@ -79,6 +87,16 @@ interface ArchSingletonRule {
   severity?: Exclude<Severity, "off">;
 }
 
+interface ArchSingletonPatternRule extends ArchSingletonRuleBase {
+  pattern: string;
+}
+
+interface ArchSingletonJsxRule extends ArchSingletonRuleBase {
+  "jsx-element": string | string[];
+}
+
+type ArchSingletonRule = ArchSingletonPatternRule | ArchSingletonJsxRule;
+
 export interface ArchConfig {
   layers?: Record<string, string[]>;
   imports?: ArchImportRule[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konvert7/klint",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Architecture-as-Code linter for TypeScript. Enforce layer boundaries, import rules, and singleton patterns in YAML.",
   "type": "module",
   "bin": {