@osovv/grace-cli 3.1.0 → 3.3.0

package/src/grace.ts

@@ -7,7 +7,7 @@ import { lintCommand } from "./grace-lint";
 const main = defineCommand({
   meta: {
     name: "grace",
-    version: "3.1.0",
+    version: "3.3.0",
     description: "GRACE CLI for linting semantic markup and GRACE project artifacts.",
   },
   subCommands: {

package/src/lint/adapters/base.ts

@@ -0,0 +1,11 @@
+import path from "node:path";
+
+import type { LanguageAdapter } from "../types";
+import { createTypeScriptAdapter } from "./typescript";
+
+const adapters: LanguageAdapter[] = [createTypeScriptAdapter()];
+
+export function getLanguageAdapter(filePath: string) {
+  const normalizedPath = path.normalize(filePath);
+  return adapters.find((adapter) => adapter.supports(normalizedPath)) ?? null;
+}

package/src/lint/adapters/typescript.ts

@@ -0,0 +1,185 @@
+import path from "node:path";
+import ts from "typescript";
+
+import type { LanguageAdapter, LanguageAnalysis } from "../types";
+
+const TS_EXTENSIONS = new Set([".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs", ".mts", ".cts"]);
+const TEST_IMPORTS = new Set(["bun:test", "vitest", "jest", "@jest/globals", "node:test"]);
+const TEST_CALLS = new Set(["describe", "it", "test", "beforeEach", "afterEach", "beforeAll", "afterAll", "suite"]);
+
+function getScriptKind(filePath: string) {
+  const ext = path.extname(filePath);
+  switch (ext) {
+    case ".js":
+    case ".mjs":
+    case ".cjs":
+      return ts.ScriptKind.JS;
+    case ".jsx":
+      return ts.ScriptKind.JSX;
+    case ".tsx":
+      return ts.ScriptKind.TSX;
+    default:
+      return ts.ScriptKind.TS;
+  }
+}
+
+function hasExportModifier(node: ts.Node) {
+  return (ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+
+function hasDefaultModifier(node: ts.Node) {
+  return (ts.canHaveModifiers(node) ? ts.getModifiers(node) : undefined)?.some((modifier) => modifier.kind === ts.SyntaxKind.DefaultKeyword) ?? false;
+}
+
+function addExport(
+  analysis: LanguageAnalysis,
+  name: string,
+  kind: "value" | "type",
+  options: { local?: boolean; defaultExport?: boolean } = {},
+) {
+  analysis.exports.add(name);
+  if (kind === "type") {
+    analysis.typeExports.add(name);
+  } else {
+    analysis.valueExports.add(name);
+  }
+
+  if (options.local) {
+    analysis.localExportCount += 1;
+  }
+
+  if (options.defaultExport) {
+    analysis.hasDefaultExport = true;
+  }
+}
+
+export function createTypeScriptAdapter(): LanguageAdapter {
+  return {
+    id: "js-ts",
+    supports(filePath) {
+      return TS_EXTENSIONS.has(path.extname(filePath));
+    },
+    analyze(filePath, text) {
+      const sourceFile = ts.createSourceFile(
+        filePath,
+        text,
+        ts.ScriptTarget.Latest,
+        true,
+        getScriptKind(filePath),
+      );
+
+      const analysis: LanguageAnalysis = {
+        adapterId: "js-ts",
+        exports: new Set<string>(),
+        valueExports: new Set<string>(),
+        typeExports: new Set<string>(),
+        hasDefaultExport: false,
+        hasWildcardReExport: false,
+        directReExportCount: 0,
+        localExportCount: 0,
+        localImplementationCount: 0,
+        usesTestFramework: false,
+      };
+
+      for (const statement of sourceFile.statements) {
+        if (ts.isImportDeclaration(statement)) {
+          const importSource = ts.isStringLiteral(statement.moduleSpecifier)
+            ? statement.moduleSpecifier.text
+            : null;
+          if (importSource && TEST_IMPORTS.has(importSource)) {
+            analysis.usesTestFramework = true;
+          }
+          continue;
+        }
+
+        if (ts.isExpressionStatement(statement)) {
+          const expression = statement.expression;
+          if (ts.isCallExpression(expression) && ts.isIdentifier(expression.expression) && TEST_CALLS.has(expression.expression.text)) {
+            analysis.usesTestFramework = true;
+          }
+        }
+
+        if (ts.isExportAssignment(statement)) {
+          analysis.localImplementationCount += 1;
+          addExport(analysis, "default", "value", { local: true, defaultExport: true });
+          continue;
+        }
+
+        if (ts.isExportDeclaration(statement)) {
+          const isReExport = Boolean(statement.moduleSpecifier);
+          if (isReExport) {
+            analysis.directReExportCount += 1;
+          }
+
+          if (!statement.exportClause) {
+            analysis.hasWildcardReExport = true;
+            continue;
+          }
+
+          if (ts.isNamedExports(statement.exportClause)) {
+            for (const element of statement.exportClause.elements) {
+              const exportName = element.name.text;
+              const isTypeOnly = statement.isTypeOnly || element.isTypeOnly;
+              addExport(analysis, exportName, isTypeOnly ? "type" : "value", isReExport ? {} : { local: true });
+            }
+          }
+          continue;
+        }
+
+        if (ts.isVariableStatement(statement) && hasExportModifier(statement)) {
+          analysis.localImplementationCount += 1;
+          for (const declaration of statement.declarationList.declarations) {
+            if (ts.isIdentifier(declaration.name)) {
+              addExport(analysis, declaration.name.text, "value", { local: true });
+            }
+          }
+          continue;
+        }
+
+        if (ts.isFunctionDeclaration(statement) && hasExportModifier(statement)) {
+          analysis.localImplementationCount += 1;
+          if (hasDefaultModifier(statement)) {
+            addExport(analysis, "default", "value", { local: true, defaultExport: true });
+          } else if (statement.name) {
+            addExport(analysis, statement.name.text, "value", { local: true });
+          }
+          continue;
+        }
+
+        if (ts.isClassDeclaration(statement) && hasExportModifier(statement)) {
+          analysis.localImplementationCount += 1;
+          if (hasDefaultModifier(statement)) {
+            addExport(analysis, "default", "value", { local: true, defaultExport: true });
+          } else if (statement.name) {
+            addExport(analysis, statement.name.text, "value", { local: true });
+          }
+          continue;
+        }
+
+        if (ts.isInterfaceDeclaration(statement) && hasExportModifier(statement)) {
+          addExport(analysis, statement.name.text, "type", { local: true });
+          continue;
+        }
+
+        if (ts.isTypeAliasDeclaration(statement) && hasExportModifier(statement)) {
+          addExport(analysis, statement.name.text, "type", { local: true });
+          continue;
+        }
+
+        if (ts.isEnumDeclaration(statement) && hasExportModifier(statement)) {
+          analysis.localImplementationCount += 1;
+          addExport(analysis, statement.name.text, "value", { local: true });
+          continue;
+        }
+
+        if (ts.isModuleDeclaration(statement) && hasExportModifier(statement)) {
+          analysis.localImplementationCount += 1;
+          addExport(analysis, statement.name.getText(sourceFile), "value", { local: true });
+          continue;
+        }
+      }
+
+      return analysis;
+    },
+  };
+}

package/src/lint/config.ts

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+
+import type { GraceLintConfig, LintIssue } from "./types";
+
+const CONFIG_FILE_NAME = ".grace-lint.json";
+const SUPPORTED_KEYS = new Set(["ignoredDirs"]);
+
+export function loadGraceLintConfig(projectRoot: string) {
+  const configPath = path.join(projectRoot, CONFIG_FILE_NAME);
+  if (!existsSync(configPath)) {
+    return { config: null as GraceLintConfig | null, issues: [] as LintIssue[] };
+  }
+
+  try {
+    const parsed = JSON.parse(readFileSync(configPath, "utf8")) as GraceLintConfig;
+    const issues: LintIssue[] = [];
+
+    if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") {
+      issues.push({
+        severity: "error",
+        code: "config.invalid-shape",
+        file: CONFIG_FILE_NAME,
+        message: `${CONFIG_FILE_NAME} must contain a JSON object.`,
+      });
+      return { config: parsed, issues };
+    }
+
+    for (const key of Object.keys(parsed)) {
+      if (SUPPORTED_KEYS.has(key)) {
+        continue;
+      }
+
+      issues.push({
+        severity: "error",
+        code: "config.unknown-key",
+        file: CONFIG_FILE_NAME,
+        message: `Unsupported key \`${key}\` in ${CONFIG_FILE_NAME}. Supported keys: ignoredDirs.`,
+      });
+    }
+
+    if (parsed.ignoredDirs && !Array.isArray(parsed.ignoredDirs)) {
+      issues.push({
+        severity: "error",
+        code: "config.invalid-ignored-dirs",
+        file: CONFIG_FILE_NAME,
+        message: `\`ignoredDirs\` in ${CONFIG_FILE_NAME} must be an array of directory names.`,
+      });
+    }
+
+    return { config: parsed, issues };
+  } catch (error) {
+    return {
+      config: null,
+      issues: [
+        {
+          severity: "error",
+          code: "config.invalid-json",
+          file: CONFIG_FILE_NAME,
+          message: `Failed to parse ${CONFIG_FILE_NAME}: ${error instanceof Error ? error.message : String(error)}`,
+        },
+      ],
+    };
+  }
+}