akanjs 0.0.1 → 2.0.0-beta.1

package/devkit/scanInfo.ts

@@ -0,0 +1,605 @@
+import path from "node:path";
+import type {
+  AppConfigResult,
+  AppScanResult,
+  FileConventionScanResult,
+  LibConfigResult,
+  LibScanResult,
+  PkgScanResult,
+  ScanResult,
+} from "./akanConfig";
+
+import { TypeScriptDependencyScanner } from "./dependencyScanner";
+import { AppExecutor, LibExecutor, PkgExecutor, WorkspaceExecutor } from "./executors";
+
+const scalarFileTypes = ["constant", "dictionary", "document", "template", "unit", "util", "view", "zone"] as const;
+type ScalarFileType = (typeof scalarFileTypes)[number];
+const serviceFileTypes = [
+  "dictionary",
+  "service",
+  "signal",
+  "store",
+  "template",
+  "unit",
+  "util",
+  "view",
+  "zone",
+] as const;
+type ServiceFileType = (typeof serviceFileTypes)[number];
+const databaseFileTypes = [
+  "constant",
+  "dictionary",
+  "document",
+  "service",
+  "signal",
+  "store",
+  "template",
+  "unit",
+  "util",
+  "view",
+  "zone",
+] as const;
+type DatabaseFileType = (typeof databaseFileTypes)[number];
+
+type ModuleKind = "database" | "service" | "scalar";
+
+const appRootAllowedFiles = new Set([
+  "akan.app.json",
+  "akan.config.ts",
+  "capacitor.config.ts",
+  "client.ts",
+  "main.ts",
+  "package.json",
+  "server.ts",
+  "tsconfig.json",
+]);
+const appRootAllowedDirs = new Set([
+  ".akan",
+  "android",
+  "env",
+  "ios",
+  "lib",
+  "page",
+  "private",
+  "public",
+  "script",
+  "ui",
+  "srvkit",
+  "webkit",
+  "common",
+]);
+const libRootAllowedFiles = new Set([
+  "cnst.ts",
+  "db.ts",
+  "dict.ts",
+  "option.ts",
+  "sig.ts",
+  "srv.ts",
+  "st.ts",
+  "useClient.ts",
+  "useServer.ts",
+]);
+const internalLibDirs = new Set(["__lib", "__scalar"]);
+const moduleNonUiFileTypes = {
+  database: new Set(["constant", "dictionary", "document", "service", "signal", "store"]),
+  service: new Set(["dictionary", "service", "signal", "store"]),
+  scalar: new Set(["constant", "dictionary", "document"]),
+} satisfies Record<ModuleKind, Set<string>>;
+const moduleUiFileTypes = {
+  database: new Set(["Template", "Unit", "Util", "View", "Zone"]),
+  service: new Set(["Util", "Zone"]),
+  scalar: new Set(["Template", "Unit"]),
+} satisfies Record<ModuleKind, Set<string>>;
+const testFilePattern = /\.(test|spec)\.(ts|tsx)$/;
+const rootSignalTestFilePattern = /^[A-Za-z][A-Za-z0-9_-]*\.signal\.(test|spec)\.(ts|tsx)$/;
+
+const isAllowedTestFile = (filename: string) => testFilePattern.test(filename);
+const isAllowedLibRootFile = (filename: string) =>
+  libRootAllowedFiles.has(filename) || rootSignalTestFilePattern.test(filename);
+const getScanPath = (exec: AppExecutor | LibExecutor, relativePath: string) =>
+  path.posix.join(`${exec.type}s`, exec.name, relativePath.split(path.sep).join("/"));
+
+async function assertScanConvention(exec: AppExecutor | LibExecutor, libRoot: { files: string[]; dirs: string[] }) {
+  const violations: string[] = [];
+  const addViolation = (relativePath: string, reason: string) => {
+    violations.push(`${getScanPath(exec, relativePath)}: ${reason}`);
+  };
+
+  if (exec.type === "app") {
+    const { files, dirs } = await exec.getFilesAndDirs(".");
+    files
+      .filter((filename) => !appRootAllowedFiles.has(filename))
+      .forEach((filename) => {
+        addViolation(filename, "unsupported app root file");
+      });
+    dirs
+      .filter((dirname) => !appRootAllowedDirs.has(dirname))
+      .forEach((dirname) => {
+        addViolation(dirname, "unsupported app root folder");
+      });
+  }
+
+  libRoot.files
+    .filter((filename) => !isAllowedLibRootFile(filename))
+    .forEach((filename) => {
+      addViolation(path.join("lib", filename), "unsupported lib root file");
+    });
+
+  libRoot.dirs
+    .filter((dirname) => dirname.startsWith("__") && !internalLibDirs.has(dirname))
+    .forEach((dirname) => {
+      addViolation(path.join("lib", dirname), "unsupported internal lib folder");
+    });
+
+  const databaseDirs = libRoot.dirs.filter((dirname) => !dirname.startsWith("_"));
+  const serviceDirs = libRoot.dirs.filter((dirname) => dirname.startsWith("_") && !dirname.startsWith("__"));
+  const scalarDirs = await exec.readdir("lib/__scalar");
+  await Promise.all([
+    ...databaseDirs.map((dirname) => validateModuleFiles(exec, violations, "database", path.join("lib", dirname))),
+    ...serviceDirs.map((dirname) => validateModuleFiles(exec, violations, "service", path.join("lib", dirname))),
+    ...scalarDirs.map((dirname) => validateModuleFiles(exec, violations, "scalar", path.join("lib/__scalar", dirname))),
+  ]);
+
+  if (violations.length > 0) {
+    throw new Error(
+      `[scan-convention]\n${violations
+        .sort()
+        .map((violation) => `- ${violation}`)
+        .join("\n")}`,
+    );
+  }
+}
+
+async function validateModuleFiles(
+  exec: AppExecutor | LibExecutor,
+  violations: string[],
+  kind: ModuleKind,
+  modulePath: string,
+) {
+  const { files, dirs } = await exec.getFilesAndDirs(modulePath);
+  dirs.forEach((dirname) => {
+    violations.push(`${getScanPath(exec, path.join(modulePath, dirname))}: unsupported module folder`);
+  });
+
+  files.forEach((filename) => {
+    const filePath = path.join(modulePath, filename);
+    if (filename === "index.ts" || filename === "index.tsx" || isAllowedTestFile(filename)) return;
+
+    const uiMatch = filename.match(/\.([A-Z][A-Za-z0-9]*)\.tsx$/);
+    if (uiMatch) {
+      const fileType = uiMatch[1];
+      if (!moduleUiFileTypes[kind].has(fileType)) {
+        violations.push(`${getScanPath(exec, filePath)}: unsupported ${kind} UI file`);
+      }
+      return;
+    }
+
+    const nonUiMatch = filename.match(/\.([a-z][A-Za-z0-9]*)\.ts$/);
+    if (nonUiMatch) {
+      const fileType = nonUiMatch[1];
+      if (!moduleNonUiFileTypes[kind].has(fileType)) {
+        violations.push(`${getScanPath(exec, filePath)}: unsupported ${kind} file`);
+      }
+      return;
+    }
+
+    violations.push(`${getScanPath(exec, filePath)}: unsupported module file`);
+  });
+}
+
+class ScanInfo {
+  protected scanResult: ScanResult;
+
+  readonly name: string;
+  readonly scalar = new Map<string, Set<ScalarFileType>>();
+  readonly service = new Map<string, Set<ServiceFileType>>();
+  readonly database = new Map<string, Set<DatabaseFileType>>();
+  readonly file = Object.fromEntries(
+    databaseFileTypes.map((type) => [
+      type,
+      { all: new Set(), databases: new Set(), services: new Set(), scalars: new Set() },
+    ]),
+  ) as {
+    [key in DatabaseFileType]: {
+      all: Set<string>;
+      databases: Set<string>;
+      services: Set<string>;
+      scalars: Set<string>;
+    };
+  };
+
+  static async getScanResult(exec: AppExecutor | LibExecutor) {
+    const [akanConfig, scanner, pkgs, libs] = await Promise.all([
+      exec.getConfig(),
+      TypeScriptDependencyScanner.from(exec),
+      exec.workspace.getPkgs(),
+      exec.workspace.getLibs(),
+    ]);
+    const { pkgDeps, libDeps, npmDeps, npmDevDeps } = await scanner.getMonorepoDependencies(exec.name, { pkgs, libs });
+    const files: FileConventionScanResult = {
+      constant: { databases: [], scalars: [] },
+      dictionary: { databases: [], services: [], scalars: [] },
+      document: { databases: [], scalars: [] },
+      service: { databases: [], services: [] },
+      signal: { databases: [], services: [] },
+      store: { databases: [], services: [] },
+      template: { databases: [], services: [], scalars: [] },
+      unit: { databases: [], services: [], scalars: [] },
+      util: { databases: [], services: [], scalars: [] },
+      view: { databases: [], services: [], scalars: [] },
+      zone: { databases: [], services: [], scalars: [] },
+    };
+    const [libRoot, scalarDirs] = await Promise.all([exec.getFilesAndDirs("lib"), exec.readdir("lib/__scalar")]);
+    await assertScanConvention(exec, libRoot);
+    const { dirs: dirnames } = libRoot;
+    const databaseDirs: string[] = [];
+    const serviceDirs: string[] = [];
+    dirnames.forEach((name) => {
+      if (name.startsWith("_")) {
+        if (name.startsWith("__")) return;
+        else serviceDirs.push(name);
+      } else databaseDirs.push(name);
+    });
+
+    await Promise.all([
+      ...databaseDirs.map(async (name) => {
+        const filenames = await exec.readdir(path.join("lib", name));
+        filenames.forEach((filename) => {
+          if (filename.endsWith(".constant.ts")) files.constant.databases.push(name);
+          else if (filename.endsWith(".dictionary.ts")) files.dictionary.databases.push(name);
+          else if (filename.endsWith(".document.ts")) files.document.databases.push(name);
+          else if (filename.endsWith(".service.ts")) files.service.databases.push(name);
+          else if (filename.endsWith(".signal.ts")) files.signal.databases.push(name);
+          else if (filename.endsWith(".store.ts")) files.store.databases.push(name);
+          else if (filename.endsWith(".Template.tsx")) files.template.databases.push(name);
+          else if (filename.endsWith(".Unit.tsx")) files.unit.databases.push(name);
+          else if (filename.endsWith(".Util.tsx")) files.util.databases.push(name);
+          else if (filename.endsWith(".View.tsx")) files.view.databases.push(name);
+          else if (filename.endsWith(".Zone.tsx")) files.zone.databases.push(name);
+        });
+      }),
+      ...serviceDirs.map(async (dirname) => {
+        const name = dirname.slice(1);
+        const filenames = await exec.readdir(path.join("lib", dirname));
+        filenames.forEach((filename) => {
+          if (filename.endsWith(".dictionary.ts")) files.dictionary.services.push(name);
+          else if (filename.endsWith(".service.ts")) files.service.services.push(name);
+          else if (filename.endsWith(".signal.ts")) files.signal.services.push(name);
+          else if (filename.endsWith(".store.ts")) files.store.services.push(name);
+          else if (filename.endsWith(".Template.tsx")) files.template.services.push(name);
+          else if (filename.endsWith(".Unit.tsx")) files.unit.services.push(name);
+          else if (filename.endsWith(".Util.tsx")) files.util.services.push(name);
+          else if (filename.endsWith(".View.tsx")) files.view.services.push(name);
+          else if (filename.endsWith(".Zone.tsx")) files.zone.services.push(name);
+        });
+      }),
+      ...scalarDirs.map(async (name) => {
+        const filenames = await exec.readdir(path.join("lib/__scalar", name));
+        filenames.forEach((filename) => {
+          if (filename.endsWith(".constant.ts")) files.constant.scalars.push(name);
+          else if (filename.endsWith(".dictionary.ts")) files.dictionary.scalars.push(name);
+          else if (filename.endsWith(".document.ts")) files.document.scalars.push(name);
+          else if (filename.endsWith(".Template.tsx")) files.template.scalars.push(name);
+          else if (filename.endsWith(".Unit.tsx")) files.unit.scalars.push(name);
+          else if (filename.endsWith(".Util.tsx")) files.util.scalars.push(name);
+          else if (filename.endsWith(".View.tsx")) files.view.scalars.push(name);
+          else if (filename.endsWith(".Zone.tsx")) files.zone.scalars.push(name);
+        });
+      }),
+    ]);
+    const routes = exec.type === "lib" ? [] : await (exec as AppExecutor).getPageKeys();
+    const scanResult: AppScanResult | LibScanResult = {
+      name: exec.name,
+      type: exec.type,
+      repoName: exec.workspace.repoName,
+      serveDomain: WorkspaceExecutor.getBaseDevEnv(path.join(exec.workspace.workspaceRoot, ".env")).serveDomain,
+      akanConfig,
+      files,
+      libDeps,
+      pkgDeps,
+      dependencies: npmDeps.filter((dep) => !isAkanFrameworkDependency(dep)),
+      devDependencies: npmDevDeps.filter((dep) => !isAkanFrameworkDependency(dep)),
+      routes,
+    };
+    return scanResult;
+  }
+
+  constructor(scanResult: ScanResult) {
+    this.name = scanResult.name;
+    this.scanResult = scanResult;
+    Object.entries(scanResult.files).forEach(([_key, value]) => {
+      const key = _key as DatabaseFileType;
+      const { databases, services, scalars } = value as {
+        databases: string[];
+        services?: string[];
+        scalars?: string[];
+      };
+      databases.forEach((modelName) => {
+        const model = this.database.get(modelName) ?? new Set<DatabaseFileType>();
+        model.add(key);
+        this.database.set(modelName, model);
+        this.file[key].all.add(modelName);
+        this.file[key].databases.add(modelName);
+      });
+      services?.forEach((serviceName) => {
+        const service = this.service.get(serviceName) ?? new Set<ServiceFileType>();
+        service.add(key as ServiceFileType);
+        this.service.set(serviceName, service);
+        this.file[key].all.add(serviceName);
+        this.file[key].services.add(serviceName);
+      });
+      scalars?.forEach((scalarName) => {
+        const scalar = this.scalar.get(scalarName) ?? new Set<ScalarFileType>();
+        scalar.add(key as ScalarFileType);
+        this.scalar.set(scalarName, scalar);
+        this.file[key].all.add(scalarName);
+        this.file[key].scalars.add(scalarName);
+      });
+    });
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+  getDatabaseModules() {
+    return [...this.database.keys()];
+  }
+  getServiceModules() {
+    return [...this.service.keys()];
+  }
+  getScalarModules() {
+    return [...this.scalar.keys()];
+  }
+}
+
+const isAkanFrameworkDependency = (dep: string) => dep === "akanjs" || dep.startsWith("akanjs/");
+export class AppInfo extends ScanInfo {
+  readonly type = "app";
+  readonly exec: AppExecutor;
+  readonly akanConfig: AppConfigResult;
+  readonly libDeps: string[];
+
+  static appInfos = new Map<string, AppInfo>();
+  static async fromExecutor(exec: AppExecutor, options: { refresh?: boolean } = {}) {
+    
+    const existingAppInfo = AppInfo.appInfos.get(exec.name);
+    if (existingAppInfo && !options.refresh) return existingAppInfo;
+    const scanResult = await ScanInfo.getScanResult(exec);
+
+    await Promise.all(
+      scanResult.libDeps.map(async (libName) => {
+        LibInfo.loadedLibs.add(libName);
+        const libExecutor = LibExecutor.from(exec, libName);
+        LibInfo.libInfos.set(libName, await LibInfo.fromExecutor(libExecutor));
+      }),
+    );
+    const libDeps = await AppInfo.#getAllLibDeps(exec, scanResult.libDeps);
+    const appInfo = new AppInfo(exec, scanResult as AppScanResult, libDeps);
+    AppInfo.appInfos.set(exec.name, appInfo);
+    return appInfo;
+  }
+
+  constructor(exec: AppExecutor, scanResult: AppScanResult, libDeps: string[]) {
+    super(scanResult);
+    this.exec = exec;
+    this.akanConfig = scanResult.akanConfig;
+    this.libDeps = libDeps;
+  }
+  override getScanResult(): AppScanResult {
+    return this.scanResult as AppScanResult;
+  }
+
+  static async #getAllLibDeps(exec: AppExecutor, libDeps: string[], libSet = new Set<string>()) {
+    await Promise.all(
+      libDeps.map(async (libName) => {
+        if (libSet.has(libName)) return;
+        libSet.add(libName);
+        const libExecutor = LibExecutor.from(exec, libName);
+        const libInfo = await LibInfo.fromExecutor(libExecutor);
+        const libScanResult = libInfo.getScanResult();
+        if (libScanResult.libDeps.length > 0) await AppInfo.#getAllLibDeps(exec, libScanResult.libDeps, libSet);
+      }),
+    );
+    return [...libSet];
+  }
+
+  #sortedLibs: string[] | null = null;
+  #getSortedLibs() {
+    if (this.#sortedLibs) return this.#sortedLibs;
+    const libIndices = LibInfo.getSortedLibIndices();
+    this.#sortedLibs = this.libDeps.sort((libNameA, libNameB) => {
+      const indexA = libIndices.get(libNameA);
+      const indexB = libIndices.get(libNameB);
+      if (indexA === undefined || indexB === undefined)
+        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
+      return indexA - indexB;
+    });
+    return this.#sortedLibs;
+  }
+  getLibs() {
+    return this.#getSortedLibs();
+  }
+  getLibInfos() {
+    return new Map(
+      this.#getSortedLibs().map((libName) => {
+        const libInfo = LibInfo.libInfos.get(libName);
+        if (!libInfo) throw new Error(`LibInfo not found: ${libName}`);
+        return [libName, libInfo];
+      }),
+    );
+  }
+}
+export class LibInfo extends ScanInfo {
+  readonly type = "lib";
+  readonly exec: LibExecutor;
+  readonly akanConfig: LibConfigResult;
+
+  static loadedLibs = new Set<string>();
+  static readonly libInfos = new Map<string, LibInfo>();
+  static #sortedLibIndices: Map<string, number> | null = null;
+
+  static getSortedLibIndices() {
+    if (LibInfo.#sortedLibIndices) return LibInfo.#sortedLibIndices;
+    LibInfo.#sortedLibIndices = new Map(
+      [...LibInfo.libInfos.entries()]
+        .sort(([_, libInfoA], [__, libInfoB]) => (libInfoA.getScanResult().libDeps.includes(libInfoB.name) ? 1 : -1))
+        .map(([libName], index) => [libName, index]),
+    );
+    return LibInfo.#sortedLibIndices;
+  }
+
+  static async fromExecutor(exec: LibExecutor, { refresh }: { refresh?: boolean } = {}) {
+    const existingLibInfo = LibInfo.libInfos.get(exec.name);
+    if (existingLibInfo && !refresh) return existingLibInfo;
+
+    const scanResult = await ScanInfo.getScanResult(exec);
+    await Promise.all(
+      scanResult.libDeps
+        .filter((libName) => !LibInfo.loadedLibs.has(libName))
+        .map(async (libName) => {
+          LibInfo.loadedLibs.add(libName);
+          const libExecutor = LibExecutor.from(exec, libName);
+          LibInfo.libInfos.set(libName, await LibInfo.fromExecutor(libExecutor));
+        }),
+    );
+    const libInfo = new LibInfo(exec, scanResult);
+    LibInfo.libInfos.set(exec.name, libInfo);
+    LibInfo.#sortedLibIndices = null;
+    return libInfo;
+  }
+
+  constructor(exec: LibExecutor, scanResult: LibScanResult) {
+    super(scanResult);
+    this.exec = exec;
+    this.akanConfig = scanResult.akanConfig;
+  }
+  override getScanResult(): LibScanResult {
+    return this.scanResult as LibScanResult;
+  }
+
+  #sortedLibs: string[] | null = null;
+  #getSortedLibs() {
+    if (this.#sortedLibs) return this.#sortedLibs;
+    const libs = LibInfo.getSortedLibIndices();
+    this.#sortedLibs = this.scanResult.libDeps.sort((libNameA, libNameB) => {
+      const indexA = libs.get(libNameA);
+      const indexB = libs.get(libNameB);
+      if (indexA === undefined || indexB === undefined)
+        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
+      return indexA - indexB;
+    });
+    return this.#sortedLibs;
+  }
+  getLibs() {
+    return this.#getSortedLibs();
+  }
+  getLibInfo(libName: string) {
+    if (!this.getScanResult().libDeps.includes(libName)) return undefined;
+    const libSet = new Set(this.#getSortedLibs());
+    if (!libSet.has(libName)) throw new Error(`LibInfo is invalid: ${libName}`);
+    return LibInfo.libInfos.get(libName);
+  }
+  getLibInfos() {
+    return new Map(
+      this.#getSortedLibs().map((libName) => {
+        const libInfo = LibInfo.libInfos.get(libName);
+        if (!libInfo) throw new Error(`LibInfo not found: ${libName}`);
+        return [libName, libInfo];
+      }),
+    );
+  }
+}
+
+export class PkgInfo {
+  readonly exec: PkgExecutor;
+  readonly name: string;
+  private scanResult: PkgScanResult;
+
+  static async getScanResult(exec: PkgExecutor) {
+    const [tsconfig, rootPackageJson] = await Promise.all([exec.getTsConfig(), exec.workspace.getPackageJson()]);
+    const scanner = await TypeScriptDependencyScanner.from(exec);
+    const npmSet = new Set(Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies }));
+    const pkgPathSet = new Set(
+      Object.keys(tsconfig.compilerOptions.paths ?? {})
+        .filter((path) => tsconfig.compilerOptions.paths?.[path]?.some((resolve) => resolve.startsWith("pkgs/")))
+        .map((path) => path.replace("/*", "")),
+    );
+    const [npmDepSet, pkgPathDepSet] = await scanner.getImportSets([npmSet, pkgPathSet]);
+    const pkgDeps = [...pkgPathDepSet]
+      .map((path) => {
+        const pathSplitLength = path.split("/").length;
+        return (tsconfig.compilerOptions.paths?.[path]?.[0] ?? "*")
+          .split("/")
+          .slice(1, 1 + pathSplitLength)
+          .join("/");
+      })
+      .filter((pkg) => pkg !== exec.name);
+    const pkgScanResult = {
+      name: exec.name,
+      pkgDeps,
+      dependencies: [...npmDepSet],
+    };
+    return pkgScanResult;
+  }
+
+  static #pkgInfos = new Map<string, PkgInfo>();
+  static async fromExecutor(exec: PkgExecutor, options: { refresh?: boolean } = {}) {
+    const existingPkgInfo = PkgInfo.#pkgInfos.get(exec.name);
+    if (existingPkgInfo && !options.refresh) return existingPkgInfo;
+
+    const scanResult = await PkgInfo.getScanResult(exec);
+    const pkgInfo = new PkgInfo(exec, scanResult);
+    PkgInfo.#pkgInfos.set(exec.name, pkgInfo);
+    return pkgInfo;
+  }
+  constructor(exec: PkgExecutor, scanResult: PkgScanResult) {
+    this.exec = exec;
+    this.name = exec.name;
+    this.scanResult = scanResult;
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+}
+
+export class WorkspaceInfo {
+  constructor(
+    public readonly appInfos: Map<string, AppInfo> = new Map(),
+    public readonly libInfos: Map<string, LibInfo> = new Map(),
+    public readonly pkgInfos: Map<string, PkgInfo> = new Map(),
+  ) {}
+
+  static #workspaceInfos = new Map<string, WorkspaceInfo>();
+  static async fromExecutor(exec: WorkspaceExecutor, options: { refresh?: boolean } = {}) {
+    const existingWorkspaceInfo = WorkspaceInfo.#workspaceInfos.get(exec.name);
+    if (existingWorkspaceInfo && !options.refresh) return existingWorkspaceInfo;
+
+    const [appNames, libNames, pkgNames] = await Promise.all([exec.getApps(), exec.getLibs(), exec.getPkgs()]);
+    
+    const [appInfos, libInfos, pkgInfos] = await Promise.all([
+      Promise.all(
+        appNames.map(async (appName) => {
+          const app = AppExecutor.from(exec, appName);
+          return await app.scan();
+        }),
+      ),
+      Promise.all(
+        libNames.map(async (libName) => {
+          const lib = LibExecutor.from(exec, libName);
+          return await lib.scan();
+        }),
+      ),
+      Promise.all(
+        pkgNames.map(async (pkgName) => {
+          return await PkgExecutor.from(exec, pkgName).scan();
+        }),
+      ),
+    ]);
+    const workspaceInfo = new WorkspaceInfo(
+      new Map(appInfos.map((app) => [app.exec.name, app as AppInfo])),
+      new Map(libInfos.map((lib) => [lib.exec.name, lib as LibInfo])),
+      new Map(pkgInfos.map((pkg: PkgInfo) => [pkg.exec.name, pkg])),
+    );
+    WorkspaceInfo.#workspaceInfos.set(exec.name, workspaceInfo);
+    return workspaceInfo;
+  }
+}

package/devkit/selectModel.ts

@@ -0,0 +1,11 @@
+import { readdirSync } from "node:fs";
+import { select } from "@inquirer/prompts";
+
+export const selectModel = async (modulePath: string) => {
+  const modelNames = readdirSync(`${modulePath}/lib`).filter((dir) => !dir.includes(".") && !dir.startsWith("_"));
+  const modelName = await select({
+    message: "Select the model to create the unit for",
+    choices: modelNames.map((name) => ({ name, value: name })),
+  });
+  return modelName;
+};

package/devkit/spinner.ts

@@ -0,0 +1,54 @@
+import ora, { type Ora } from "ora";
+
+export class Spinner {
+  static padding = 12;
+  spinner: Ora;
+  stopWatch: NodeJS.Timeout | null = null;
+  startAt: Date = new Date();
+  prefix: string;
+  message: string;
+  enableSpin: boolean;
+  constructor(message: string, { prefix = "", indent = 0, enableSpin = true } = {}) {
+    Spinner.padding = Math.max(Spinner.padding, prefix.length);
+    this.prefix = prefix;
+    this.message = message;
+    this.spinner = ora(message);
+    this.spinner.prefixText = prefix.padStart(Spinner.padding, " ");
+    this.spinner.indent = indent;
+    this.enableSpin = enableSpin;
+  }
+  start() {
+    this.startAt = new Date();
+    if (this.enableSpin) {
+      this.spinner.start();
+      this.stopWatch = setInterval(() => {
+        this.spinner.prefixText = this.prefix.padStart(Spinner.padding, " ");
+        this.spinner.text = `${this.message} (${this.#getElapsedTimeStr({ floor: true })})`;
+      }, 1000);
+    } else this.spinner.info();
+    return this;
+  }
+  succeed(message: string) {
+    this.spinner.succeed(`${message} (${this.#getElapsedTimeStr()})`);
+    this.#reset();
+  }
+  fail(message: string) {
+    this.spinner.fail(`${message} (${this.#getElapsedTimeStr()})`);
+    this.#reset();
+  }
+  isSpinning() {
+    return this.spinner.isSpinning;
+  }
+  #reset() {
+    if (this.stopWatch) clearInterval(this.stopWatch);
+    this.stopWatch = null;
+  }
+  #getElapsedTimeStr({ floor = false }: { floor?: boolean } = {}) {
+    const ms = Date.now() - this.startAt.getTime();
+    if (ms < 1000) return `${ms}ms`;
+    const s = Math.floor(ms / 1000);
+    if (s < 60) return `${floor ? Math.floor(ms / 1000) : Math.floor(ms / 100) / 10}s`;
+    const m = Math.floor(s / 60);
+    return `${m}m ${s % 60}s`;
+  }
+}