@konvert7/klint 0.38.0 → 1.0.0

package/cli/stats.ts

@@ -1,92 +0,0 @@
-import { resolve } from "node:path";
-import { type KlintStats, readStats, STATS_DIR, STATS_FILE } from "../core/stats";
-import type { OptionValues } from "./command";
-
-const RULE_HEADING = "by rule";
-const REPORTED_HEADING = "reported";
-const PREVENTED_HEADING = "prevented";
-const LABEL_WIDTH = "violations reported".length;
-
-interface RuleRow {
-  rule: string;
-  reported: number;
-  prevented: number;
-}
-
-function ruleRows(stats: KlintStats): RuleRow[] {
-  const rules = new Set([
-    ...Object.keys(stats.reported.byRule),
-    ...Object.keys(stats.prevented.byRule),
-  ]);
-  const byCodePoint = (a: string, b: string) => Number(a > b) - Number(a < b);
-  return [...rules]
-    .map((rule) => ({
-      rule,
-      reported: stats.reported.byRule[rule] ?? 0,
-      prevented: stats.prevented.byRule[rule] ?? 0,
-    }))
-    .sort(
-      (a, b) =>
-        b.reported - a.reported ||
-        b.prevented - a.prevented ||
-        byCodePoint(a.rule, b.rule)
-    );
-}
-
-interface Summary {
-  label: string;
-  total: number;
-  detail: string;
-}
-
-function summaryLines(summaries: Summary[]): string[] {
-  const width = Math.max(...summaries.map(({ total }) => String(total).length));
-  return summaries.map(
-    ({ label, total, detail }) =>
-      `  ${label.padEnd(LABEL_WIDTH)}  ${String(total).padStart(width)}  (${detail})`
-  );
-}
-
-function ruleTable(rows: RuleRow[]): string[] {
-  const width = Math.max(RULE_HEADING.length - 2, ...rows.map(({ rule }) => rule.length));
-  const heading = `  ${RULE_HEADING.padEnd(width + 2)}  ${REPORTED_HEADING}  ${PREVENTED_HEADING}`;
-  const lines = rows.map(
-    ({ rule, reported, prevented }) =>
-      `    ${rule.padEnd(width)}  ${String(reported).padStart(REPORTED_HEADING.length)}  ${String(prevented).padStart(PREVENTED_HEADING.length)}`
-  );
-  return [heading, ...lines];
-}
-
-export function formatStats(stats: KlintStats): string {
-  const { runs, reported, prevented } = stats;
-  const lines = [
-    `klint stats (${STATS_DIR}/${STATS_FILE})`,
-    "",
-    ...summaryLines([
-      {
-        label: "runs",
-        total: runs.hook + runs.direct,
-        detail: `hook ${runs.hook}, direct ${runs.direct}`,
-      },
-      {
-        label: "violations reported",
-        total: reported.bySource.hook + reported.bySource.direct,
-        detail: `hook ${reported.bySource.hook}, direct ${reported.bySource.direct}`,
-      },
-      {
-        label: "errors prevented",
-        total: prevented.bySource.hook + prevented.bySource.direct,
-        detail: `caught by hook ${prevented.bySource.hook}, direct ${prevented.bySource.direct}`,
-      },
-    ]),
-  ];
-  const rows = ruleRows(stats);
-  if (rows.length > 0) lines.push("", ...ruleTable(rows));
-  return `${lines.join("\n")}\n`;
-}
-
-export function printStats(values: OptionValues): void {
-  const configDir =
-    typeof values.config === "string" ? resolve(values.config) : process.cwd();
-  process.stdout.write(formatStats(readStats(configDir)));
-}

package/cli.ts

@@ -1,214 +0,0 @@
-#!/usr/bin/env bun
-import { existsSync } from "node:fs";
-import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import { parse as parseYaml } from "yaml";
-import { type OptionValues, runCommand } from "./cli/command";
-import { klintCommand } from "./cli/commands";
-import { installSkill } from "./cli/install-skill";
-import {
-  formatDuration,
-  toJsonCliResult,
-  withAdvisories,
-  writeDebugEvent,
-  writeTextOutput,
-} from "./cli/output";
-import { installedVersion, SHIPPED_SKILL_PATH } from "./cli/paths";
-import { runAutoEngine, runCompareEngine, runRustEngine } from "./cli/rust-engine";
-import { printStats } from "./cli/stats";
-import { applyFixes } from "./core/fixer";
-import { runKlint } from "./core/runner";
-import { schemaVersionAdvisory } from "./core/schema-version";
-import { skillAdvisories } from "./core/skill";
-import { runRecorder } from "./core/stats";
-import type { ArchConfig, KlintConfig, KlintRule, RuleConfigValue } from "./core/types";
-
-export async function main(): Promise<number> {
-  const startedAt = performance.now();
-  const command = klintCommand({
-    lint: (values) => lint(values, startedAt),
-    stats: printStats,
-    installSkill,
-  });
-  return runCommand(command, process.argv.slice(2), ["klint"]);
-}
-
-function optionalPath(value: string | true | undefined): string | undefined {
-  return typeof value === "string" ? resolve(value) : undefined;
-}
-
-async function lint(values: OptionValues, startedAt: number): Promise<void> {
-  if (values.version) {
-    process.stdout.write(`klint ${installedVersion()}\n`);
-    return;
-  }
-  const rulesFile = optionalPath(values.rules);
-  const fix = values.fix === true;
-  const json = values.json === true;
-  const debug = values.debug === true;
-  const hook = values.hook === true;
-  const engine =
-    typeof values.engine === "string" ? values.engine : process.env.KLINT_ENGINE;
-  const configDir = optionalPath(values.config) ?? process.cwd();
-  const record = runRecorder(configDir, hook ? "hook" : "direct");
-
-  const yamlPath = resolve(configDir, "klint.yaml");
-  const jsonPath = resolve(configDir, "klint.config.json");
-  const usingYaml = existsSync(yamlPath);
-  const configPath = usingYaml ? yamlPath : jsonPath;
-
-  if (!existsSync(configPath)) {
-    process.stderr.write(
-      `klint: no config file found — create klint.yaml (or klint.config.json) at ${configDir}\n`
-    );
-    process.exit(1);
-  }
-
-  interface RawConfig {
-    $schema?: string;
-    root?: string;
-    include?: string[];
-    plugins?: string[];
-    rules?: Record<string, RuleConfigValue>;
-    arch?: unknown;
-  }
-  let raw: RawConfig;
-  let configText = "";
-  try {
-    configText = await readFile(configPath, "utf-8");
-    raw = (usingYaml ? parseYaml(configText) : JSON.parse(configText)) as RawConfig;
-  } catch {
-    process.stderr.write(`klint: failed to parse ${configPath}\n`);
-    process.exit(1);
-  }
-  const root = resolve(configDir, raw.root ?? ".");
-
-  const installed = installedVersion();
-  const advisories = [
-    ...schemaVersionAdvisory({
-      schema: raw.$schema,
-      installed,
-      configFile: usingYaml ? "klint.yaml" : "klint.config.json",
-      configText,
-    }),
-    ...skillAdvisories({
-      configDir,
-      installed,
-      shippedSkillPath: SHIPPED_SKILL_PATH,
-    }),
-  ];
-
-  if (engine === "rust") {
-    runRustEngine({ advisories, fix, json, raw, record, root, rulesFile, startedAt });
-    return;
-  }
-  if (
-    engine !== undefined &&
-    engine !== "ts" &&
-    engine !== "rust" &&
-    engine !== "compare" &&
-    engine !== "auto"
-  ) {
-    process.stderr.write(
-      `klint: unknown engine "${engine}" (expected "ts", "rust", "compare", or "auto")\n`
-    );
-    process.exit(1);
-  }
-
-  let customRules: Record<string, KlintRule> = {};
-  const defaultRulesPath = resolve(configDir, "klint.rules.ts");
-  const rulesPath =
-    rulesFile ?? (existsSync(defaultRulesPath) ? defaultRulesPath : undefined);
-  if (rulesPath) {
-    const mod = await import(rulesPath);
-    customRules = (mod.default ?? {}) as Record<string, KlintRule>;
-  }
-
-  const customRulesMap: Record<string, RuleConfigValue> = Object.fromEntries(
-    Object.keys(customRules).map((name) => [name, "error" as const])
-  );
-  const allRules: KlintConfig["rules"] = { ...customRulesMap, ...(raw.rules ?? {}) };
-
-  if (engine === "auto") {
-    runAutoEngine({
-      advisories,
-      fix,
-      json,
-      raw,
-      record,
-      root,
-      rulesFile,
-      startedAt,
-      customRules,
-      customRulesMap,
-    });
-    return;
-  }
-
-  const violations = runKlint(
-    {
-      root,
-      include: raw.include ?? ["."],
-      plugins: raw.plugins,
-      rules: allRules,
-      arch: raw.arch as ArchConfig | undefined,
-    },
-    customRules,
-    { onDebug: debug ? writeDebugEvent : undefined }
-  );
-
-  if (engine === "compare") {
-    runCompareEngine({
-      advisories,
-      fix,
-      json,
-      raw,
-      record,
-      root,
-      rulesFile,
-      tsViolations: violations,
-    });
-    return;
-  }
-
-  if (json) {
-    record(violations);
-    const tsResult = toJsonCliResult(violations);
-    process.stdout.write(withAdvisories(tsResult.stdout, advisories));
-    process.exit(tsResult.status);
-  }
-
-  if (fix) {
-    let totalApplied = 0;
-    let current = violations;
-    while (true) {
-      const applied = applyFixes(current, root);
-      totalApplied += applied;
-      if (applied === 0) break;
-      current = runKlint(
-        {
-          root,
-          include: raw.include ?? ["."],
-          plugins: raw.plugins,
-          rules: allRules,
-          arch: raw.arch as ArchConfig | undefined,
-        },
-        customRules,
-        { onDebug: debug ? writeDebugEvent : undefined }
-      );
-      if (current.every((v) => !v.fix)) break;
-    }
-    record(current);
-    const unfixed = current.filter((v) => !v.fix).length;
-    const msg =
-      unfixed > 0
-        ? `klint: applied ${totalApplied} fix(es). ${unfixed} violation(s) require manual attention.`
-        : `klint: applied ${totalApplied} fix(es). No remaining violations.`;
-    process.stdout.write(`${msg} Finished in ${formatDuration(startedAt)}.\n`);
-    process.exit(0);
-  }
-  record(violations);
-  writeTextOutput([...violations, ...advisories], startedAt);
-}
-
-if (import.meta.main) process.exitCode = await main();

package/core/arch-comments.ts

@@ -1,125 +0,0 @@
-import ts from "typescript";
-
-interface CommentSpan {
-  startLine: number;
-  endLine: number;
-  isDoc: boolean;
-}
-
-/** JS-like sources are lexed for comments; Python/Swift comment rules run in the native engine. */
-function collectComments(file: string, content: string): CommentSpan[] {
-  if (!/\.(tsx?|jsx?|mts|cts)$/.test(file)) return [];
-  const variant = /\.(tsx|jsx)$/.test(file)
-    ? ts.LanguageVariant.JSX
-    : ts.LanguageVariant.Standard;
-  const scanner = ts.createScanner(ts.ScriptTarget.Latest, false, variant, content);
-  const starts = lineStarts(content);
-  const spans: CommentSpan[] = [];
-  const substitutionDepths: number[] = [];
-  let braceDepth = 0;
-  let token = scanner.scan();
-  while (token !== ts.SyntaxKind.EndOfFileToken) {
-    if (
-      token === ts.SyntaxKind.SingleLineCommentTrivia ||
-      token === ts.SyntaxKind.MultiLineCommentTrivia
-    ) {
-      const start = scanner.getTokenStart();
-      const end = scanner.getTokenEnd();
-      spans.push({
-        startLine: lineAt(starts, start),
-        endLine: lineAt(starts, Math.max(start, end - 1)),
-        isDoc: isDocComment(content.slice(start, end)),
-      });
-    } else if (token === ts.SyntaxKind.TemplateHead) {
-      substitutionDepths.push(braceDepth);
-    } else if (token === ts.SyntaxKind.OpenBraceToken) {
-      braceDepth += 1;
-    } else if (token === ts.SyntaxKind.CloseBraceToken) {
-      if (substitutionDepths.at(-1) === braceDepth) {
-        if (scanner.reScanTemplateToken(false) === ts.SyntaxKind.TemplateTail) {
-          substitutionDepths.pop();
-        }
-      } else {
-        braceDepth -= 1;
-      }
-    }
-    token = scanner.scan();
-  }
-  return spans;
-}
-
-/** A `/** *​/` JSDoc block, but not the empty `/**​/` comment. Mirrors the Rust engine. */
-function isDocComment(text: string): boolean {
-  return text.startsWith("/**") && text !== "/**/";
-}
-
-export function commentLineSet(
-  file: string,
-  content: string,
-  countDocComments: boolean
-): Set<number> {
-  const set = new Set<number>();
-  for (const span of collectComments(file, content)) {
-    if (!countDocComments && span.isDoc) continue;
-    for (let line = span.startLine; line <= span.endLine; line++) set.add(line);
-  }
-  return set;
-}
-
-/**
- * Comment lines whose source text matches an `ignore` pattern. They stay in the
- * density denominator and keep a comment run contiguous, but count toward neither.
- */
-export function ignoredCommentLines(
-  content: string,
-  commentLines: Iterable<number>,
-  matchesIgnore: (text: string) => boolean
-): Set<number> {
-  const sourceLines = content.split("\n");
-  const ignored = new Set<number>();
-  for (const line of commentLines) {
-    if (matchesIgnore(sourceLines[line - 1] ?? "")) ignored.add(line);
-  }
-  return ignored;
-}
-
-/**
- * Returns the first line at which a run of consecutive comment lines exceeds
- * `limit`. An ignored line neither counts toward the height nor breaks the run.
- */
-export function firstCommentBlockOverrun(
-  sortedLines: number[],
-  limit: number,
-  ignored?: ReadonlySet<number>
-): number | undefined {
-  let counted = 0;
-  let prev: number | undefined;
-  for (const line of sortedLines) {
-    if (prev !== undefined && line !== prev + 1) counted = 0;
-    prev = line;
-    if (ignored?.has(line)) continue;
-    counted += 1;
-    if (counted > limit) return line;
-  }
-  return undefined;
-}
-
-function lineStarts(content: string): number[] {
-  const starts = [0];
-  for (let i = 0; i < content.length; i++) {
-    if (content[i] === "\n") starts.push(i + 1);
-  }
-  return starts;
-}
-
-/** 1-based line for a character offset, via binary search over line starts. */
-function lineAt(starts: number[], offset: number): number {
-  let lo = 0;
-  let hi = starts.length - 1;
-  while (lo < hi) {
-    const mid = (lo + hi + 1) >> 1;
-    if (starts[mid] <= offset) lo = mid;
-    else hi = mid - 1;
-  }
-  return lo + 1;
-}