@akanjs/devkit 3.0.0-alpha.75 → 3.0.0-alpha.77

package/slicePlanner.ts

@@ -0,0 +1,157 @@
+import type { AppExecutor } from "./executors";
+import { AppInfo } from "./scanInfo";
+import type { PackageJson } from "./types";
+
+export interface SlicePlan {
+  app: string;
+  /** Transitive lib closure, in mount order. */
+  libs: string[];
+  appFiles: string[];
+  libFiles: Record<string, string[]>;
+  rootFiles: string[];
+  /** Root manifest for a workspace holding only this slice. */
+  packageJson: PackageJson;
+  /** Root dependencies nothing in the slice imports — prune candidates for a human, never pruned here. */
+  unusedDependencies: string[];
+  warnings: string[];
+}
+
+/**
+ * The exact file set a single app needs to live in a workspace of its own: the app, its transitive lib
+ * closure, the workspace shell around them, and a root manifest for the result.
+ *
+ * Consumed by `akan plan-slice`, and by anything that moves an app or a lib between workspaces.
+ */
+export class SlicePlanner {
+  /** Root entries owned by an app, a lib or an in-tree package rather than by the workspace shell. */
+  static readonly memberDirs = ["apps", "libs", "pkgs"];
+  /** Never reported unused: the toolchain a workspace needs whether or not app code imports it. */
+  static readonly toolchainDependencies = [
+    "@akanjs/cli",
+    "@akanjs/devkit",
+    "@biomejs/biome",
+    "@types/bun",
+    "akanjs",
+    "typescript",
+  ];
+
+  #app: AppExecutor;
+  constructor(app: AppExecutor) {
+    this.#app = app;
+  }
+
+  async #trackedFiles(paths: string[]) {
+    return await this.#app.workspace.listGitFiles(paths);
+  }
+
+  async #untrackedFiles(paths: string[]) {
+    const [tracked, all] = await Promise.all([
+      this.#app.workspace.listGitFiles(paths),
+      this.#app.workspace.listGitFiles(paths, { untracked: true }),
+    ]);
+    const trackedSet = new Set(tracked);
+    return all.filter((file) => !trackedSet.has(file));
+  }
+
+  #isMemberFile(file: string) {
+    return SlicePlanner.memberDirs.includes(file.split("/")[0] ?? "");
+  }
+
+  static #requiredDependencies(appInfo: AppInfo) {
+    const scanResults = [
+      appInfo.getScanResult(),
+      ...[...appInfo.getLibInfos().values()].map((lib) => lib.getScanResult()),
+    ];
+    return new Set([
+      ...SlicePlanner.toolchainDependencies,
+      ...scanResults.flatMap((scanResult) => [
+        ...scanResult.dependencies,
+        ...scanResult.devDependencies,
+        ...scanResult.pkgDeps,
+      ]),
+    ]);
+  }
+
+  async #patchWarnings(packageJson: PackageJson) {
+    const patchedDependencies = (packageJson.patchedDependencies ?? {}) as Record<string, string>;
+    const missing = (
+      await Promise.all(
+        Object.entries(patchedDependencies).map(async ([spec, patchPath]) =>
+          (await this.#app.workspace.exists(patchPath)) ? null : `${spec} -> ${patchPath}`,
+        ),
+      )
+    ).filter((entry): entry is string => !!entry);
+    return missing.length ? [`patchedDependencies references a missing patch file: ${missing.join(", ")}`] : [];
+  }
+
+  async plan(): Promise<SlicePlan> {
+    const appInfo = await AppInfo.fromExecutor(this.#app);
+    const libs = appInfo.getLibs();
+    const slicePaths = [`apps/${this.#app.name}`, ...libs.map((lib) => `libs/${lib}`)];
+
+    const [appFiles, allTracked, untracked, rootPackageJson] = await Promise.all([
+      this.#trackedFiles([`apps/${this.#app.name}`]),
+      this.#trackedFiles(["."]),
+      this.#untrackedFiles(slicePaths),
+      this.#app.workspace.getPackageJson(),
+    ]);
+
+    const libFiles = Object.fromEntries(
+      await Promise.all(libs.map(async (lib) => [lib, await this.#trackedFiles([`libs/${lib}`])] as const)),
+    );
+    const rootFiles = allTracked.filter((file) => !this.#isMemberFile(file));
+
+    const required = SlicePlanner.#requiredDependencies(appInfo);
+    const rootDependencies = { ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies };
+    const unusedDependencies = Object.keys(rootDependencies)
+      .filter((dep) => !required.has(dep))
+      .sort();
+
+    //* `workspaces` names in-tree packages, and a slice never carries `pkgs/` — it consumes akanjs from
+    //* the registry. Dependencies are copied whole rather than pruned: the root of a hub is a superset of
+    //* every slice, so carrying it always installs, while a wrong prune produces a repo that does not.
+    const { workspaces: _workspaces, ...slicePackageJson } = rootPackageJson;
+
+    const warnings = [
+      ...(untracked.length
+        ? [`${untracked.length} untracked file(s) under the slice paths: ${untracked.join(", ")}`]
+        : []),
+      ...(rootPackageJson.workspaces ? ["root `workspaces` dropped — a slice consumes akanjs from the registry"] : []),
+      ...(await this.#patchWarnings(rootPackageJson)),
+    ];
+
+    return {
+      app: this.#app.name,
+      libs,
+      appFiles,
+      libFiles,
+      rootFiles,
+      packageJson: slicePackageJson as PackageJson,
+      unusedDependencies,
+      warnings,
+    };
+  }
+}
+
+/** Top-level entry each path sits under, so a long tree (`infra/**`) reads as one line. */
+const rootEntriesOf = (rootFiles: string[]) => [...new Set(rootFiles.map((file) => file.split("/")[0] ?? file))].sort();
+
+export function formatSlicePlan(plan: SlicePlan) {
+  const libCounts = Object.entries(plan.libFiles).map(([lib, files]) => `  - libs/${lib}: ${files.length} files`);
+  const sections = [
+    "Akan Slice Plan",
+    `app: ${plan.app} (apps/${plan.app}: ${plan.appFiles.length} files)`,
+    `libs: ${plan.libs.length ? plan.libs.join(", ") : "(none)"}`,
+    ...libCounts,
+    `workspace shell: ${plan.rootFiles.length} files across ${rootEntriesOf(plan.rootFiles).join(", ")}`,
+    "",
+    `Unused root dependencies (${plan.unusedDependencies.length}) — prune candidates, not pruned:`,
+    "",
+    ...(plan.unusedDependencies.length ? plan.unusedDependencies.map((dep) => `  - ${dep}`) : ["  (none)"]),
+    "",
+    `Warnings (${plan.warnings.length}):`,
+    "",
+    ...(plan.warnings.length ? plan.warnings.map((warning) => `  - ${warning}`) : ["  (none)"]),
+  ];
+  return sections.join("\n");
+}

package/transforms/asyncDefaultExportDetector.ts

@@ -0,0 +1,103 @@
+import fs from "node:fs";
+import path from "node:path";
+import type ts from "typescript";
+
+type TypeScript = typeof ts;
+
+export class AsyncDefaultExportDetector {
+  static #typescriptLoad: Promise<TypeScript> | undefined;
+
+  // `typescript` costs ~70 MB resident and this detector is reached from the cli entry through the root
+  // layout generator, so the compiler loads on first use rather than at import (`entryModuleGraph.test.ts`).
+  static #loadTypescript(): Promise<TypeScript> {
+    AsyncDefaultExportDetector.#typescriptLoad ??= import("typescript").then(
+      (mod) => (mod.default ?? mod) as TypeScript,
+    );
+    return AsyncDefaultExportDetector.#typescriptLoad;
+  }
+
+  static async detect(moduleAbsPath: string): Promise<boolean> {
+    try {
+      const typescript = await AsyncDefaultExportDetector.#loadTypescript();
+      const source = fs.readFileSync(path.resolve(moduleAbsPath), "utf8");
+      const sourceFile = typescript.createSourceFile(
+        moduleAbsPath,
+        source,
+        typescript.ScriptTarget.Latest,
+        true,
+        AsyncDefaultExportDetector.#scriptKind(typescript, moduleAbsPath),
+      );
+      return new AsyncDefaultExportDetector(typescript).detectInSourceFile(sourceFile);
+    } catch {
+      return false;
+    }
+  }
+
+  #ts: TypeScript;
+
+  constructor(typescript: TypeScript) {
+    this.#ts = typescript;
+  }
+
+  detectInSourceFile(sourceFile: ts.SourceFile): boolean {
+    const ts = this.#ts;
+    const asyncBindings = new Map<string, boolean>();
+    let defaultIdentifier: string | null = null;
+
+    for (const statement of sourceFile.statements) {
+      if (ts.isFunctionDeclaration(statement)) {
+        if (this.#hasModifier(statement, ts.SyntaxKind.DefaultKeyword)) {
+          return this.#hasModifier(statement, ts.SyntaxKind.AsyncKeyword);
+        }
+        if (statement.name) {
+          asyncBindings.set(statement.name.text, this.#hasModifier(statement, ts.SyntaxKind.AsyncKeyword));
+        }
+        continue;
+      }
+
+      if (ts.isVariableStatement(statement)) {
+        for (const declaration of statement.declarationList.declarations) {
+          if (!ts.isIdentifier(declaration.name)) continue;
+          asyncBindings.set(declaration.name.text, this.#isAsyncFunctionExpression(declaration.initializer));
+        }
+        continue;
+      }
+
+      if (ts.isExportAssignment(statement)) {
+        if (this.#isAsyncFunctionExpression(statement.expression)) return true;
+        if (ts.isIdentifier(statement.expression)) defaultIdentifier = statement.expression.text;
+        continue;
+      }
+
+      if (ts.isExportDeclaration(statement) && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+        const exportClause = statement.exportClause;
+        for (const specifier of exportClause.elements) {
+          if (specifier.name.text !== "default") continue;
+          defaultIdentifier = specifier.propertyName?.text ?? specifier.name.text;
+        }
+      }
+    }
+
+    return defaultIdentifier ? asyncBindings.get(defaultIdentifier) === true : false;
+  }
+
+  #hasModifier(node: ts.Node, kind: ts.SyntaxKind): boolean {
+    const ts = this.#ts;
+    return ts.canHaveModifiers(node) && (ts.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false);
+  }
+
+  #isAsyncFunctionExpression(node?: ts.Expression): boolean {
+    const ts = this.#ts;
+    return Boolean(
+      node &&
+        (ts.isArrowFunction(node) || ts.isFunctionExpression(node)) &&
+        this.#hasModifier(node, ts.SyntaxKind.AsyncKeyword),
+    );
+  }
+
+  static #scriptKind(typescript: TypeScript, moduleAbsPath: string): ts.ScriptKind {
+    return moduleAbsPath.endsWith(".tsx") || moduleAbsPath.endsWith(".jsx")
+      ? typescript.ScriptKind.TSX
+      : typescript.ScriptKind.TS;
+  }
+}