@akanjs/devkit 0.9.41 → 0.9.42

package/esm/src/executors.js

@@ -1,18 +1,14 @@
 import { capitalize, Logger } from "@akanjs/common";
-import {
-  getAppConfig,
-  getDefaultFileScan,
-  getLibConfig
-} from "@akanjs/config";
+import { getAppConfig, getLibConfig } from "@akanjs/config";
 import chalk from "chalk";
 import { exec, fork, spawn } from "child_process";
 import dotenv from "dotenv";
 import fs from "fs";
 import fsPromise from "fs/promises";
 import path from "path";
-import { TypeScriptDependencyScanner } from "./dependencyScanner";
 import { getDirname } from "./getDirname";
 import { Linter } from "./linter";
+import { AppInfo, LibInfo, PkgInfo, WorkspaceInfo } from "./scanInfo";
 import { Spinner } from "./spinner";
 import { TypeChecker } from "./typeChecker";
 const execEmoji = {
@@ -159,6 +155,22 @@ class Executor {
       return [];
     }
   }
+  async getFilesAndDirs(dirPath) {
+    const paths = await this.readdir(dirPath);
+    const files = [];
+    const dirs = [];
+    const fullDirPath = this.getPath(dirPath);
+    await Promise.all(
+      paths.map(async (p) => {
+        const stats = await fsPromise.stat(path.join(fullDirPath, p));
+        if (stats.isDirectory())
+          dirs.push(p);
+        else
+          files.push(p);
+      })
+    );
+    return { files, dirs };
+  }
   exists(filePath) {
     const readPath = this.getPath(filePath);
     return fs.existsSync(readPath);
@@ -190,11 +202,12 @@ class Executor {
         contentStr = fs.readFileSync(writePath, "utf-8");
       } else {
         fs.writeFileSync(writePath, contentStr, "utf8");
-        this.logger.verbose(`File ${writePath} is changed`);
+        if (Logger.isVerbose())
+          this.logger.rawLog(chalk.yellow(`File Update: ${filePath}`));
       }
     } else {
       fs.writeFileSync(writePath, contentStr, "utf8");
-      this.logger.verbose(`File ${writePath} is created`);
+      this.logger.rawLog(chalk.green(`File Create: ${filePath}`));
     }
     return { filePath: writePath, content: contentStr };
   }
@@ -231,7 +244,10 @@ class Executor {
   spinning(msg, { prefix = `${this.emoji}${this.name}`, indent = 0, enableSpin = !Executor.verbose } = {}) {
     return new Spinner(msg, { prefix, indent, enableSpin }).start();
   }
-  getTsConfig(pathname = "tsconfig.json") {
+  #tsconfig = null;
+  getTsConfig(pathname = "tsconfig.json", { refresh } = {}) {
+    if (this.#tsconfig && !refresh)
+      return this.#tsconfig;
     const tsconfig = this.readJson(pathname);
     if (tsconfig.extends) {
       const extendsTsconfig = this.getTsConfig(tsconfig.extends);
@@ -241,17 +257,34 @@ class Executor {
         compilerOptions: { ...extendsTsconfig.compilerOptions, ...tsconfig.compilerOptions }
       };
     }
+    this.#tsconfig = tsconfig;
     return tsconfig;
   }
+  setTsConfig(tsconfig) {
+    this.writeJson("tsconfig.json", tsconfig);
+    this.#tsconfig = tsconfig;
+  }
+  #packageJson = null;
+  getPackageJson({ refresh } = {}) {
+    if (this.#packageJson && !refresh)
+      return this.#packageJson;
+    const packageJson = this.readJson("package.json");
+    this.#packageJson = packageJson;
+    return packageJson;
+  }
+  setPackageJson(packageJson) {
+    this.writeJson("package.json", packageJson);
+    this.#packageJson = packageJson;
+  }
   async #applyTemplateFile({
     templatePath,
     targetPath,
-    scanResult,
+    scanInfo,
     overwrite = true
   }, dict = {}) {
     if (targetPath.endsWith(".js") || targetPath.endsWith(".jsx")) {
       const getContent = await import(templatePath);
-      const result = getContent.default(scanResult ?? null, dict);
+      const result = getContent.default(scanInfo ?? null, dict);
       if (result === null)
         return null;
       const filename = typeof result === "object" ? result.filename : path.basename(targetPath).replace(".js", ".ts");
@@ -281,7 +314,7 @@ class Executor {
   async _applyTemplate({
     basePath,
     template,
-    scanResult,
+    scanInfo,
     dict = {},
     overwrite = true
   }) {
@@ -290,7 +323,7 @@ class Executor {
     if (fs.statSync(prefixTemplatePath).isFile()) {
       const filename = path.basename(prefixTemplatePath);
       const fileContent = await this.#applyTemplateFile(
-        { templatePath: prefixTemplatePath, targetPath: path.join(basePath, filename), scanResult, overwrite },
+        { templatePath: prefixTemplatePath, targetPath: path.join(basePath, filename), scanInfo, overwrite },
         dict
       );
       return fileContent ? [fileContent] : [];
@@ -301,7 +334,7 @@ class Executor {
           const subpath = path.join(templatePath, subdir);
           if (fs.statSync(subpath).isFile()) {
             const fileContent = await this.#applyTemplateFile(
-              { templatePath: subpath, targetPath: path.join(basePath, subdir), scanResult, overwrite },
+              { templatePath: subpath, targetPath: path.join(basePath, subdir), scanInfo, overwrite },
               dict
             );
             return fileContent ? [fileContent] : [];
@@ -309,7 +342,7 @@ class Executor {
             return await this._applyTemplate({
               basePath: path.join(basePath, subdir),
               template: path.join(template, subdir),
-              scanResult,
+              scanInfo,
               dict,
               overwrite
             });
@@ -359,9 +392,12 @@ class WorkspaceExecutor extends Executor {
     this.workspaceRoot = workspaceRoot;
     this.repoName = repoName;
   }
-  static fromRoot() {
-    const repoName = path.basename(process.cwd());
-    return new WorkspaceExecutor({ workspaceRoot: process.cwd(), repoName });
+  static #execs = /* @__PURE__ */ new Map();
+  static fromRoot({
+    workspaceRoot = process.cwd(),
+    repoName = path.basename(process.cwd())
+  } = {}) {
+    return this.#execs.get(repoName) ?? new WorkspaceExecutor({ workspaceRoot, repoName });
   }
   getBaseDevEnv() {
     const envFile = dotenv.parse(this.readFile(".env"));
@@ -379,36 +415,7 @@ class WorkspaceExecutor extends Executor {
     return { ...appName ? { name: appName } : {}, repoName, serveDomain, env, portOffset };
   }
   async scan() {
-    const [appNames, libNames, pkgNames] = await Promise.all([this.getApps(), this.getLibs(), this.getPkgs()]);
-    const [appScanResults, libScanResults, pkgScanResults] = await Promise.all([
-      Promise.all(
-        appNames.map(async (appName) => {
-          const app = AppExecutor.from(this, appName);
-          const akanConfig = await app.getConfig("scan");
-          return await app.scan({ akanConfig });
-        })
-      ),
-      Promise.all(
-        libNames.map(async (libName) => {
-          const lib = LibExecutor.from(this, libName);
-          const akanConfig = await lib.getConfig("scan");
-          return await lib.scan({ akanConfig });
-        })
-      ),
-      Promise.all(
-        pkgNames.map(async (pkgName) => {
-          return await PkgExecutor.from(this, pkgName).scan();
-        })
-      )
-    ]);
-    return {
-      appNames,
-      libNames,
-      pkgNames,
-      apps: Object.fromEntries(appScanResults.map((app) => [app.name, app])),
-      libs: Object.fromEntries(libScanResults.map((lib) => [lib.name, lib])),
-      pkgs: Object.fromEntries(pkgScanResults.map((pkg) => [pkg.name, pkg]))
-    };
+    return await WorkspaceInfo.fromExecutor(this);
   }
   async getApps() {
     if (!fs.existsSync(`${this.workspaceRoot}/apps`))
@@ -556,160 +563,103 @@ class SysExecutor extends Executor {
     this.type = type;
     this.emoji = execEmoji[type];
   }
-  async getConfig(command) {
-    return this.type === "app" ? await getAppConfig(this.cwdPath, { ...this.workspace.getBaseDevEnv(), type: "app", name: this.name, command }) : await getLibConfig(this.cwdPath, { ...this.workspace.getBaseDevEnv(), type: "lib", name: this.name, command });
+  #akanConfig = null;
+  async getConfig({ refresh } = {}) {
+    if (this.#akanConfig && !refresh)
+      return this.#akanConfig;
+    this.#akanConfig = this.type === "app" ? await getAppConfig(this.cwdPath, { ...this.workspace.getBaseDevEnv(), type: "app", name: this.name }) : await getLibConfig(this.cwdPath, { ...this.workspace.getBaseDevEnv(), type: "lib", name: this.name });
+    return this.#akanConfig;
   }
   async getModules() {
     const path2 = this.type === "app" ? `apps/${this.name}/lib` : `libs/${this.name}/lib`;
     return await this.workspace.getDirInModule(path2, this.name);
   }
+  #scanInfo = null;
   async scan({
-    tsconfig = this.getTsConfig(`${this.cwdPath}/tsconfig.json`),
-    akanConfig
-  }, libScanResults = {}) {
-    if (libScanResults[this.name])
-      return libScanResults[this.name];
-    const rootPackageJson = this.readJson(`${this.workspace.workspaceRoot}/package.json`);
-    const scanner = new TypeScriptDependencyScanner(this.cwdPath);
-    const npmSet = new Set(Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies }));
-    const pkgPathSet = new Set(
-      Object.keys(tsconfig.compilerOptions.paths ?? {}).filter((path2) => tsconfig.compilerOptions.paths?.[path2]?.some((resolve) => resolve.startsWith("pkgs/"))).map((path2) => path2.replace("/*", ""))
-    );
-    const libPathSet = new Set(
-      Object.keys(tsconfig.compilerOptions.paths ?? {}).filter((path2) => tsconfig.compilerOptions.paths?.[path2]?.some((resolve) => resolve.startsWith("libs/"))).map((path2) => path2.replace("/*", ""))
-    );
-    const [npmDepSet, pkgPathDepSet, libPathDepSet] = await scanner.getImportSets([npmSet, pkgPathSet, libPathSet]);
-    const pkgDeps = [...pkgPathDepSet].map((path2) => {
-      const pathSplitLength = path2.split("/").length;
-      return (tsconfig.compilerOptions.paths?.[path2]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
-    });
-    const libDeps = [...libPathDepSet].map((path2) => {
-      const pathSplitLength = path2.split("/").length;
-      return (tsconfig.compilerOptions.paths?.[path2]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
-    }).filter((libName) => libName !== this.name);
-    if (!fs.existsSync(`${this.cwdPath}/lib/__scalar`))
-      fs.mkdirSync(`${this.cwdPath}/lib/__scalar`, { recursive: true });
-    const files = getDefaultFileScan();
-    const dirnames = (await this.readdir("lib")).filter(
-      (name) => fs.lstatSync(`${this.cwdPath}/lib/${name}`).isDirectory()
-    );
-    const databaseDirs = dirnames.filter((name) => !name.startsWith("_"));
-    const serviceDirs = dirnames.filter((name) => name.startsWith("_") && !name.startsWith("__"));
-    await Promise.all(
-      databaseDirs.map(async (name) => {
-        const filenames = await this.readdir(path.join("lib", name));
-        filenames.forEach((filename) => {
-          if (filename.endsWith(".constant.ts"))
-            files.constants.databases.push(name);
-          else if (filename.endsWith(".dictionary.ts"))
-            files.dictionary.databases.push(name);
-          else if (filename.endsWith(".document.ts"))
-            files.documents.databases.push(name);
-          else if (filename.endsWith(".service.ts"))
-            files.services.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 === "index.tsx")
-            files.components.databases.push(name);
-        });
-      })
-    );
-    await Promise.all(
-      serviceDirs.map(async (dirname) => {
-        const name = dirname.slice(1);
-        const filenames = await this.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.services.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 === "index.tsx")
-            files.components.services.push(name);
-        });
-      })
-    );
-    const scalarDirs = (await this.readdir("lib/__scalar")).filter((name) => !name.startsWith("_"));
-    await Promise.all(
-      scalarDirs.map(async (name) => {
-        const filenames = await this.readdir(path.join("lib/__scalar", name));
-        filenames.forEach((filename) => {
-          if (filename.endsWith(".constant.ts"))
-            files.constants.scalars.push(name);
-          else if (filename.endsWith(".dictionary.ts"))
-            files.dictionary.scalars.push(name);
-          else if (filename.endsWith(".document.ts"))
-            files.documents.scalars.push(name);
-          else if (filename.endsWith(".service.ts"))
-            files.services.scalars.push(name);
-          else if (filename.endsWith(".signal.ts"))
-            files.signal.scalars.push(name);
-          else if (filename.endsWith(".store.ts"))
-            files.store.scalars.push(name);
-          else if (filename === "index.ts")
-            files.components.scalars.push(name);
-        });
-      })
-    );
-    const missingLibDeps = [];
-    libDeps.forEach((libName) => {
-      if (!akanConfig.libs.includes(libName))
-        missingLibDeps.push(libName);
-    });
-    if (missingLibDeps.length)
-      throw new Error(
-        `Missing libs: ${missingLibDeps.join(", ")}, add these dependencies in akan.config.ts as { libs: [...other deps, ${missingLibDeps.join(", ")}] }`
-      );
-    for (const libName of akanConfig.libs) {
-      if (libScanResults[libName])
-        continue;
-      const lib = new LibExecutor({ workspace: this.workspace, name: libName });
-      const akanConfig2 = await lib.getConfig();
-      libScanResults[libName] = await lib.scan({ akanConfig: akanConfig2 }, libScanResults);
+    refresh,
+    write = true,
+    writeLib = true
+  } = {}) {
+    if (this.#scanInfo && !refresh)
+      return this.#scanInfo;
+    const scanInfo = this.type === "app" ? await AppInfo.fromExecutor(this, { refresh }) : await LibInfo.fromExecutor(this, { refresh });
+    if (write) {
+      await Promise.all([
+        this._applyTemplate({ basePath: "lib", template: "lib", scanInfo }),
+        this._applyTemplate({ basePath: ".", template: "server.ts", scanInfo }),
+        this._applyTemplate({ basePath: ".", template: "client.ts", scanInfo }),
+        this.type === "lib" ? this._applyTemplate({ basePath: ".", template: "index.ts", scanInfo }) : null,
+        ...scanInfo.getDatabaseModules().map(
+          (model) => this._applyTemplate({
+            basePath: `lib/${model}`,
+            template: "moduleRoot",
+            scanInfo,
+            dict: { model, Model: capitalize(model) }
+          })
+        ),
+        ...scanInfo.getServiceModules().map(
+          (model) => this._applyTemplate({
+            basePath: `lib/_${model}`,
+            template: "moduleRoot",
+            scanInfo,
+            dict: { model, Model: capitalize(model) }
+          })
+        )
+      ]);
+      this.writeJson(`akan.${this.type}.json`, scanInfo.getScanResult());
+      if (this.type === "lib")
+        this.#updateDependencies(scanInfo);
+      if (writeLib) {
+        const libInfos = [...scanInfo.getLibInfos().values()];
+        await Promise.all(
+          libInfos.map((libInfo) => [
+            libInfo.exec._applyTemplate({ basePath: "lib", template: "lib", scanInfo: libInfo }),
+            libInfo.exec._applyTemplate({ basePath: ".", template: "server.ts", scanInfo: libInfo }),
+            libInfo.exec._applyTemplate({ basePath: ".", template: "client.ts", scanInfo: libInfo }),
+            libInfo.exec._applyTemplate({ basePath: ".", template: "index.ts", scanInfo: libInfo }),
+            ...libInfo.getDatabaseModules().map(
+              (model) => libInfo.exec._applyTemplate({
+                basePath: `lib/${model}`,
+                template: "moduleRoot",
+                scanInfo: libInfo,
+                dict: { model, Model: capitalize(model) }
+              })
+            ),
+            ...libInfo.getServiceModules().map(
+              (model) => libInfo.exec._applyTemplate({
+                basePath: `lib/_${model}`,
+                template: "moduleRoot",
+                scanInfo: libInfo,
+                dict: { model, Model: capitalize(model) }
+              })
+            )
+          ]).flat()
+        );
+      }
     }
-    const scanResult = {
-      name: this.name,
-      type: this.type,
-      repoName: this.workspace.repoName,
-      serveDomain: this.workspace.getBaseDevEnv().serveDomain,
-      akanConfig,
-      files,
-      libDeps,
-      pkgDeps,
-      dependencies: [...npmDepSet].filter((dep) => !dep.startsWith("@akanjs")),
-      libs: Object.fromEntries(akanConfig.libs.map((libName) => [libName, libScanResults[libName]]))
-    };
-    await this._applyTemplate({ basePath: "lib", template: "lib", scanResult });
-    await this._applyTemplate({ basePath: ".", template: "server.ts", scanResult });
-    await this._applyTemplate({ basePath: ".", template: "client.ts", scanResult });
-    if (this.type === "lib")
-      await this._applyTemplate({ basePath: ".", template: "index.ts", scanResult });
-    this.writeJson(`akan.${this.type}.json`, scanResult);
-    if (this.type === "app")
-      return scanResult;
-    const libPackageJson = this.readJson("package.json");
+    this.#scanInfo = scanInfo;
+    return scanInfo;
+  }
+  #updateDependencies(scanInfo) {
+    const rootPackageJson = this.workspace.getPackageJson();
+    const libPackageJson = this.getPackageJson();
+    const dependencies = scanInfo.getScanResult().dependencies;
     const libPkgJsonWithDeps = {
       ...libPackageJson,
       dependencies: {
         ...libPackageJson.dependencies,
         ...Object.fromEntries(
-          scanResult.dependencies.filter((dep) => rootPackageJson.dependencies?.[dep]).sort().map((dep) => [dep, rootPackageJson.dependencies?.[dep]])
+          dependencies.filter((dep) => rootPackageJson.dependencies?.[dep]).sort().map((dep) => [dep, rootPackageJson.dependencies?.[dep]])
         )
       },
       devDependencies: {
         ...libPackageJson.devDependencies,
         ...Object.fromEntries(
-          scanResult.dependencies.filter((dep) => rootPackageJson.devDependencies?.[dep]).sort().map((dep) => [dep, rootPackageJson.devDependencies?.[dep]])
+          dependencies.filter((dep) => rootPackageJson.devDependencies?.[dep]).sort().map((dep) => [dep, rootPackageJson.devDependencies?.[dep]])
         )
       }
     };
-    this.writeJson("package.json", libPkgJsonWithDeps);
-    return scanResult;
+    this.setPackageJson(libPkgJsonWithDeps);
   }
   getLocalFile(targetPath) {
     const filePath = path.isAbsolute(targetPath) ? targetPath : `${this.type}s/${this.name}/${targetPath}`;
@@ -792,9 +742,9 @@ class SysExecutor extends Executor {
       )
     };
     const akanConfig = await this.getConfig();
-    const scanResult = await this.scan({ akanConfig });
-    const fileContents = await this._applyTemplate({ ...options, scanResult, dict });
-    await this.scan({ akanConfig });
+    const scanInfo = await this.scan();
+    const fileContents = await this._applyTemplate({ ...options, scanInfo, dict });
+    await this.scan();
     return fileContents;
   }
   setTsPaths() {
@@ -809,21 +759,29 @@ class AppExecutor extends SysExecutor {
     super({ workspace, name, type: "app" });
     this.dist = new Executor(`dist/${name}`, `${this.workspace.workspaceRoot}/dist/apps/${name}`);
   }
+  static #execs = /* @__PURE__ */ new Map();
   static from(executor, name) {
-    if (executor instanceof WorkspaceExecutor)
+    const exec2 = this.#execs.get(name);
+    if (exec2)
+      return exec2;
+    else if (executor instanceof WorkspaceExecutor)
       return new AppExecutor({ workspace: executor, name });
-    return new AppExecutor({ workspace: executor.workspace, name });
+    else
+      return new AppExecutor({ workspace: executor.workspace, name });
   }
   getEnv() {
     return this.workspace.getBaseDevEnv().env;
   }
-  async getConfig(command) {
-    return await getAppConfig(this.cwdPath, {
+  #akanConfig = null;
+  async getConfig({ refresh } = {}) {
+    if (this.#akanConfig && !refresh)
+      return this.#akanConfig;
+    this.#akanConfig = await getAppConfig(this.cwdPath, {
       ...this.workspace.getBaseDevEnv(),
       type: "app",
-      name: this.name,
-      command
+      name: this.name
     });
+    return this.#akanConfig;
   }
   async syncAssets(libDeps) {
     const projectPublicLibPath = `${this.cwdPath}/public/libs`;
@@ -860,18 +818,26 @@ class LibExecutor extends SysExecutor {
     super({ workspace, name, type: "lib" });
     this.dist = new Executor(`dist/${name}`, `${this.workspace.workspaceRoot}/dist/libs/${name}`);
   }
+  static #execs = /* @__PURE__ */ new Map();
   static from(executor, name) {
-    if (executor instanceof WorkspaceExecutor)
+    const exec2 = this.#execs.get(name);
+    if (exec2)
+      return exec2;
+    else if (executor instanceof WorkspaceExecutor)
       return new LibExecutor({ workspace: executor, name });
-    return new LibExecutor({ workspace: executor.workspace, name });
-  }
-  async getConfig(command) {
-    return await getLibConfig(this.cwdPath, {
+    else
+      return new LibExecutor({ workspace: executor.workspace, name });
+  }
+  #akanConfig = null;
+  async getConfig({ refresh } = {}) {
+    if (this.#akanConfig && !refresh)
+      return this.#akanConfig;
+    this.#akanConfig = await getLibConfig(this.cwdPath, {
       ...this.workspace.getBaseDevEnv(),
       type: "lib",
-      name: this.name,
-      command
+      name: this.name
     });
+    return this.#akanConfig;
   }
 }
 class PkgExecutor extends Executor {
@@ -890,27 +856,13 @@ class PkgExecutor extends Executor {
       return new PkgExecutor({ workspace: executor, name });
     return new PkgExecutor({ workspace: executor.workspace, name });
   }
-  async scan({
-    packageJson = this.readJson(`${this.cwdPath}/package.json`),
-    tsconfig = this.getTsConfig(`${this.cwdPath}/tsconfig.json`)
-  } = {}) {
-    const rootPackageJson = this.readJson(`${this.workspace.workspaceRoot}/package.json`);
-    const scanner = new TypeScriptDependencyScanner(this.cwdPath);
-    const npmSet = new Set(Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies }));
-    const pkgPathSet = new Set(
-      Object.keys(tsconfig.compilerOptions.paths ?? {}).filter((path2) => tsconfig.compilerOptions.paths?.[path2]?.some((resolve) => resolve.startsWith("pkgs/"))).map((path2) => path2.replace("/*", ""))
-    );
-    const [npmDepSet, pkgPathDepSet] = await scanner.getImportSets([npmSet, pkgPathSet]);
-    const pkgDeps = [...pkgPathDepSet].map((path2) => {
-      const pathSplitLength = path2.split("/").length;
-      return (tsconfig.compilerOptions.paths?.[path2]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
-    }).filter((pkg) => pkg !== this.name);
-    const pkgScanResult = {
-      name: this.name,
-      pkgDeps,
-      dependencies: [...npmDepSet]
-    };
-    return pkgScanResult;
+  #scanInfo = null;
+  async scan({ refresh } = {}) {
+    if (this.#scanInfo && !refresh)
+      return this.#scanInfo;
+    const scanInfo = await PkgInfo.fromExecutor(this, { refresh });
+    this.#scanInfo = scanInfo;
+    return scanInfo;
   }
 }
 class ModuleExecutor extends Executor {

package/esm/src/index.js

@@ -20,3 +20,4 @@ export * from "./prompter";
 export * from "./guideline";
 export * from "./getDirname";
 export * from "./useStdoutDimensions";
+export * from "./scanInfo";