@beignet/cli 0.0.1 → 0.0.4

package/dist/lint.js

@@ -1,6 +1,11 @@
 import { readdir, readFile, stat } from "node:fs/promises";
 import path from "node:path";
+import { createPainter } from "./ansi.js";
 import { directoryPath, loadBeignetConfig, normalizePath, resolveConfig, } from "./config.js";
+import { formatGithubAnnotation } from "./github-annotations.js";
+/**
+ * Inspect app imports and report dependency-direction violations.
+ */
 export async function lintApp(options = {}) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
     await assertDirectory(targetDir);
@@ -9,34 +14,98 @@ export async function lintApp(options = {}) {
         ? resolveConfig(options.config)
         : await loadBeignetConfig(targetDir, files);
     const diagnostics = [];
-    for (const file of lintSourceFiles(files)) {
+    const sourceFiles = lintSourceFiles(files);
+    const sourceFileSet = new Set(sourceFiles);
+    const sourceByFile = new Map();
+    const importGraph = new Map();
+    for (const file of sourceFiles) {
         const sourceLayer = classifyPath(file, config);
+        const source = await readFile(path.join(targetDir, file), "utf8");
+        sourceByFile.set(file, source);
+        importGraph.set(file, parseImports(source, file, sourceFileSet));
         if (sourceLayer === "test" || sourceLayer === "unknown")
             continue;
-        const source = await readFile(path.join(targetDir, file), "utf8");
-        for (const reference of parseImports(source, file)) {
+        const lineStarts = computeLineStarts(source);
+        for (const reference of importGraph.get(file) ?? []) {
             const diagnostic = lintImport(file, sourceLayer, reference, config);
-            if (diagnostic)
-                diagnostics.push(diagnostic);
+            if (diagnostic) {
+                diagnostics.push({
+                    ...diagnostic,
+                    ...positionFromOffset(lineStarts, reference.offset),
+                });
+            }
         }
     }
+    diagnostics.push(...lintRuntimeBoundary({
+        config,
+        graph: importGraph,
+        sourceByFile,
+    }));
     return {
+        schemaVersion: 1,
         targetDir,
         config,
         diagnostics: dedupeDiagnostics(diagnostics),
     };
 }
-export function formatLint(result) {
+function computeLineStarts(source) {
+    const lineStarts = [0];
+    for (let index = 0; index < source.length; index++) {
+        if (source[index] === "\n") {
+            lineStarts.push(index + 1);
+        }
+    }
+    return lineStarts;
+}
+function positionFromOffset(lineStarts, offset) {
+    let low = 0;
+    let high = lineStarts.length - 1;
+    while (low < high) {
+        const middle = Math.ceil((low + high) / 2);
+        if (lineStarts[middle] <= offset) {
+            low = middle;
+        }
+        else {
+            high = middle - 1;
+        }
+    }
+    return { line: low + 1, column: offset - lineStarts[low] + 1 };
+}
+/**
+ * Format dependency-direction lint diagnostics for CLI output.
+ */
+export function formatLint(result, options = {}) {
+    const paint = createPainter(options.color);
     if (result.diagnostics.length === 0) {
         return `No Beignet lint issues found in ${result.targetDir}.`;
     }
     return [
         `Found ${result.diagnostics.length} Beignet lint issue${result.diagnostics.length === 1 ? "" : "s"} in ${result.targetDir}:`,
         "",
-        ...result.diagnostics.map((diagnostic) => `ERROR ${diagnostic.code} ${diagnostic.file}
+        ...result.diagnostics.map((diagnostic) => `${paint("ERROR", "red")} ${diagnostic.code} ${lintDiagnosticLocation(diagnostic)}
   ${diagnostic.message}`),
     ].join("\n");
 }
+function lintDiagnosticLocation(diagnostic) {
+    if (diagnostic.line === undefined || diagnostic.column === undefined) {
+        return diagnostic.file;
+    }
+    return `${diagnostic.file}:${diagnostic.line}:${diagnostic.column}`;
+}
+/**
+ * Format dependency-direction lint diagnostics as GitHub Actions annotations.
+ */
+export function formatLintGithub(result) {
+    return result.diagnostics
+        .map((diagnostic) => formatGithubAnnotation({
+        severity: "error",
+        file: diagnostic.file,
+        line: diagnostic.line,
+        col: diagnostic.column,
+        message: `${diagnostic.code}: ${diagnostic.message}`,
+    }))
+        .join("\n");
+}
 async function assertDirectory(targetDir) {
     try {
         const stats = await stat(targetDir);
@@ -86,11 +155,11 @@ function lintSourceFiles(files) {
         return /\.(c|m)?tsx?$/.test(file);
     });
 }
-function parseImports(source, importerFile) {
+function parseImports(source, importerFile, files) {
     const references = parseImportSpecifiers(source);
-    return references.map((importPath) => ({
-        importPath,
-        ...resolveImport(importPath, importerFile),
+    return references.map((reference) => ({
+        ...reference,
+        ...resolveImport(reference.importPath, importerFile, files),
     }));
 }
 function parseImportSpecifiers(source) {
@@ -100,15 +169,25 @@ function parseImportSpecifiers(source) {
         index = skipNonCode(source, index);
         if (isKeywordAt(source, index, "import")) {
             const parsed = parseImportSpecifierAt(source, index + "import".length);
-            if (parsed?.specifier)
-                specifiers.push(parsed.specifier);
+            if (parsed?.specifier) {
+                specifiers.push({
+                    importPath: parsed.specifier,
+                    kind: parsed.kind ?? "value",
+                    offset: index,
+                });
+            }
             index = parsed?.end ?? index + "import".length;
             continue;
         }
         if (isKeywordAt(source, index, "export")) {
             const parsed = parseExportSpecifierAt(source, index + "export".length);
-            if (parsed?.specifier)
-                specifiers.push(parsed.specifier);
+            if (parsed?.specifier) {
+                specifiers.push({
+                    importPath: parsed.specifier,
+                    kind: parsed.kind ?? "value",
+                    offset: index,
+                });
+            }
             index = parsed?.end ?? index + "export".length;
             continue;
         }
@@ -132,9 +211,16 @@ function parseImportSpecifierAt(source, index) {
     if (sideEffectImport) {
         return {
             specifier: sideEffectImport.value,
+            kind: "value",
             end: sideEffectImport.end,
         };
     }
+    const importClauseStart = cursor;
+    let isImportType = false;
+    if (isKeywordAt(source, cursor, "type")) {
+        isImportType = true;
+        cursor = cursorAfterKeyword("type", cursor);
+    }
     while (cursor < source.length) {
         cursor = skipWhitespaceAndComments(source, cursor);
         if (source[cursor] === ";" || source[cursor] === "\n") {
@@ -147,6 +233,9 @@ function parseImportSpecifierAt(source, index) {
                 return { end: fromCursor };
             return {
                 specifier: stringLiteral.value,
+                kind: isImportType
+                    ? "type"
+                    : inferImportClauseKind(source.slice(importClauseStart, cursor)),
                 end: stringLiteral.end,
             };
         }
@@ -156,8 +245,15 @@ function parseImportSpecifierAt(source, index) {
 }
 function parseExportSpecifierAt(source, index) {
     let cursor = index;
+    let isExportType = false;
+    const exportClauseStart = cursor;
     while (cursor < source.length) {
         cursor = skipWhitespaceAndComments(source, cursor);
+        if (isKeywordAt(source, cursor, "type")) {
+            isExportType = true;
+            cursor = cursorAfterKeyword("type", cursor);
+            continue;
+        }
         if (source[cursor] === ";" || source[cursor] === "\n") {
             return { end: cursor + 1 };
         }
@@ -168,6 +264,9 @@ function parseExportSpecifierAt(source, index) {
                 return { end: fromCursor };
             return {
                 specifier: stringLiteral.value,
+                kind: isExportType
+                    ? "type"
+                    : inferImportClauseKind(source.slice(exportClauseStart, cursor)),
                 end: stringLiteral.end,
             };
         }
@@ -175,6 +274,13 @@ function parseExportSpecifierAt(source, index) {
     }
     return undefined;
 }
+function inferImportClauseKind(importClause) {
+    const trimmed = importClause.trim();
+    if (/^\{\s*type\s+[^,}]+(?:,\s*type\s+[^,}]+)*,?\s*\}$/.test(trimmed)) {
+        return "type";
+    }
+    return "value";
+}
 function cursorAfterKeyword(keyword, index) {
     return index + keyword.length;
 }
@@ -292,21 +398,42 @@ function isKeywordAt(source, index, keyword) {
 function isIdentifierChar(char) {
     return Boolean(char && /[A-Za-z0-9_$]/.test(char));
 }
-function resolveImport(importPath, importerFile) {
+function resolveImport(importPath, importerFile, files) {
     if (importPath.startsWith("@/")) {
         return {
-            resolvedPath: stripKnownExtension(importPath.slice(2)),
+            resolvedPath: resolveLocalImportPath(stripKnownExtension(importPath.slice(2)), files),
         };
     }
     if (importPath.startsWith(".")) {
         return {
-            resolvedPath: stripKnownExtension(normalizePath(path.join(path.dirname(importerFile), importPath))),
+            resolvedPath: resolveLocalImportPath(stripKnownExtension(normalizePath(path.join(path.dirname(importerFile), importPath))), files),
         };
     }
     return {
         packageName: packageName(importPath),
     };
 }
+function resolveLocalImportPath(importPath, files) {
+    const candidates = [
+        importPath,
+        `${importPath}.ts`,
+        `${importPath}.tsx`,
+        `${importPath}.mts`,
+        `${importPath}.cts`,
+        `${importPath}/index.ts`,
+        `${importPath}/index.tsx`,
+        `${importPath}/index.mts`,
+        `${importPath}/index.cts`,
+    ];
+    for (const candidate of candidates) {
+        for (const file of files) {
+            if (stripKnownExtension(file) === stripKnownExtension(candidate)) {
+                return file;
+            }
+        }
+    }
+    return stripKnownExtension(importPath);
+}
 function packageName(importPath) {
     if (!importPath.startsWith("@"))
         return importPath.split("/")[0];
@@ -317,29 +444,45 @@ function stripKnownExtension(filePath) {
     return filePath.replace(/\.(c|m)?tsx?$/, "");
 }
 function lintImport(file, sourceLayer, reference, config) {
+    if (reference.kind === "type")
+        return undefined;
     const targetLayer = reference.resolvedPath
         ? classifyPath(reference.resolvedPath, config)
         : undefined;
+    const featureImport = reference.resolvedPath
+        ? featureImportViolation(file, sourceLayer, reference.resolvedPath, config)
+        : undefined;
+    if (featureImport) {
+        return {
+            severity: "error",
+            code: "BEIGNET_IMPORT_DIRECTION",
+            file,
+            importPath: reference.importPath,
+            message: featureImport,
+        };
+    }
     const appImport = reference.resolvedPath
         ? appImportViolation(sourceLayer, targetLayer)
         : undefined;
     if (appImport) {
         return {
             severity: "error",
-            code: "CK_IMPORT_DIRECTION",
+            code: "BEIGNET_IMPORT_DIRECTION",
             file,
             importPath: reference.importPath,
             message: appImportMessage(sourceLayer, reference.importPath, appImport),
         };
     }
-    if (reference.packageName &&
-        packageImportViolation(sourceLayer, reference.packageName)) {
+    const bannedPackage = reference.packageName
+        ? packageImportViolation(sourceLayer, reference.importPath)
+        : undefined;
+    if (bannedPackage) {
         return {
             severity: "error",
-            code: "CK_IMPORT_DIRECTION",
+            code: "BEIGNET_IMPORT_DIRECTION",
             file,
             importPath: reference.importPath,
-            message: packageImportMessage(sourceLayer, reference.packageName),
+            message: packageImportMessage(sourceLayer, bannedPackage),
         };
     }
     return undefined;
@@ -362,42 +505,211 @@ function appImportViolation(sourceLayer, targetLayer) {
             "route",
             "server",
             "use-case",
+            "workflow",
         ].includes(targetLayer)) {
         return targetLayer;
     }
-    if (sourceLayer === "use-case" &&
+    if ((sourceLayer === "use-case" || sourceLayer === "workflow") &&
         ["app", "client", "component", "infra", "route", "server"].includes(targetLayer)) {
         return targetLayer;
     }
     if (["feature-port", "policy", "port"].includes(sourceLayer) &&
-        ["app", "client", "component", "infra", "route", "server"].includes(targetLayer)) {
+        [
+            "app",
+            "client",
+            "component",
+            "infra",
+            "route",
+            "server",
+            "workflow",
+        ].includes(targetLayer)) {
         return targetLayer;
     }
     if (sourceLayer === "contract" &&
-        ["app", "client", "component", "infra", "route"].includes(targetLayer)) {
+        ["app", "client", "component", "infra", "route", "workflow"].includes(targetLayer)) {
         return targetLayer;
     }
     if (sourceLayer === "route" &&
-        ["app", "client", "component", "infra"].includes(targetLayer)) {
+        ["app", "client", "component", "infra", "workflow"].includes(targetLayer)) {
+        return targetLayer;
+    }
+    if (sourceLayer === "infra" &&
+        ["app", "client", "component", "route", "server"].includes(targetLayer)) {
         return targetLayer;
     }
     return undefined;
 }
-function packageImportViolation(sourceLayer, packageName) {
+function packageImportViolation(sourceLayer, importPath) {
     if (sourceLayer === "domain") {
-        return (domainBannedPackages.has(packageName) ||
-            packageName.startsWith("@beignet/provider-"));
-    }
-    if (["contract", "feature-port", "policy", "port", "use-case"].includes(sourceLayer)) {
-        return (coreBannedPackages.has(packageName) ||
-            serverRuntimePackages.has(packageName) ||
-            packageName.startsWith("@beignet/provider-"));
+        return (matchBannedPackage(domainBannedPackages, importPath) ??
+            matchBeignetProviderPackage(importPath));
+    }
+    if ([
+        "contract",
+        "feature-port",
+        "policy",
+        "port",
+        "use-case",
+        "workflow",
+    ].includes(sourceLayer)) {
+        return (matchBannedPackage(coreBannedPackages, importPath) ??
+            matchBannedPackage(serverRuntimePackages, importPath) ??
+            matchBeignetProviderPackage(importPath));
     }
     if (sourceLayer === "route") {
-        return (coreBannedPackages.has(packageName) ||
-            packageName.startsWith("@beignet/provider-"));
+        return (matchBannedPackage(coreBannedPackages, importPath) ??
+            matchBeignetProviderPackage(importPath));
+    }
+    return undefined;
+}
+function matchBannedPackage(bannedPackages, importPath) {
+    let candidate = importPath;
+    while (candidate.length > 0) {
+        if (bannedPackages.has(candidate))
+            return candidate;
+        const separator = candidate.lastIndexOf("/");
+        if (separator === -1)
+            return undefined;
+        candidate = candidate.slice(0, separator);
+    }
+    return undefined;
+}
+function matchBeignetProviderPackage(importPath) {
+    const name = packageName(importPath);
+    return name.startsWith("@beignet/provider-") ? name : undefined;
+}
+function lintRuntimeBoundary({ config, graph, sourceByFile, }) {
+    const diagnostics = [];
+    for (const file of graph.keys()) {
+        const rootKind = runtimeBoundaryRootKind(file, sourceByFile.get(file) ?? "", config);
+        if (!rootKind)
+            continue;
+        diagnostics.push(...lintRuntimeBoundaryRoot({
+            root: file,
+            rootKind,
+            config,
+            graph,
+        }));
+    }
+    return diagnostics;
+}
+function lintRuntimeBoundaryRoot({ root, rootKind, config, graph, }) {
+    const diagnostics = [];
+    const visited = new Set();
+    const queue = [
+        { file: root, chain: [root] },
+    ];
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current)
+            continue;
+        if (visited.has(current.file))
+            continue;
+        visited.add(current.file);
+        for (const reference of graph.get(current.file) ?? []) {
+            if (reference.kind === "type" &&
+                reference.importPath !== "@beignet/core/server-only") {
+                continue;
+            }
+            const chain = reference.resolvedPath
+                ? [...current.chain, reference.resolvedPath]
+                : current.chain;
+            const violation = runtimeBoundaryViolation(reference, config);
+            if (violation) {
+                diagnostics.push({
+                    severity: "error",
+                    code: "BEIGNET_RUNTIME_BOUNDARY",
+                    file: root,
+                    importPath: reference.importPath,
+                    message: runtimeBoundaryMessage(rootKind, violation, chain),
+                });
+                continue;
+            }
+            if (reference.resolvedPath && graph.has(reference.resolvedPath)) {
+                queue.push({
+                    file: reference.resolvedPath,
+                    chain,
+                });
+            }
+        }
+    }
+    return diagnostics;
+}
+function runtimeBoundaryRootKind(file, source, config) {
+    const layer = classifyPath(file, config);
+    if (layer === "contract")
+        return "contract";
+    if (layer === "client")
+        return "client";
+    if (hasUseClientDirective(source))
+        return "client";
+    if (isGeneratedClientAdapter(file))
+        return "client";
+    return undefined;
+}
+function hasUseClientDirective(source) {
+    const trimmed = source.trimStart();
+    return (trimmed.startsWith('"use client";') ||
+        trimmed.startsWith('"use client"') ||
+        trimmed.startsWith("'use client';") ||
+        trimmed.startsWith("'use client'"));
+}
+function isGeneratedClientAdapter(file) {
+    return (file === "client/index.ts" ||
+        file === "client/api-client.ts" ||
+        file === "client/rhf.ts" ||
+        file === "client/rq.ts" ||
+        file === "client/uploads.ts");
+}
+function runtimeBoundaryViolation(reference, config) {
+    if (reference.resolvedPath) {
+        const targetLayer = classifyPath(reference.resolvedPath, config);
+        if (targetLayer === "use-case" ||
+            targetLayer === "route" ||
+            targetLayer === "infra" ||
+            targetLayer === "server") {
+            return `${layerLabel(targetLayer)} module ${reference.resolvedPath}`;
+        }
+        if (targetLayer === "app-context") {
+            return `app context module ${reference.resolvedPath}`;
+        }
+    }
+    if (reference.importPath === "@beignet/core/server-only") {
+        return "server-only marker @beignet/core/server-only";
+    }
+    if (reference.importPath.startsWith("node:")) {
+        return `Node runtime module ${reference.importPath}`;
+    }
+    if (serverRuntimePackages.has(reference.importPath) ||
+        reference.importPath.startsWith("@beignet/provider-")) {
+        return `server runtime package ${reference.importPath}`;
+    }
+    return undefined;
+}
+function runtimeBoundaryMessage(rootKind, violation, chain) {
+    return `${rootKindLabel(rootKind)} roots must not value-import server-only code. Reached ${violation} through ${formatImportChain(chain)}. Move shared DTO and validation schemas to features/<feature>/schemas.ts, keep use cases/routes/infra/server modules behind server entrypoints, or import server-shaped modules with import type only.`;
+}
+function rootKindLabel(rootKind) {
+    return rootKind === "contract" ? "contract" : "client";
+}
+function formatImportChain(chain) {
+    return chain.join(" -> ");
+}
+function featureImportViolation(file, sourceLayer, resolvedPath, config) {
+    if (sourceLayer !== "domain")
+        return undefined;
+    const sourceFeature = featureLayerInfo(file, config);
+    const targetFeature = featureLayerInfo(resolvedPath, config);
+    if (!sourceFeature || !targetFeature)
+        return undefined;
+    if (sourceFeature.layer !== "domain" || targetFeature.layer !== "domain") {
+        return undefined;
     }
-    return false;
+    if (sourceFeature.feature === targetFeature.feature)
+        return undefined;
+    if (targetFeature.feature === "shared")
+        return undefined;
+    return `feature-specific domain files must not import another feature's domain (${stripKnownExtension(resolvedPath)}). Move shared concepts to features/shared/domain.`;
 }
 const domainBannedPackages = new Set([
     "@aws-sdk/client-s3",
@@ -520,6 +832,16 @@ function classifyPath(filePath, config) {
             return "policy";
         if (layerSegment === "use-cases")
             return "use-case";
+        if ([
+            "jobs",
+            "listeners",
+            "notifications",
+            "schedules",
+            "tasks",
+            "uploads",
+        ].includes(layerSegment)) {
+            return "workflow";
+        }
         if (layerSegment === "components")
             return "component";
     }
@@ -551,6 +873,16 @@ function featureRelativePath(filePath, featuresPath) {
     const prefix = `${directoryPath(featuresPath)}/`;
     return filePath.slice(prefix.length);
 }
+function featureLayerInfo(filePath, config) {
+    const normalizedPath = stripKnownExtension(normalizePath(filePath));
+    const relativePath = featureRelativePath(normalizedPath, directoryPath(config.paths.features));
+    if (!relativePath)
+        return undefined;
+    const [feature, layer] = relativePath.split("/");
+    if (!feature)
+        return undefined;
+    return { feature, layer };
+}
 function sharedDomainPath(config) {
     const featuresDir = directoryPath(config.paths.features);
     const featuresParent = directoryPath(path.dirname(featuresDir));