@beignet/cli 0.0.48 → 0.0.49

package/src/analysis/layers.ts

@@ -0,0 +1,266 @@
+import path from "node:path";
+import {
+  clientDirPath,
+  directoryPath,
+  normalizePath,
+  type ResolvedBeignetConfig,
+} from "../config.js";
+
+export type SourceLayer =
+  | "app"
+  | "app-context"
+  | "agent-capability"
+  | "client"
+  | "component"
+  | "contract"
+  | "domain"
+  | "feature-helper"
+  | "feature-port"
+  | "infra"
+  | "lib"
+  | "policy"
+  | "port"
+  | "route"
+  | "schema"
+  | "seed"
+  | "server"
+  | "test"
+  | "use-case"
+  | "workflow"
+  | "unknown";
+
+type FeatureLayerConvention = {
+  path: string;
+  layer: SourceLayer;
+};
+
+const canonicalFeatureDirectories = {
+  client: "client",
+  components: "component",
+  domain: "domain",
+  jobs: "workflow",
+  listeners: "workflow",
+  notifications: "workflow",
+  schedules: "workflow",
+  seeds: "seed",
+  tasks: "workflow",
+  tests: "test",
+  uploads: "workflow",
+  "use-cases": "use-case",
+} as const satisfies Record<string, SourceLayer>;
+
+const canonicalFeatureRootFiles = {
+  "agent-capabilities": "agent-capability",
+  contracts: "contract",
+  policy: "policy",
+  ports: "feature-port",
+  routes: "route",
+  schemas: "schema",
+} as const satisfies Record<string, SourceLayer>;
+
+const featureDirectoryAliases = {
+  command: "tasks",
+  commands: "tasks",
+  event: "domain/events",
+  events: "domain/events",
+  job: "jobs",
+  listener: "listeners",
+  notification: "notifications",
+  schedule: "schedules",
+  scheduled: "schedules",
+  task: "tasks",
+  upload: "uploads",
+} as const;
+
+export function classifySourcePath(
+  filePath: string,
+  config: ResolvedBeignetConfig,
+): SourceLayer {
+  const normalizedPath = stripKnownExtension(normalizePath(filePath));
+  const featuresPath = directoryPath(config.paths.features);
+  const portsDir = directoryPath(path.dirname(config.paths.ports));
+
+  if (
+    isTestPath(normalizedPath) ||
+    isUnder(normalizedPath, directoryPath(config.paths.tests))
+  ) {
+    return "test";
+  }
+  if (normalizedPath === stripKnownExtension(config.paths.appContext)) {
+    return "app-context";
+  }
+
+  const featurePath = featureRelativePath(normalizedPath, featuresPath);
+  if (featurePath) {
+    const layerSegment = featurePath.split("/")[1];
+    if (!layerSegment) return "feature-helper";
+    const convention = featureDirectoryConvention(layerSegment);
+    if (convention) return convention.layer;
+    const rootConvention = featureRootFileConvention(layerSegment);
+    if (rootConvention) return rootConvention.layer;
+    if (layerSegment.endsWith("-contracts")) return "contract";
+    return "feature-helper";
+  }
+
+  if (
+    directoryPath(config.paths.contracts) !== featuresPath &&
+    isUnder(normalizedPath, directoryPath(config.paths.contracts))
+  ) {
+    return "contract";
+  }
+  if (
+    directoryPath(config.paths.useCases) !== featuresPath &&
+    isUnder(normalizedPath, directoryPath(config.paths.useCases))
+  ) {
+    return "use-case";
+  }
+  if (
+    directoryPath(config.paths.policies) !== featuresPath &&
+    isUnder(normalizedPath, directoryPath(config.paths.policies))
+  ) {
+    return "policy";
+  }
+
+  if (
+    isUnder(normalizedPath, directoryPath(path.dirname(config.paths.server)))
+  ) {
+    return "server";
+  }
+  if (
+    isUnder(
+      normalizedPath,
+      directoryPath(path.dirname(config.paths.portWiring)),
+    )
+  ) {
+    return "infra";
+  }
+  if (isUnder(normalizedPath, portsDir)) return "port";
+  if (isUnder(normalizedPath, clientDirPath(config))) return "client";
+  if (isUnder(normalizedPath, "components")) return "component";
+  if (isUnder(normalizedPath, legacySharedDomainPath(config))) return "domain";
+  if (isUnder(normalizedPath, "lib")) return "lib";
+  if (
+    isUnder(normalizedPath, directoryPath(path.dirname(config.paths.routes)))
+  ) {
+    return "app";
+  }
+
+  return "unknown";
+}
+
+export function canonicalFeatureLayerPath(
+  filePath: string,
+  config: ResolvedBeignetConfig,
+): string | undefined {
+  const featuresPath = directoryPath(config.paths.features);
+  const relativePath = featureRelativePath(
+    normalizePath(filePath),
+    featuresPath,
+  );
+  if (!relativePath) return undefined;
+
+  const [feature, segment, ...rest] = relativePath.split("/");
+  if (!feature || !segment) return undefined;
+
+  if (isTestSourceFile(segment, rest) && segment !== "tests") {
+    return path.posix.join(
+      featuresPath,
+      feature,
+      "tests",
+      ...(rest.length > 0 ? rest : [segment]),
+    );
+  }
+
+  if (rest.length > 0) {
+    const convention = featureDirectoryConvention(segment);
+    if (!convention || convention.path === segment) return undefined;
+    return path.posix.join(featuresPath, feature, convention.path, ...rest);
+  }
+
+  const extension = path.posix.extname(segment);
+  const stem = extension ? segment.slice(0, -extension.length) : segment;
+  const convention = featureRootFileConvention(stem);
+  if (!convention || convention.path === stem) return undefined;
+  return path.posix.join(
+    featuresPath,
+    feature,
+    `${convention.path}${extension}`,
+  );
+}
+
+function isTestSourceFile(segment: string, rest: string[]): boolean {
+  const fileName = rest.at(-1) ?? segment;
+  return /\.(?:test|spec)\.(?:ts|tsx|mts|cts)$/.test(fileName);
+}
+
+function featureDirectoryConvention(
+  segment: string,
+): FeatureLayerConvention | undefined {
+  const canonical = Object.entries(canonicalFeatureDirectories).find(
+    ([candidate]) =>
+      normalizeLayerSegment(candidate) === normalizeLayerSegment(segment),
+  );
+  if (canonical) return { path: canonical[0], layer: canonical[1] };
+
+  const alias =
+    featureDirectoryAliases[
+      normalizeLayerSegment(segment) as keyof typeof featureDirectoryAliases
+    ];
+  if (!alias) return undefined;
+  return {
+    path: alias,
+    layer:
+      alias === "domain/events"
+        ? "domain"
+        : canonicalFeatureDirectories[
+            alias as keyof typeof canonicalFeatureDirectories
+          ],
+  };
+}
+
+function featureRootFileConvention(
+  segment: string,
+): FeatureLayerConvention | undefined {
+  const canonical = Object.entries(canonicalFeatureRootFiles).find(
+    ([candidate]) =>
+      normalizeLayerSegment(candidate) === normalizeLayerSegment(segment),
+  );
+  return canonical ? { path: canonical[0], layer: canonical[1] } : undefined;
+}
+
+function normalizeLayerSegment(segment: string): string {
+  return segment.replaceAll("-", "").replaceAll("_", "").toLowerCase();
+}
+
+function stripKnownExtension(filePath: string): string {
+  return filePath.replace(/\.(c|m)?tsx?$/, "");
+}
+
+function isTestPath(filePath: string): boolean {
+  return (
+    filePath.includes("/tests/") ||
+    filePath.endsWith(".test") ||
+    filePath.endsWith(".spec")
+  );
+}
+
+function isUnder(filePath: string, directory: string): boolean {
+  const normalizedDir = directoryPath(directory);
+  if (!normalizedDir || normalizedDir === ".") return false;
+  return filePath === normalizedDir || filePath.startsWith(`${normalizedDir}/`);
+}
+
+function featureRelativePath(
+  filePath: string,
+  featuresPath: string,
+): string | undefined {
+  if (!isUnder(filePath, featuresPath)) return undefined;
+  return filePath.slice(`${directoryPath(featuresPath)}/`.length);
+}
+
+function legacySharedDomainPath(config: ResolvedBeignetConfig): string {
+  const featuresDir = directoryPath(config.paths.features);
+  const featuresParent = directoryPath(path.dirname(featuresDir));
+  if (!featuresParent || featuresParent === ".") return "domain";
+  return path.join(featuresParent, "domain");
+}