@rettangoli/check 0.0.1

package/src/core/analyze.js

@@ -0,0 +1,227 @@
+import { statSync } from "node:fs";
+import { buildComponentModel, buildProjectModel } from "./model.js";
+import { discoverComponentEntries, groupEntriesByComponent } from "./discovery.js";
+import { buildMergedRegistry } from "./registry.js";
+import { runRules } from "../rules/index.js";
+import { runSemanticEngine } from "../semantic/engine.js";
+import { getDiagnosticCatalogEntry } from "../diagnostics/catalog.js";
+
+const summarizeDiagnostics = (diagnostics = []) => {
+  const bySeverity = { error: 0, warn: 0 };
+  const byCodeMap = new Map();
+
+  diagnostics.forEach((diag) => {
+    const severity = diag.severity === "warn" ? "warn" : "error";
+    bySeverity[severity] += 1;
+    byCodeMap.set(diag.code, (byCodeMap.get(diag.code) || 0) + 1);
+  });
+
+  const byCode = [...byCodeMap.entries()]
+    .map(([code, count]) => ({ code, count }))
+    .sort((a, b) => a.code.localeCompare(b.code));
+
+  return {
+    total: diagnostics.length,
+    bySeverity,
+    byCode,
+  };
+};
+
+const categorizeDiagnosticCode = (code = "") => {
+  if (code.includes("YAHTML")) return "template";
+  if (code.includes("JEMPL")) return "template";
+  if (code.includes("SYMBOL")) return "symbols";
+  if (code.includes("SCHEMA")) return "schema";
+  if (code.includes("LIFECYCLE")) return "lifecycle";
+  if (code.includes("EXPR")) return "expression";
+  if (code.includes("COMPAT")) return "compatibility";
+  if (code.includes("CONTRACT")) return "contracts";
+  return "general";
+};
+
+const normalizeRelatedLocations = (related = []) => {
+  if (!Array.isArray(related) || related.length === 0) {
+    return undefined;
+  }
+
+  const normalized = related
+    .filter((entry) => entry && typeof entry === "object")
+    .map((entry) => ({
+      message: typeof entry.message === "string" && entry.message.trim()
+        ? entry.message.trim()
+        : undefined,
+      filePath: typeof entry.filePath === "string" && entry.filePath
+        ? entry.filePath
+        : "unknown",
+      line: Number.isInteger(entry.line) ? entry.line : undefined,
+      column: Number.isInteger(entry.column) ? entry.column : undefined,
+      endLine: Number.isInteger(entry.endLine) ? entry.endLine : undefined,
+      endColumn: Number.isInteger(entry.endColumn) ? entry.endColumn : undefined,
+    }))
+    .sort((left, right) => (
+      left.filePath.localeCompare(right.filePath)
+      || (left.line || 0) - (right.line || 0)
+      || (left.column || 0) - (right.column || 0)
+      || (left.message || "").localeCompare(right.message || "")
+    ));
+
+  return normalized.length > 0 ? normalized : undefined;
+};
+
+const normalizeFix = (fix = {}, diagnostic = {}) => {
+  if (!fix || typeof fix !== "object") {
+    return undefined;
+  }
+
+  const normalized = {
+    kind: typeof fix.kind === "string" ? fix.kind : undefined,
+    description: typeof fix.description === "string" && fix.description.trim()
+      ? fix.description.trim()
+      : undefined,
+    safe: fix.safe !== false,
+    confidence: Number.isFinite(fix.confidence) ? Number(fix.confidence) : undefined,
+    filePath: typeof fix.filePath === "string" && fix.filePath
+      ? fix.filePath
+      : (diagnostic.filePath || "unknown"),
+    line: Number.isInteger(fix.line) ? fix.line : undefined,
+    column: Number.isInteger(fix.column) ? fix.column : undefined,
+    endLine: Number.isInteger(fix.endLine) ? fix.endLine : undefined,
+    endColumn: Number.isInteger(fix.endColumn) ? fix.endColumn : undefined,
+    pattern: typeof fix.pattern === "string" && fix.pattern ? fix.pattern : undefined,
+    replacement: typeof fix.replacement === "string" ? fix.replacement : undefined,
+    flags: typeof fix.flags === "string" && fix.flags ? fix.flags : undefined,
+  };
+
+  if (!normalized.kind) {
+    return undefined;
+  }
+
+  return normalized;
+};
+
+const normalizeTrace = (trace = []) => {
+  if (!Array.isArray(trace) || trace.length === 0) {
+    return undefined;
+  }
+
+  const normalized = trace
+    .map((entry) => (entry === null || entry === undefined ? "" : String(entry).trim()))
+    .filter(Boolean)
+    .sort((left, right) => left.localeCompare(right));
+  return normalized.length > 0 ? normalized : undefined;
+};
+
+const normalizeDiagnostics = (diagnostics = []) => {
+  return diagnostics
+    .filter(Boolean)
+    .map((diag) => {
+      const code = diag.code || "RTGL-CHECK-UNKNOWN";
+      const catalog = getDiagnosticCatalogEntry(code);
+      const related = normalizeRelatedLocations(diag.related);
+      const trace = normalizeTrace(diag.trace || related?.map((entry) => entry.message).filter(Boolean));
+      return {
+        code,
+        category: categorizeDiagnosticCode(code),
+        severity: diag.severity === "warn" ? "warn" : "error",
+        message: String(diag.message || "Unknown diagnostic"),
+        filePath: diag.filePath || "unknown",
+        line: Number.isInteger(diag.line) ? diag.line : undefined,
+        column: Number.isInteger(diag.column) ? diag.column : undefined,
+        endLine: Number.isInteger(diag.endLine) ? diag.endLine : undefined,
+        endColumn: Number.isInteger(diag.endColumn) ? diag.endColumn : undefined,
+        title: catalog.title,
+        family: catalog.family,
+        docsPath: catalog.docsPath,
+        namespaceValid: catalog.namespaceValid,
+        tags: catalog.tags,
+        related,
+        trace,
+        fix: normalizeFix(diag.fix, diag),
+      };
+    });
+};
+
+export const analyzeProject = async ({
+  cwd = process.cwd(),
+  dirs = [],
+  workspaceRoot = cwd,
+  includeYahtml = true,
+  includeExpression = false,
+  includeSemantic = false,
+  incrementalState,
+} = {}) => {
+  const discovery = discoverComponentEntries({ cwd, dirs });
+  const componentGroups = groupEntriesByComponent(discovery.entries);
+  const models = (() => {
+    if (!incrementalState || !(incrementalState.componentCache instanceof Map)) {
+      return buildProjectModel(componentGroups);
+    }
+
+    const buildFingerprint = (files = {}) => {
+      return Object.entries(files)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([fileType, filePath]) => {
+          try {
+            const stat = statSync(filePath);
+            return `${fileType}:${filePath}:${stat.mtimeMs}:${stat.size}`;
+          } catch {
+            return `${fileType}:${filePath}:missing`;
+          }
+        })
+        .join("|");
+    };
+
+    const nextCache = new Map();
+    const nextModels = componentGroups.map((componentGroup) => {
+      const fingerprint = buildFingerprint(componentGroup.files);
+      const cached = incrementalState.componentCache.get(componentGroup.componentKey);
+      if (cached && cached.fingerprint === fingerprint) {
+        nextCache.set(componentGroup.componentKey, cached);
+        return cached.model;
+      }
+
+      const model = buildComponentModel(componentGroup);
+      nextCache.set(componentGroup.componentKey, {
+        fingerprint,
+        model,
+      });
+      return model;
+    });
+
+    incrementalState.componentCache = nextCache;
+    return nextModels;
+  })();
+
+  const modelDiagnostics = normalizeDiagnostics(models.flatMap((model) => model.diagnostics || []));
+  const registry = await buildMergedRegistry({ models, workspaceRoot });
+  const ruleDiagnostics = normalizeDiagnostics(runRules({
+    models,
+    registry,
+    includeYahtml,
+    includeExpression,
+  }));
+  const semanticResult = includeSemantic
+    ? runSemanticEngine({ models, registry })
+    : null;
+  const semanticDiagnostics = includeSemantic
+    ? normalizeDiagnostics(semanticResult?.diagnostics || [])
+    : [];
+  const diagnostics = [...modelDiagnostics, ...ruleDiagnostics, ...semanticDiagnostics];
+  const summary = summarizeDiagnostics(diagnostics);
+
+  return {
+    ok: summary.bySeverity.error === 0,
+    cwd,
+    dirs: discovery.resolvedDirs,
+    componentCount: models.length,
+    diagnostics,
+    summary,
+    registryTagCount: registry.size,
+    semantic: semanticResult
+      ? {
+        diagnosticsCount: semanticDiagnostics.length,
+        invariants: semanticResult.invariants,
+      }
+      : undefined,
+  };
+};

package/src/core/discovery.js

@@ -0,0 +1,83 @@
+import path from "node:path";
+import { walkFiles, isDirectoryPath } from "../utils/fs.js";
+
+const FILE_SUFFIX_MAP = [
+  [".view.yaml", "view"],
+  [".schema.yaml", "schema"],
+  [".store.js", "store"],
+  [".handlers.js", "handlers"],
+  [".methods.js", "methods"],
+  [".constants.yaml", "constants"],
+];
+
+export const SUPPORTED_FILE_SUFFIXES = FILE_SUFFIX_MAP.map(([suffix]) => suffix);
+
+const detectFileType = (filePath) => {
+  for (const [suffix, fileType] of FILE_SUFFIX_MAP) {
+    if (filePath.endsWith(suffix)) {
+      return { suffix, fileType };
+    }
+  }
+  return null;
+};
+
+export const resolveDirs = ({ cwd = process.cwd(), dirs = [] }) => {
+  return dirs
+    .map((dirPath) => path.resolve(cwd, dirPath))
+    .filter((dirPath) => isDirectoryPath(dirPath));
+};
+
+export const discoverComponentEntries = ({ cwd = process.cwd(), dirs = [] }) => {
+  const resolvedDirs = resolveDirs({ cwd, dirs });
+  const allFiles = walkFiles(resolvedDirs);
+  const supportedEntries = [];
+
+  allFiles.forEach((filePath) => {
+    const fileTypeInfo = detectFileType(filePath);
+    if (!fileTypeInfo) {
+      return;
+    }
+
+    const normalizedPath = path.resolve(filePath);
+    const fileName = path.basename(normalizedPath);
+    const componentDir = path.basename(path.dirname(normalizedPath));
+    const categoryDir = path.basename(path.dirname(path.dirname(normalizedPath)));
+    const componentNameFromFile = fileName.slice(0, -fileTypeInfo.suffix.length);
+
+    supportedEntries.push({
+      filePath: normalizedPath,
+      fileName,
+      fileType: fileTypeInfo.fileType,
+      category: categoryDir,
+      component: componentDir,
+      componentNameFromFile,
+      componentKey: `${categoryDir}/${componentDir}`,
+    });
+  });
+
+  return {
+    resolvedDirs,
+    allFiles,
+    entries: supportedEntries,
+  };
+};
+
+export const groupEntriesByComponent = (entries = []) => {
+  const byComponent = new Map();
+
+  entries.forEach((entry) => {
+    const existing = byComponent.get(entry.componentKey) || {
+      componentKey: entry.componentKey,
+      category: entry.category,
+      component: entry.component,
+      files: {},
+      entries: [],
+    };
+
+    existing.files[entry.fileType] = entry.filePath;
+    existing.entries.push(entry);
+    byComponent.set(entry.componentKey, existing);
+  });
+
+  return [...byComponent.values()];
+};

package/src/core/exportedFunctions.js

@@ -0,0 +1,235 @@
+import { parseSync } from "oxc-parser";
+
+const createLineOffsets = (source = "") => {
+  const offsets = [0];
+  for (let index = 0; index < source.length; index += 1) {
+    if (source[index] === "\n") {
+      offsets.push(index + 1);
+    }
+  }
+  return offsets;
+};
+
+const offsetToLine = ({ lineOffsets = [], offset = 0 }) => {
+  let low = 0;
+  let high = lineOffsets.length - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const start = lineOffsets[mid];
+    const next = lineOffsets[mid + 1] ?? Number.POSITIVE_INFINITY;
+    if (offset >= start && offset < next) {
+      return mid + 1;
+    }
+    if (offset < start) {
+      high = mid - 1;
+    } else {
+      low = mid + 1;
+    }
+  }
+  return undefined;
+};
+
+const getPropertyKeyName = (keyNode) => {
+  if (!keyNode || typeof keyNode !== "object") {
+    return null;
+  }
+  if (keyNode.type === "Identifier" && typeof keyNode.name === "string" && keyNode.name) {
+    return keyNode.name;
+  }
+  if (keyNode.type === "StringLiteral" && typeof keyNode.value === "string" && keyNode.value) {
+    return keyNode.value;
+  }
+  if (keyNode.type === "Literal" && typeof keyNode.value === "string" && keyNode.value) {
+    return keyNode.value;
+  }
+  return null;
+};
+
+const describeObjectPattern = (pattern = {}) => {
+  if (!pattern || pattern.type !== "ObjectPattern" || !Array.isArray(pattern.properties)) {
+    return null;
+  }
+
+  const keys = new Set();
+  let hasRest = false;
+
+  pattern.properties.forEach((property) => {
+    if (!property || typeof property !== "object") {
+      return;
+    }
+
+    if (property.type === "RestElement") {
+      hasRest = true;
+      return;
+    }
+
+    if (property.type !== "Property" || property.computed) {
+      return;
+    }
+
+    const keyName = getPropertyKeyName(property.key);
+    if (keyName) {
+      keys.add(keyName);
+    }
+  });
+
+  return {
+    kind: "object",
+    objectKeys: [...keys].sort((left, right) => left.localeCompare(right)),
+    hasRest,
+  };
+};
+
+const describeParam = (param = {}) => {
+  if (!param || typeof param !== "object") {
+    return {
+      kind: "unknown",
+      name: null,
+      objectKeys: [],
+      hasRest: false,
+    };
+  }
+
+  if (param.type === "Identifier") {
+    return {
+      kind: "identifier",
+      name: param.name || null,
+      objectKeys: [],
+      hasRest: false,
+    };
+  }
+
+  if (param.type === "AssignmentPattern") {
+    const left = describeParam(param.left);
+    return {
+      ...left,
+      kind: left.kind === "unknown" ? "assignment" : left.kind,
+    };
+  }
+
+  const objectPattern = describeObjectPattern(param);
+  if (objectPattern) {
+    return {
+      kind: "object",
+      name: null,
+      objectKeys: objectPattern.objectKeys,
+      hasRest: objectPattern.hasRest,
+    };
+  }
+
+  return {
+    kind: "pattern",
+    name: null,
+    objectKeys: [],
+    hasRest: false,
+  };
+};
+
+const toFunctionMeta = ({ name, node, lineOffsets = [] }) => {
+  if (!name || !node || typeof node !== "object") {
+    return null;
+  }
+
+  const params = Array.isArray(node.params) ? node.params : [];
+  const firstParam = params.length > 0
+    ? describeParam(params[0])
+    : {
+      kind: "none",
+      name: null,
+      objectKeys: [],
+      hasRest: false,
+    };
+  const secondParam = params.length > 1
+    ? describeParam(params[1])
+    : {
+      kind: "none",
+      name: null,
+      objectKeys: [],
+      hasRest: false,
+    };
+
+  return {
+    name,
+    async: Boolean(node.async),
+    paramCount: params.length,
+    firstParamName: firstParam.name,
+    secondParamName: secondParam.name,
+    firstParam,
+    secondParam,
+    line: offsetToLine({
+      lineOffsets,
+      offset: Number(node.start) || 0,
+    }),
+  };
+};
+
+export const parseNamedExportedFunctions = ({
+  sourceText = "",
+  filePath = "unknown.js",
+} = {}) => {
+  const functions = new Map();
+  let parsed = null;
+
+  try {
+    parsed = parseSync(filePath, sourceText, { sourceType: "unambiguous" });
+  } catch {
+    return functions;
+  }
+
+  if (!parsed?.program?.body || !Array.isArray(parsed.program.body)) {
+    return functions;
+  }
+  if (Array.isArray(parsed.errors) && parsed.errors.length > 0) {
+    return functions;
+  }
+
+  const lineOffsets = createLineOffsets(sourceText);
+
+  parsed.program.body.forEach((statement) => {
+    if (!statement || statement.type !== "ExportNamedDeclaration") {
+      return;
+    }
+
+    const declaration = statement.declaration;
+    if (!declaration) {
+      return;
+    }
+
+    if (declaration.type === "FunctionDeclaration" && declaration.id?.name) {
+      const meta = toFunctionMeta({
+        name: declaration.id.name,
+        node: declaration,
+        lineOffsets,
+      });
+      if (meta) {
+        functions.set(meta.name, meta);
+      }
+      return;
+    }
+
+    if (declaration.type !== "VariableDeclaration" || !Array.isArray(declaration.declarations)) {
+      return;
+    }
+
+    declaration.declarations.forEach((declarator) => {
+      const exportName = declarator?.id?.type === "Identifier" ? declarator.id.name : null;
+      if (!exportName) {
+        return;
+      }
+      const init = declarator.init;
+      if (!init || (init.type !== "ArrowFunctionExpression" && init.type !== "FunctionExpression")) {
+        return;
+      }
+      const meta = toFunctionMeta({
+        name: exportName,
+        node: init,
+        lineOffsets,
+      });
+      if (meta) {
+        functions.set(meta.name, meta);
+      }
+    });
+  });
+
+  return functions;
+};