@konvert7/klint 0.38.0 → 1.0.0

package/core/arch.ts

@@ -1,470 +0,0 @@
-import { dirname, isAbsolute, resolve } from "node:path";
-import ts from "typescript";
-import {
-  commentLineSet,
-  firstCommentBlockOverrun,
-  ignoredCommentLines,
-} from "./arch-comments";
-import { walkAst } from "./ast";
-import { relativeSlashPath, toSlashPath } from "./paths";
-import type { ArchConfig, Severity, Violation } from "./types";
-
-interface AliasEntry {
-  /** The prefix to match (pattern with `/*` stripped, e.g. `"@"` from `"@/*"`). */
-  prefix: string;
-  /** Resolved absolute base directory (target with `/*` stripped). */
-  base: string;
-  isWildcard: boolean;
-}
-
-function loadPathAliases(root: string): AliasEntry[] {
-  const tsconfigPath = resolve(root, "tsconfig.json");
-  const parsed = ts.getParsedCommandLineOfConfigFile(tsconfigPath, undefined, {
-    ...ts.sys,
-    onUnRecoverableConfigFileDiagnostic: () => {},
-  });
-  if (!parsed) return [];
-  const { paths, baseUrl } = parsed.options;
-  if (!paths) return [];
-  // baseUrl is absolute when set; fall back to tsconfig dir for TS 5+ pathless baseUrl
-  const base = baseUrl ?? root;
-  const entries: AliasEntry[] = [];
-  for (const [pattern, targets] of Object.entries(paths)) {
-    if (targets.length === 0) continue;
-    const isWildcard = pattern.endsWith("/*");
-    const prefix = isWildcard ? pattern.slice(0, -2) : pattern;
-    const targetStr = targets[0];
-    const targetBase = targetStr.endsWith("/*") ? targetStr.slice(0, -2) : targetStr;
-    entries.push({ prefix, base: toSlashPath(resolve(base, targetBase)), isWildcard });
-  }
-  return entries;
-}
-
-function resolveAlias(importPath: string, aliases: AliasEntry[]): string | undefined {
-  for (const alias of aliases) {
-    if (alias.isWildcard) {
-      const matchPrefix = `${alias.prefix}/`;
-      if (importPath.startsWith(matchPrefix)) {
-        return toSlashPath(resolve(alias.base, importPath.slice(matchPrefix.length)));
-      }
-    } else if (importPath === alias.prefix) {
-      return alias.base;
-    }
-  }
-  return undefined;
-}
-
-interface ImportRecord {
-  path: string;
-  resolved: string;
-  isTypeOnly: boolean;
-  line: number;
-}
-
-function isBareSpecifier(path: string): boolean {
-  return !path.startsWith(".") && !isAbsolute(path);
-}
-
-function globToPrefix(glob: string, root: string): string {
-  return toSlashPath(resolve(root, glob.split("/**")[0].split("/*")[0].split("*")[0]));
-}
-
-function resolveGlobs(
-  ref: string | string[],
-  layers: Record<string, string[]> | undefined
-): string[] {
-  const items = Array.isArray(ref) ? ref : [ref];
-  return items.flatMap((item) => layers?.[item] ?? [item]);
-}
-
-function resolveLayerPrefixes(
-  ref: string | string[],
-  layers: Record<string, string[]> | undefined,
-  root: string
-): string[] {
-  return resolveGlobs(ref, layers)
-    .filter((g) => !g.startsWith("!"))
-    .map((g) => globToPrefix(g, root));
-}
-
-function resolveLayerFiles(
-  ref: string | string[],
-  layers: Record<string, string[]> | undefined,
-  root: string,
-  allFiles: string[]
-): string[] {
-  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 matchesPackage(specifier: string, entries: string[]): boolean {
-  return entries.some(
-    (entry) => specifier === entry || specifier.startsWith(`${entry}/`)
-  );
-}
-
-function inPrefixes(absPath: string, prefixes: string[]): boolean {
-  return prefixes.some((p) => {
-    if (absPath === p || absPath.startsWith(`${p}/`)) return true;
-    // Extension-less imports ("../cli") won't match a prefix like "{root}/cli.ts"
-    const bare = p.replace(/\.(tsx?|jsx?|mts|cts)$/, "");
-    return bare !== p && (absPath === bare || absPath.startsWith(`${bare}/`));
-  });
-}
-
-function scanImports(
-  file: string,
-  content: string,
-  aliases: AliasEntry[]
-): ImportRecord[] {
-  const records: ImportRecord[] = [];
-  const fileDir = dirname(file);
-
-  walkAst(file, content, (node, src) => {
-    let specifierNode: ts.StringLiteral | undefined;
-    let isTypeOnly = false;
-
-    if (ts.isImportDeclaration(node)) {
-      if (ts.isStringLiteral(node.moduleSpecifier)) {
-        specifierNode = node.moduleSpecifier;
-        isTypeOnly = node.importClause?.isTypeOnly ?? false;
-      }
-    } else if (ts.isExportDeclaration(node)) {
-      if (node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
-        specifierNode = node.moduleSpecifier;
-        isTypeOnly = node.isTypeOnly;
-      }
-    } else if (
-      ts.isCallExpression(node) &&
-      node.expression.kind === ts.SyntaxKind.ImportKeyword &&
-      node.arguments.length >= 1 &&
-      ts.isStringLiteral(node.arguments[0])
-    ) {
-      specifierNode = node.arguments[0] as ts.StringLiteral;
-    }
-
-    if (!specifierNode) return;
-
-    const path = specifierNode.text;
-    let resolved: string;
-    if (isBareSpecifier(path)) {
-      resolved = resolveAlias(path, aliases) ?? path;
-    } else {
-      resolved = toSlashPath(resolve(fileDir, path));
-    }
-    const { line } = src.getLineAndCharacterOfPosition(specifierNode.getStart());
-    records.push({ path, resolved, isTypeOnly, line: line + 1 });
-  });
-
-  return records;
-}
-
-export function runArchRules(
-  arch: ArchConfig,
-  allFiles: string[],
-  fileContents: Map<string, string>,
-  root: string
-): Violation[] {
-  const violations: Violation[] = [];
-  const layers = arch.layers;
-  const aliases = loadPathAliases(root);
-
-  for (const rule of arch.imports ?? []) {
-    const severity: Severity = rule.severity ?? "error";
-    const fromFiles = resolveLayerFiles(rule.from, layers, root, allFiles);
-    const denyPackages = toArray(rule["deny-packages"] ?? []);
-
-    for (const file of fromFiles) {
-      const content = fileContents.get(file);
-      if (!content) continue;
-
-      for (const imp of scanImports(file, content, aliases)) {
-        if (rule["type-only"] === "allow" && imp.isTypeOnly) continue;
-
-        const relFile = relativeSlashPath(root, file);
-
-        if (isBareSpecifier(imp.resolved)) {
-          if (matchesPackage(imp.path, denyPackages)) {
-            violations.push({
-              file: relFile,
-              line: imp.line,
-              message: rule.message ?? "Import of a denied package",
-              rule: "arch/imports",
-              severity,
-            });
-          }
-          continue;
-        }
-
-        if (rule.deny !== undefined) {
-          const denyPrefixes = resolveLayerPrefixes(rule.deny, layers, root);
-          if (inPrefixes(imp.resolved, denyPrefixes)) {
-            violations.push({
-              file: relFile,
-              line: imp.line,
-              message: rule.message ?? "Import crosses a denied boundary",
-              rule: "arch/imports",
-              severity,
-            });
-          }
-        } else if (rule.allow !== undefined) {
-          const allowPrefixes = resolveLayerPrefixes(rule.allow, layers, root);
-          if (!inPrefixes(imp.resolved, allowPrefixes)) {
-            violations.push({
-              file: relFile,
-              line: imp.line,
-              message: rule.message ?? "Import is not in the allowed list",
-              rule: "arch/imports",
-              severity,
-            });
-          }
-        }
-      }
-    }
-  }
-
-  for (const rule of arch.forbidden ?? []) {
-    const severity: Severity = rule.severity ?? "error";
-    const inFiles = resolveLayerFiles(rule.in, layers, root, allFiles);
-    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 ?? []) {
-    const severity: Severity = rule.severity ?? "error";
-    const onlyFile = toSlashPath(resolve(root, rule.only));
-    const inFiles = rule.in
-      ? resolveLayerFiles(rule.in, layers, root, allFiles)
-      : allFiles;
-    const scope = inFiles.filter((f) => f !== onlyFile);
-    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
-      );
-    }
-  }
-
-  for (const rule of arch.maxLines ?? []) {
-    const severity: Severity = rule.severity ?? "error";
-    const inFiles = resolveLayerFiles(rule.in, layers, root, allFiles);
-    for (const file of inFiles) {
-      const content = fileContents.get(file);
-      if (content === undefined) continue;
-      if (countLines(content) > rule.limit) {
-        violations.push({
-          file: relativeSlashPath(root, file),
-          line: rule.limit + 1,
-          message: rule.message ?? `File exceeds the maximum of ${rule.limit} lines`,
-          rule: "arch/max-lines",
-          severity,
-        });
-      }
-    }
-  }
-
-  for (const rule of arch.maxCommentDensity ?? []) {
-    const severity: Severity = rule.severity ?? "error";
-    const ignoreMatcher = buildIgnoreMatcher(rule.ignore);
-    const inFiles = resolveLayerFiles(rule.in, layers, root, allFiles);
-    for (const file of inFiles) {
-      const content = fileContents.get(file);
-      if (content === undefined) continue;
-      const total = countLines(content);
-      if (total === 0) continue;
-      const commentLines = commentLineSet(file, content, rule.countDocComments ?? false);
-      const ignored = ignoreMatcher
-        ? ignoredCommentLines(content, commentLines, ignoreMatcher)
-        : undefined;
-      const counted = commentLines.size - (ignored?.size ?? 0);
-      const density = (counted / total) * 100;
-      if (density > rule.limit) {
-        violations.push({
-          file: relativeSlashPath(root, file),
-          line: 1,
-          message:
-            rule.message ??
-            `Comment density ${density.toFixed(1)}% exceeds the maximum of ${rule.limit}%`,
-          rule: "arch/max-comment-density",
-          severity,
-        });
-      }
-    }
-  }
-
-  for (const rule of arch.maxCommentBlock ?? []) {
-    const severity: Severity = rule.severity ?? "error";
-    const ignoreMatcher = buildIgnoreMatcher(rule.ignore);
-    const inFiles = resolveLayerFiles(rule.in, layers, root, allFiles);
-    for (const file of inFiles) {
-      const content = fileContents.get(file);
-      if (content === undefined) continue;
-      const commentLines = [
-        ...commentLineSet(file, content, rule.countDocComments ?? false),
-      ].sort((a, b) => a - b);
-      const ignored = ignoreMatcher
-        ? ignoredCommentLines(content, commentLines, ignoreMatcher)
-        : undefined;
-      const overrun = firstCommentBlockOverrun(commentLines, rule.limit, ignored);
-      if (overrun !== undefined) {
-        violations.push({
-          file: relativeSlashPath(root, file),
-          line: overrun,
-          message:
-            rule.message ??
-            `Comment block exceeds the maximum of ${rule.limit} consecutive lines`,
-          rule: "arch/max-comment-block",
-          severity,
-        });
-      }
-    }
-  }
-
-  return violations;
-}
-
-/** Counts physical lines the same way Rust's `str::lines()` does — a trailing newline does not add a line. */
-function countLines(content: string): number {
-  if (content.length === 0) return 0;
-  return content.split("\n").length - (content.endsWith("\n") ? 1 : 0);
-}
-
-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: relativeSlashPath(root, file),
-        line: line + 1,
-        message,
-        rule: ruleName,
-        severity,
-      });
-    });
-  }
-}
-
-const REGEX_PREFIX = "re:";
-
-function buildIgnoreMatcher(
-  ignore: string | string[] | undefined
-): ((line: string) => boolean) | undefined {
-  const patterns = toArray(ignore ?? []);
-  if (patterns.length === 0) return undefined;
-  const matchers = patterns.map(buildLineMatcher);
-  return (line) => matchers.some((matches) => matches(line));
-}
-
-function buildLineMatcher(pattern: string): (line: string) => boolean {
-  if (!pattern.startsWith(REGEX_PREFIX)) {
-    return (line) => line.includes(pattern);
-  }
-  const source = pattern.slice(REGEX_PREFIX.length);
-  let regex: RegExp;
-  try {
-    regex = new RegExp(source);
-  } catch (cause) {
-    throw new Error(
-      `klint: invalid regex in arch pattern "${pattern}": ${(cause as Error).message}`
-    );
-  }
-  return (line) => regex.test(line);
-}
-
-function scanLinesForPattern(
-  files: string[],
-  pattern: string,
-  fileContents: Map<string, string>,
-  root: string,
-  ruleName: string,
-  message: string,
-  severity: Severity,
-  violations: Violation[]
-): void {
-  const matchesLine = buildLineMatcher(pattern);
-  for (const file of files) {
-    const content = fileContents.get(file);
-    if (!content) continue;
-    const lines = content.split("\n");
-    for (let i = 0; i < lines.length; i++) {
-      if (matchesLine(lines[i])) {
-        violations.push({
-          file: relativeSlashPath(root, file),
-          line: i + 1,
-          message,
-          rule: ruleName,
-          severity,
-        });
-      }
-    }
-  }
-}

package/core/ast.ts

@@ -1,63 +0,0 @@
-import ts from "typescript";
-
-let _program: { key: string; program: ts.Program } | undefined;
-let _sourceFiles: Map<string, ts.SourceFile> = new Map();
-
-export function clearAstCache(): void {
-  _program = undefined;
-  _sourceFiles = new Map();
-}
-
-export function createProgram(files: string[], root: string): ts.Program {
-  const key = `${root}\0${[...files].sort().join("\0")}`;
-  if (_program?.key === key) return _program.program;
-  const configPath = ts.findConfigFile(root, ts.sys.fileExists);
-  let options: ts.CompilerOptions = { target: ts.ScriptTarget.Latest, strict: true };
-  if (configPath) {
-    const { config } = ts.readConfigFile(configPath, ts.sys.readFile);
-    options = ts.parseJsonConfigFileContent(config, ts.sys, root).options;
-  }
-  const program = ts.createProgram(files, options);
-  _program = { key, program };
-  return program;
-}
-
-export function nearestFunctionIsAsync(node: ts.Node): boolean {
-  let cur: ts.Node | undefined = node.parent;
-  while (cur) {
-    if (
-      ts.isFunctionDeclaration(cur) ||
-      ts.isFunctionExpression(cur) ||
-      ts.isArrowFunction(cur)
-    ) {
-      return cur.modifiers?.some((m) => m.kind === ts.SyntaxKind.AsyncKeyword) ?? false;
-    }
-    cur = cur.parent;
-  }
-  return false;
-}
-
-export function isInsideTry(node: ts.Node): boolean {
-  let cur: ts.Node | undefined = node.parent;
-  while (cur) {
-    if (ts.isTryStatement(cur)) return true;
-    cur = cur.parent;
-  }
-  return false;
-}
-
-export function walkAst(
-  filePath: string,
-  content: string,
-  visitor: (node: ts.Node, src: ts.SourceFile) => void
-): void {
-  const cached = _sourceFiles.get(filePath);
-  const src =
-    cached ?? ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
-  if (!cached) _sourceFiles.set(filePath, src);
-  function recurse(node: ts.Node): void {
-    visitor(node, src);
-    ts.forEachChild(node, recurse);
-  }
-  recurse(src);
-}