@beignet/cli 0.0.40 → 0.0.41

package/src/analysis/source-index.ts

@@ -0,0 +1,395 @@
+import ts from "typescript";
+import { type AnalysisWorkspace, resolveLocalSourceFile } from "./workspace.js";
+
+export type AnalysisSourceLocation = {
+  file: string;
+  exportName?: string;
+  line?: number;
+  column?: number;
+};
+
+export type ResolvedSourceReference = {
+  file: string;
+  exportName: string;
+  declaration?: ts.Declaration;
+};
+
+export type LocalImportReference = {
+  file: string;
+  importPath: string;
+  resolvedFile: string;
+  kind: "type" | "value";
+  line: number;
+  column: number;
+};
+
+type ImportBinding =
+  | { kind: "named"; file: string; exportName: string }
+  | { kind: "namespace"; file: string };
+
+type FileIndex = {
+  declarations: Map<string, ts.Declaration>;
+  imports: Map<string, ImportBinding>;
+  reexports: Map<string, { file: string; exportName: string }>;
+  exportStars: string[];
+};
+
+export type SourceIndex = {
+  resolveName(
+    file: string,
+    name: string,
+  ): Promise<ResolvedSourceReference | undefined>;
+  resolveExpression(
+    file: string,
+    expression: ts.Expression,
+  ): Promise<ResolvedSourceReference | undefined>;
+  resolveExport(
+    file: string,
+    exportName: string,
+  ): Promise<ResolvedSourceReference | undefined>;
+  sourceLocation(
+    file: string,
+    node: ts.Node,
+    exportName?: string,
+  ): Promise<AnalysisSourceLocation>;
+};
+
+export function createSourceIndex(workspace: AnalysisWorkspace): SourceIndex {
+  const indexes = new Map<string, FileIndex>();
+
+  const readIndex = async (file: string): Promise<FileIndex> => {
+    const cached = indexes.get(file);
+    if (cached) return cached;
+
+    const sourceFile = await workspace.readSourceFile(file);
+    const index: FileIndex = {
+      declarations: new Map(),
+      imports: new Map(),
+      reexports: new Map(),
+      exportStars: [],
+    };
+    indexes.set(file, index);
+
+    for (const statement of sourceFile.statements) {
+      if (ts.isImportDeclaration(statement)) {
+        const source = moduleText(statement.moduleSpecifier);
+        const target = source
+          ? resolveLocalSourceFile(workspace, file, source)
+          : undefined;
+        if (!target || !statement.importClause) continue;
+
+        if (statement.importClause.name) {
+          index.imports.set(statement.importClause.name.text, {
+            kind: "named",
+            file: target,
+            exportName: "default",
+          });
+        }
+
+        const bindings = statement.importClause.namedBindings;
+        if (bindings && ts.isNamespaceImport(bindings)) {
+          index.imports.set(bindings.name.text, {
+            kind: "namespace",
+            file: target,
+          });
+        } else if (bindings && ts.isNamedImports(bindings)) {
+          for (const element of bindings.elements) {
+            index.imports.set(element.name.text, {
+              kind: "named",
+              file: target,
+              exportName: element.propertyName?.text ?? element.name.text,
+            });
+          }
+        }
+        continue;
+      }
+
+      if (ts.isExportDeclaration(statement)) {
+        const source = statement.moduleSpecifier
+          ? moduleText(statement.moduleSpecifier)
+          : undefined;
+        const target = source
+          ? resolveLocalSourceFile(workspace, file, source)
+          : undefined;
+        if (!target) continue;
+
+        if (!statement.exportClause) {
+          index.exportStars.push(target);
+          continue;
+        }
+
+        if (ts.isNamedExports(statement.exportClause)) {
+          for (const element of statement.exportClause.elements) {
+            index.reexports.set(element.name.text, {
+              file: target,
+              exportName: element.propertyName?.text ?? element.name.text,
+            });
+          }
+        }
+        continue;
+      }
+
+      if (ts.isVariableStatement(statement) && hasExportModifier(statement)) {
+        for (const declaration of statement.declarationList.declarations) {
+          if (ts.isIdentifier(declaration.name)) {
+            index.declarations.set(declaration.name.text, declaration);
+          }
+        }
+        continue;
+      }
+
+      if (
+        (ts.isFunctionDeclaration(statement) ||
+          ts.isClassDeclaration(statement) ||
+          ts.isInterfaceDeclaration(statement) ||
+          ts.isTypeAliasDeclaration(statement) ||
+          ts.isEnumDeclaration(statement)) &&
+        hasExportModifier(statement) &&
+        statement.name
+      ) {
+        index.declarations.set(statement.name.text, statement);
+      }
+    }
+
+    return index;
+  };
+
+  const resolveExport = async (
+    file: string,
+    exportName: string,
+    visited = new Set<string>(),
+  ): Promise<ResolvedSourceReference | undefined> => {
+    const key = `${file}#${exportName}`;
+    if (visited.has(key)) return undefined;
+    visited.add(key);
+
+    const index = await readIndex(file);
+    const declaration = index.declarations.get(exportName);
+    if (declaration) return { file, exportName, declaration };
+
+    const reexport = index.reexports.get(exportName);
+    if (reexport) {
+      return (
+        (await resolveExport(reexport.file, reexport.exportName, visited)) ?? {
+          file: reexport.file,
+          exportName: reexport.exportName,
+        }
+      );
+    }
+
+    for (const target of index.exportStars) {
+      const resolved = await resolveExport(target, exportName, visited);
+      if (resolved) return resolved;
+    }
+
+    return undefined;
+  };
+
+  return {
+    async resolveName(file, name) {
+      const index = await readIndex(file);
+      const local = index.declarations.get(name);
+      if (local) {
+        return { file, exportName: name, declaration: local };
+      }
+
+      const binding = index.imports.get(name);
+      if (binding?.kind !== "named") return undefined;
+      return (
+        (await resolveExport(binding.file, binding.exportName)) ?? {
+          file: binding.file,
+          exportName: binding.exportName,
+        }
+      );
+    },
+    async resolveExpression(file, rawExpression) {
+      const expression = unwrapExpression(rawExpression);
+      const index = await readIndex(file);
+      if (ts.isIdentifier(expression)) {
+        const local = index.declarations.get(expression.text);
+        if (local) {
+          return { file, exportName: expression.text, declaration: local };
+        }
+
+        const binding = index.imports.get(expression.text);
+        if (binding?.kind !== "named") return undefined;
+        return (
+          (await resolveExport(binding.file, binding.exportName)) ?? {
+            file: binding.file,
+            exportName: binding.exportName,
+          }
+        );
+      }
+
+      if (
+        ts.isPropertyAccessExpression(expression) &&
+        ts.isIdentifier(expression.expression)
+      ) {
+        const binding = index.imports.get(expression.expression.text);
+        if (binding?.kind !== "namespace") return undefined;
+        return (
+          (await resolveExport(binding.file, expression.name.text)) ?? {
+            file: binding.file,
+            exportName: expression.name.text,
+          }
+        );
+      }
+
+      return undefined;
+    },
+    resolveExport(file, exportName) {
+      return resolveExport(file, exportName);
+    },
+    async sourceLocation(file, node, exportName) {
+      const sourceFile = await workspace.readSourceFile(file);
+      const position = sourceFile.getLineAndCharacterOfPosition(
+        node.getStart(),
+      );
+      return {
+        file,
+        ...(exportName ? { exportName } : {}),
+        line: position.line + 1,
+        column: position.character + 1,
+      };
+    },
+  };
+}
+
+export function exportedVariableDeclarations(
+  sourceFile: ts.SourceFile,
+): Array<{ exportName: string; declaration: ts.VariableDeclaration }> {
+  const declarations: Array<{
+    exportName: string;
+    declaration: ts.VariableDeclaration;
+  }> = [];
+
+  for (const statement of sourceFile.statements) {
+    if (!ts.isVariableStatement(statement) || !hasExportModifier(statement)) {
+      continue;
+    }
+    for (const declaration of statement.declarationList.declarations) {
+      if (ts.isIdentifier(declaration.name)) {
+        declarations.push({
+          exportName: declaration.name.text,
+          declaration,
+        });
+      }
+    }
+  }
+
+  return declarations;
+}
+
+export function literalText(node: ts.Node | undefined): string | undefined {
+  return node &&
+    (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+    ? node.text
+    : undefined;
+}
+
+export function propertyAssignment(
+  object: ts.ObjectLiteralExpression,
+  name: string,
+): ts.PropertyAssignment | undefined {
+  return object.properties.find(
+    (property): property is ts.PropertyAssignment =>
+      ts.isPropertyAssignment(property) && propertyName(property.name) === name,
+  );
+}
+
+export function propertyName(node: ts.PropertyName): string | undefined {
+  if (ts.isIdentifier(node) || ts.isStringLiteral(node)) return node.text;
+  return undefined;
+}
+
+export function visitCalls(
+  node: ts.Node,
+  visit: (call: ts.CallExpression) => void,
+): void {
+  const walk = (current: ts.Node) => {
+    if (ts.isCallExpression(current)) visit(current);
+    current.forEachChild(walk);
+  };
+  walk(node);
+}
+
+export async function localImportReferences(
+  workspace: AnalysisWorkspace,
+  file: string,
+): Promise<LocalImportReference[]> {
+  const sourceFile = await workspace.readSourceFile(file);
+  const references: LocalImportReference[] = [];
+
+  for (const statement of sourceFile.statements) {
+    if (
+      !ts.isImportDeclaration(statement) &&
+      !ts.isExportDeclaration(statement)
+    ) {
+      continue;
+    }
+    if (!statement.moduleSpecifier) continue;
+
+    const importPath = moduleText(statement.moduleSpecifier);
+    const resolvedFile = importPath
+      ? resolveLocalSourceFile(workspace, file, importPath)
+      : undefined;
+    if (!importPath || !resolvedFile) continue;
+
+    const position = sourceFile.getLineAndCharacterOfPosition(
+      statement.getStart(sourceFile),
+    );
+    const typeOnly = ts.isImportDeclaration(statement)
+      ? Boolean(
+          statement.importClause?.isTypeOnly ||
+            (statement.importClause?.namedBindings &&
+              ts.isNamedImports(statement.importClause.namedBindings) &&
+              statement.importClause.namedBindings.elements.length > 0 &&
+              statement.importClause.namedBindings.elements.every(
+                (element) => element.isTypeOnly,
+              )),
+        )
+      : statement.isTypeOnly ||
+        (statement.exportClause &&
+          ts.isNamedExports(statement.exportClause) &&
+          statement.exportClause.elements.length > 0 &&
+          statement.exportClause.elements.every(
+            (element) => element.isTypeOnly,
+          ));
+    references.push({
+      file,
+      importPath,
+      resolvedFile,
+      kind: typeOnly ? "type" : "value",
+      line: position.line + 1,
+      column: position.character + 1,
+    });
+  }
+
+  return references;
+}
+
+function moduleText(node: ts.Expression): string | undefined {
+  return ts.isStringLiteral(node) ? node.text : undefined;
+}
+
+function hasExportModifier(node: ts.Node): boolean {
+  return Boolean(
+    ts.canHaveModifiers(node) &&
+      ts
+        .getModifiers(node)
+        ?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword),
+  );
+}
+
+function unwrapExpression(expression: ts.Expression): ts.Expression {
+  let current = expression;
+  while (
+    ts.isAsExpression(current) ||
+    ts.isSatisfiesExpression(current) ||
+    ts.isParenthesizedExpression(current) ||
+    ts.isNonNullExpression(current)
+  ) {
+    current = current.expression;
+  }
+  return current;
+}

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];