@beignet/cli 0.0.40 → 0.0.42

package/src/analysis/workspace.ts

@@ -0,0 +1,180 @@
+import { readdir, readFile, stat } from "node:fs/promises";
+import path from "node:path";
+import ts from "typescript";
+import {
+  directoryPath,
+  loadBeignetConfig,
+  normalizePath,
+  type ResolvedBeignetConfig,
+} from "../config.js";
+
+const ignoredDirectoryNames = new Set([
+  ".git",
+  ".next",
+  ".turbo",
+  "coverage",
+  "dist",
+  "node_modules",
+]);
+
+export type AnalysisWorkspace = {
+  targetDir: string;
+  files: string[];
+  fileSet: Set<string>;
+  config: ResolvedBeignetConfig;
+  atAliasRoot: string;
+  readSource(file: string): Promise<string>;
+  readSourceFile(file: string): Promise<ts.SourceFile>;
+};
+
+export async function createAnalysisWorkspace(
+  cwd = process.cwd(),
+): Promise<AnalysisWorkspace> {
+  const targetDir = path.resolve(cwd);
+  await assertDirectory(targetDir);
+  const files = await listProjectFiles(targetDir);
+  const fileSet = new Set(files);
+  const config = await loadBeignetConfig(targetDir, files);
+  const atAliasRoot = resolveAtAliasRoot(targetDir);
+  const sources = new Map<string, string>();
+  const sourceFiles = new Map<string, ts.SourceFile>();
+
+  const readSource = async (file: string): Promise<string> => {
+    const cached = sources.get(file);
+    if (cached !== undefined) return cached;
+
+    const source = await readFile(path.join(targetDir, file), "utf8");
+    sources.set(file, source);
+    return source;
+  };
+
+  return {
+    targetDir,
+    files,
+    fileSet,
+    config,
+    atAliasRoot,
+    readSource,
+    async readSourceFile(file) {
+      const cached = sourceFiles.get(file);
+      if (cached) return cached;
+
+      const sourceFile = ts.createSourceFile(
+        file,
+        await readSource(file),
+        ts.ScriptTarget.Latest,
+        true,
+        scriptKind(file),
+      );
+      sourceFiles.set(file, sourceFile);
+      return sourceFile;
+    },
+  };
+}
+
+export async function assertDirectory(targetDir: string): Promise<void> {
+  try {
+    const stats = await stat(targetDir);
+    if (!stats.isDirectory()) {
+      throw new Error(`${targetDir} is not a directory.`);
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("not a directory")) {
+      throw error;
+    }
+    throw new Error(`Directory ${targetDir} does not exist.`);
+  }
+}
+
+export async function listProjectFiles(targetDir: string): Promise<string[]> {
+  const files: string[] = [];
+
+  async function visit(relativeDir: string): Promise<void> {
+    const absoluteDir = path.join(targetDir, relativeDir);
+    const entries = await readdir(absoluteDir, { withFileTypes: true });
+
+    for (const entry of entries) {
+      if (ignoredDirectoryNames.has(entry.name)) continue;
+
+      const relativePath = normalizePath(path.join(relativeDir, entry.name));
+      if (entry.isDirectory()) {
+        await visit(relativePath);
+      } else if (entry.isFile()) {
+        files.push(relativePath);
+      }
+    }
+  }
+
+  await visit("");
+  return files.sort();
+}
+
+export function resolveLocalSourceFile(
+  workspace: Pick<AnalysisWorkspace, "atAliasRoot" | "fileSet">,
+  importerFile: string,
+  importPath: string,
+): string | undefined {
+  let candidate: string;
+  if (importPath.startsWith("@/")) {
+    candidate = path.posix.join(
+      workspace.atAliasRoot,
+      importPath.slice("@/".length),
+    );
+  } else if (importPath.startsWith(".")) {
+    candidate = normalizePath(
+      path.join(path.dirname(importerFile), importPath),
+    );
+  } else {
+    return undefined;
+  }
+
+  const withoutExtension = candidate.replace(/\.(c|m)?tsx?$/, "");
+  const candidates = [
+    candidate,
+    `${withoutExtension}.ts`,
+    `${withoutExtension}.tsx`,
+    `${withoutExtension}.mts`,
+    `${withoutExtension}.cts`,
+    `${withoutExtension}/index.ts`,
+    `${withoutExtension}/index.tsx`,
+    `${withoutExtension}/index.mts`,
+    `${withoutExtension}/index.cts`,
+  ];
+
+  return candidates.find((file) => workspace.fileSet.has(file));
+}
+
+function resolveAtAliasRoot(targetDir: string): string {
+  const parsed = ts.getParsedCommandLineOfConfigFile(
+    path.join(targetDir, "tsconfig.json"),
+    {},
+    {
+      ...ts.sys,
+      onUnRecoverableConfigFileDiagnostic: () => {},
+    },
+  );
+  const aliasTarget = parsed?.options.paths?.["@/*"]?.[0];
+  if (!aliasTarget) return "";
+
+  const targetWithoutWildcard = aliasTarget.replace(/[/\\]?\*$/, "");
+  const baseUrl = parsed.options.baseUrl ?? targetDir;
+  const relativeTarget = normalizePath(
+    path.relative(targetDir, path.resolve(baseUrl, targetWithoutWildcard)),
+  );
+  if (
+    relativeTarget === "" ||
+    relativeTarget === "." ||
+    relativeTarget === ".." ||
+    relativeTarget.startsWith("../")
+  ) {
+    return "";
+  }
+  return directoryPath(relativeTarget);
+}
+
+function scriptKind(file: string): ts.ScriptKind {
+  if (file.endsWith(".tsx")) return ts.ScriptKind.TSX;
+  if (file.endsWith(".jsx")) return ts.ScriptKind.JSX;
+  if (file.endsWith(".js") || file.endsWith(".mjs")) return ts.ScriptKind.JS;
+  return ts.ScriptKind.TS;
+}

package/src/app-map-schema.ts

@@ -0,0 +1,28 @@
+/** Node kinds emitted by the version 1 Beignet app-map schema. */
+export const appMapNodeKinds = [
+  "feature",
+  "contract",
+  "route",
+  "route-group",
+  "use-case",
+  "policy",
+  "ability",
+  "event",
+  "listener",
+  "job",
+  "schedule",
+  "task",
+  "notification",
+  "upload",
+  "agent-capability",
+  "registry",
+  "port",
+  "provider",
+  "table",
+  "openapi",
+  "entrypoint",
+  "test",
+] as const;
+
+/** One node-kind value from the version 1 Beignet app-map schema. */
+export type AppMapNodeKind = (typeof appMapNodeKinds)[number];