@rettangoli/check 0.0.1

package/src/cli/bin.js

@@ -0,0 +1,325 @@
+#!/usr/bin/env node
+import check from "./check.js";
+import { DIAGNOSTIC_CATALOG_VERSION, getDiagnosticCatalogEntry } from "../diagnostics/catalog.js";
+
+const CHECK_USAGE = [
+  "Usage: rtgl-check [options]",
+  "",
+  "Options:",
+  "  --dir <path>        Component directory (repeatable)",
+  "  --dirs <path>       Alias for --dir",
+  "  --format <value>    Report format: text | json | sarif",
+  "  --warn-as-error     Treat warnings as errors",
+  "  --no-yahtml         Disable YAHTML attribute checks",
+  "  --expr              Enable template expression root checks",
+  "  --autofix           Apply safe autofixes in place",
+  "  --autofix-dry-run   Preview safe autofixes without writing files",
+  "  --autofix-min-confidence <0-1> Minimum confidence threshold (default: 0.9)",
+  "  --autofix-patch     Include patch output for autofix candidates",
+  "  --watch             Re-run check when files change (polling)",
+  "  --watch-interval-ms Poll interval in milliseconds (default: 800)",
+  "  -h, --help          Show this help",
+].join("\n");
+
+class CliArgError extends Error {
+  constructor(message, { usage = CHECK_USAGE } = {}) {
+    super(message);
+    this.name = "CliArgError";
+    this.command = "check";
+    this.usage = usage;
+  }
+}
+
+const getRequiredValue = ({ args, index, flag, usage }) => {
+  const value = args[index + 1];
+  if (!value || value.startsWith("-")) {
+    throw new CliArgError(`Missing value for ${flag}.`, { usage });
+  }
+  return value;
+};
+
+const parseCheckArgs = (args = []) => {
+  if (args.includes("--help") || args.includes("-h")) {
+    return { help: true, usage: CHECK_USAGE, command: "check" };
+  }
+
+  const dirs = [];
+  let format = "text";
+  let warnAsError = false;
+  let includeYahtml = true;
+  let includeExpression = false;
+  let watch = false;
+  let watchIntervalMs = 800;
+  let autofixMode = "off";
+  let autofixMinConfidence = 0.9;
+  let autofixPatch = false;
+  let autofixMinConfidenceSet = false;
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+
+    if (arg === "check") {
+      continue;
+    }
+
+    if (arg === "--dirs" || arg === "--dir") {
+      const value = getRequiredValue({ args, index: i, flag: arg, usage: CHECK_USAGE });
+      dirs.push(value);
+      i += 1;
+      continue;
+    }
+
+    if (arg === "--format") {
+      const value = getRequiredValue({ args, index: i, flag: arg, usage: CHECK_USAGE });
+      if (value !== "text" && value !== "json" && value !== "sarif") {
+        throw new CliArgError(`Invalid value for --format: "${value}". Expected "text", "json", or "sarif".`, {
+          usage: CHECK_USAGE,
+        });
+      }
+      format = value;
+      i += 1;
+      continue;
+    }
+
+    if (arg === "--warn-as-error") {
+      warnAsError = true;
+      continue;
+    }
+
+    if (arg === "--no-yahtml") {
+      includeYahtml = false;
+      continue;
+    }
+
+    if (arg === "--expr") {
+      includeExpression = true;
+      continue;
+    }
+
+    if (arg === "--autofix") {
+      if (autofixMode === "dry-run") {
+        throw new CliArgError("Cannot combine --autofix with --autofix-dry-run.", {
+          usage: CHECK_USAGE,
+        });
+      }
+      autofixMode = "apply";
+      continue;
+    }
+
+    if (arg === "--autofix-dry-run") {
+      if (autofixMode === "apply") {
+        throw new CliArgError("Cannot combine --autofix with --autofix-dry-run.", {
+          usage: CHECK_USAGE,
+        });
+      }
+      autofixMode = "dry-run";
+      continue;
+    }
+
+    if (arg === "--autofix-patch") {
+      autofixPatch = true;
+      if (autofixMode === "off") {
+        autofixMode = "dry-run";
+      }
+      continue;
+    }
+
+    if (arg === "--autofix-min-confidence") {
+      const value = getRequiredValue({ args, index: i, flag: arg, usage: CHECK_USAGE });
+      const parsed = Number.parseFloat(value);
+      if (!Number.isFinite(parsed) || parsed < 0 || parsed > 1) {
+        throw new CliArgError(`Invalid value for --autofix-min-confidence: "${value}". Expected a number in [0, 1].`, {
+          usage: CHECK_USAGE,
+        });
+      }
+      autofixMinConfidence = parsed;
+      autofixMinConfidenceSet = true;
+      i += 1;
+      continue;
+    }
+
+    if (arg === "--watch") {
+      watch = true;
+      continue;
+    }
+
+    if (arg === "--watch-interval-ms") {
+      const value = getRequiredValue({ args, index: i, flag: arg, usage: CHECK_USAGE });
+      const parsed = Number.parseInt(value, 10);
+      if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new CliArgError(`Invalid value for --watch-interval-ms: "${value}". Expected a positive integer.`, {
+          usage: CHECK_USAGE,
+        });
+      }
+      watchIntervalMs = parsed;
+      i += 1;
+      continue;
+    }
+
+    if (arg.startsWith("-")) {
+      throw new CliArgError(`Unknown option: ${arg}`, { usage: CHECK_USAGE });
+    }
+
+    throw new CliArgError(`Unexpected positional argument: ${arg}`, { usage: CHECK_USAGE });
+  }
+
+  if (autofixMode === "off" && autofixMinConfidenceSet) {
+    throw new CliArgError("Cannot use --autofix-min-confidence without --autofix or --autofix-dry-run.", {
+      usage: CHECK_USAGE,
+    });
+  }
+
+  return {
+    help: false,
+    usage: CHECK_USAGE,
+    command: "check",
+    options: {
+      cwd: process.cwd(),
+      dirs,
+      format,
+      warnAsError,
+      includeYahtml,
+      includeExpression,
+      watch,
+      watchIntervalMs,
+      autofixMode,
+      autofixMinConfidence,
+      autofixPatch,
+    },
+  };
+};
+
+const formatCliRuntimeErrorReport = ({ message, warnAsError = false }) => {
+  const catalogEntry = getDiagnosticCatalogEntry("RTGL-CLI-001");
+  const diagnostic = {
+    code: "RTGL-CLI-001",
+    category: "cli",
+    family: catalogEntry.family,
+    title: catalogEntry.title,
+    severity: "error",
+    message,
+    docsPath: catalogEntry.docsPath,
+    namespaceValid: catalogEntry.namespaceValid,
+    tags: catalogEntry.tags,
+    filePath: "unknown",
+  };
+
+  return JSON.stringify({
+    $schema: "docs/diagnostics-json-schema-v1.json",
+    schemaVersion: 1,
+    contractVersion: 1,
+    reportFormat: "json",
+    diagnosticCatalogVersion: DIAGNOSTIC_CATALOG_VERSION,
+    ok: false,
+    command: "check",
+    componentCount: 0,
+    registryTagCount: 0,
+    summary: {
+      total: 1,
+      bySeverity: {
+        error: 1,
+        warn: 0,
+      },
+      byCode: [
+        {
+          code: diagnostic.code,
+          count: 1,
+        },
+      ],
+    },
+    warnAsError,
+    diagnosticCatalog: [catalogEntry],
+    diagnostics: [diagnostic],
+  }, null, 2);
+};
+
+const formatCliRuntimeErrorSarif = ({ message }) => {
+  const catalogEntry = getDiagnosticCatalogEntry("RTGL-CLI-001");
+  return JSON.stringify({
+    $schema: "https://json.schemastore.org/sarif-2.1.0.json",
+    version: "2.1.0",
+    runs: [
+      {
+        tool: {
+          driver: {
+            name: "@rettangoli/check",
+            rules: [
+              {
+                id: "RTGL-CLI-001",
+                shortDescription: { text: catalogEntry.title },
+                fullDescription: { text: catalogEntry.description },
+                helpUri: catalogEntry.docsPath,
+                defaultConfiguration: { level: "error" },
+                properties: {
+                  category: catalogEntry.family,
+                  namespaceValid: catalogEntry.namespaceValid,
+                  tags: catalogEntry.tags,
+                },
+              },
+            ],
+          },
+        },
+        results: [
+          {
+            ruleId: "RTGL-CLI-001",
+            level: "error",
+            message: { text: message },
+            locations: [
+              {
+                physicalLocation: {
+                  artifactLocation: { uri: "unknown" },
+                },
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  }, null, 2);
+};
+
+const main = async () => {
+  let parsed = null;
+
+  try {
+    parsed = parseCheckArgs(process.argv.slice(2));
+    if (parsed.help) {
+      console.log(parsed.usage);
+      process.exitCode = 0;
+      return;
+    }
+
+    await check(parsed.options);
+  } catch (err) {
+    if (err instanceof CliArgError) {
+      console.error(`[Check] ${err.message}`);
+      console.error("");
+      console.error(err.usage);
+      process.exitCode = 1;
+      return;
+    }
+
+    const message = err instanceof Error ? err.message : String(err);
+    const format = parsed?.options?.format || "text";
+
+    if (format === "json") {
+      console.log(formatCliRuntimeErrorReport({
+        message,
+        warnAsError: Boolean(parsed?.options?.warnAsError),
+      }));
+      process.exitCode = 1;
+      return;
+    }
+
+    if (format === "sarif") {
+      console.log(formatCliRuntimeErrorSarif({ message }));
+      process.exitCode = 1;
+      return;
+    }
+
+    console.error(`[Check] ${message}`);
+    process.exitCode = 1;
+  }
+};
+
+await main();

package/src/cli/check.js

@@ -0,0 +1,232 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { load as loadYaml } from "js-yaml";
+import { analyzeProject } from "../core/analyze.js";
+import { applyDiagnosticFixes } from "../diagnostics/autofix.js";
+import { formatReport } from "../reporters/index.js";
+import { isDirectoryPath } from "../utils/fs.js";
+
+const readConfig = (cwd) => {
+  const configPath = path.resolve(cwd, "rettangoli.config.yaml");
+  if (!existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(configPath, "utf8");
+    return loadYaml(content);
+  } catch (err) {
+    throw new Error(`Failed to read rettangoli.config.yaml: ${err.message}`);
+  }
+};
+
+const resolveDirs = ({ cwd, dirs, config }) => {
+  if (Array.isArray(dirs) && dirs.length > 0) {
+    return dirs;
+  }
+
+  const configDirs = config?.fe?.dirs;
+  if (Array.isArray(configDirs) && configDirs.length > 0) {
+    return configDirs;
+  }
+
+  return ["./src/components"];
+};
+
+const toAutofixReport = ({
+  autofixResult,
+  mode = "off",
+  includePatchText = false,
+}) => {
+  if (!autofixResult) {
+    return undefined;
+  }
+
+  return {
+    mode,
+    dryRun: Boolean(autofixResult.dryRun),
+    patchOutput: includePatchText,
+    candidateCount: Number(autofixResult.candidateCount) || 0,
+    appliedCount: Number(autofixResult.appliedCount) || 0,
+    skippedCount: Number(autofixResult.skippedCount) || 0,
+    patches: Array.isArray(autofixResult.patches)
+      ? autofixResult.patches.map((patch) => ({
+        code: patch.code,
+        filePath: patch.filePath,
+        line: patch.line,
+        description: patch.description,
+        confidence: patch.confidence,
+        ...(includePatchText && typeof patch.patch === "string" ? { patch: patch.patch } : {}),
+      }))
+      : [],
+  };
+};
+
+export const check = async (options = {}) => {
+  const {
+    cwd = process.cwd(),
+    dirs = [],
+    format = "text",
+    warnAsError = false,
+    includeYahtml = true,
+    includeExpression = false,
+    watch = false,
+    watchIntervalMs = 800,
+    autofixMode = "off",
+    autofixMinConfidence = 0.9,
+    autofixPatch = false,
+  } = options;
+
+  const config = readConfig(cwd);
+  const resolvedDirs = resolveDirs({ cwd, dirs, config });
+  const missingDirs = resolvedDirs.filter((dirPath) => !isDirectoryPath(path.resolve(cwd, dirPath)));
+  const incrementalState = { componentCache: new Map() };
+
+  if (missingDirs.length > 0) {
+    throw new Error(`Component directories do not exist: ${missingDirs.join(", ")}`);
+  }
+
+  if (watch && autofixMode !== "off") {
+    throw new Error("Autofix is not supported with --watch.");
+  }
+
+  const runAnalysis = async () => analyzeProject({
+    cwd,
+    dirs: resolvedDirs,
+    workspaceRoot: cwd,
+    includeYahtml,
+    includeExpression,
+    incrementalState,
+  });
+
+  const runOnce = async () => {
+    const initialResult = await runAnalysis();
+    let result = initialResult;
+
+    let autofixResult = null;
+    if (autofixMode !== "off") {
+      autofixResult = applyDiagnosticFixes({
+        diagnostics: initialResult.diagnostics,
+        dryRun: autofixMode !== "apply",
+        minConfidence: autofixMinConfidence,
+        includePatchText: autofixPatch,
+      });
+
+      if (autofixMode === "apply" && autofixResult.appliedCount > 0) {
+        result = await runAnalysis();
+      }
+
+      result = {
+        ...result,
+        autofix: toAutofixReport({
+          autofixResult,
+          mode: autofixMode,
+          includePatchText: autofixPatch,
+        }),
+      };
+    }
+
+    const report = formatReport({
+      format: (format === "json" || format === "sarif") ? format : "text",
+      result,
+      warnAsError,
+    });
+
+    const hasErrors = result.summary.bySeverity.error > 0;
+    const hasWarnAsError = warnAsError && result.summary.bySeverity.warn > 0;
+    process.exitCode = hasErrors || hasWarnAsError ? 1 : 0;
+
+    return {
+      result,
+      report,
+      hasErrors,
+      hasWarnAsError,
+    };
+  };
+
+  if (!watch) {
+    const {
+      result,
+      report,
+      hasErrors,
+      hasWarnAsError,
+    } = await runOnce();
+    if (format === "json" || format === "sarif") {
+      console.log(report);
+    } else if (hasErrors || hasWarnAsError) {
+      console.error(report);
+    } else {
+      console.log(report);
+    }
+    return result;
+  }
+
+  let lastSignature = null;
+  let running = false;
+  let stopped = false;
+  let lastResult = null;
+  const interval = Math.max(200, Number.isFinite(watchIntervalMs) ? Number(watchIntervalMs) : 800);
+
+  const runWatchIteration = async () => {
+    if (running || stopped) {
+      return;
+    }
+    running = true;
+    try {
+      const { result, report } = await runOnce();
+      const signature = JSON.stringify({
+        summary: result.summary,
+        diagnostics: result.diagnostics,
+      });
+      if (signature !== lastSignature) {
+        if (lastSignature !== null && format === "text") {
+          console.log("\n[Watch] Change detected.\n");
+        }
+        if (format === "json" || format === "sarif") {
+          console.log(report);
+        } else {
+          const hasErrors = result.summary.bySeverity.error > 0;
+          const hasWarnAsError = warnAsError && result.summary.bySeverity.warn > 0;
+          if (hasErrors || hasWarnAsError) {
+            console.error(report);
+          } else {
+            console.log(report);
+          }
+        }
+        lastSignature = signature;
+      }
+      lastResult = result;
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      if (format === "text") {
+        console.error(`[Watch] ${message}`);
+      }
+    } finally {
+      running = false;
+    }
+  };
+
+  await runWatchIteration();
+  const timer = setInterval(runWatchIteration, interval);
+
+  const stop = () => {
+    stopped = true;
+    clearInterval(timer);
+  };
+
+  process.on("SIGINT", stop);
+  process.on("SIGTERM", stop);
+
+  await new Promise((resolve) => {
+    const checkStopped = setInterval(() => {
+      if (stopped) {
+        clearInterval(checkStopped);
+        resolve();
+      }
+    }, 100);
+  });
+
+  return lastResult;
+};
+
+export default check;

package/src/cli/index.js

@@ -0,0 +1 @@
+export { default as check } from "./check.js";