@akanjs/devkit 0.9.41 → 0.9.42

package/cjs/src/builder.js

@@ -104,8 +104,8 @@ class Builder {
       }
     };
     buildResult.outputFiles.map((file) => this.#distExecutor.writeFile(file.path, file.text));
-    this.#distExecutor.writeJson("package.json", pkgPackageJson);
-    this.#executor.writeJson("package.json", pkgPackageJson);
+    this.#distExecutor.setPackageJson(pkgPackageJson);
+    this.#executor.setPackageJson(pkgPackageJson);
   }
 }
 // Annotate the CommonJS export names for ESM import in node:

package/cjs/src/commandDecorators/command.js

@@ -217,8 +217,18 @@ const runCommands = async (...commands) => {
   });
   const __dirname = (0, import__.getDirname)(import_meta.url);
   const hasPackageJson = import_fs.default.existsSync(`${__dirname}/../package.json`);
-  const version = hasPackageJson ? JSON.parse(import_fs.default.readFileSync(`${__dirname}/../package.json`, "utf8")).version : "0.0.1";
-  import_commander.program.version(version).description("Akan CLI");
+  process.env.AKAN_VERSION = hasPackageJson ? JSON.parse(import_fs.default.readFileSync(`${__dirname}/../package.json`, "utf8")).version : "0.0.1";
+  import_commander.program.version(process.env.AKAN_VERSION).description("Akan CLI");
+  const akanBasePackageJson = import_fs.default.existsSync("./node_modules/@akanjs/base/package.json") ? JSON.parse(import_fs.default.readFileSync("./node_modules/@akanjs/base/package.json", "utf8")) : null;
+  if (akanBasePackageJson && akanBasePackageJson.version !== process.env.AKAN_VERSION) {
+    import_common.Logger.rawLog(
+      import_chalk.default.yellow(
+        `
+Akan CLI version is mismatch with installed package. ${process.env.AKAN_VERSION} (global) vs ${akanBasePackageJson.version} (base)
+It may cause unexpected behavior. Run \`akan update\` to update latest akanjs.`
+      )
+    );
+  }
   for (const command of commands) {
     const targetMetas = (0, import_targetMeta.getTargetMetas)(command);
     for (const targetMeta of targetMetas) {
@@ -281,7 +291,8 @@ const runCommands = async (...commands) => {
             import_common.Logger.rawLog();
           } catch (e) {
             const errMsg = e instanceof Error ? e.message : typeof e === "string" ? e : JSON.stringify(e);
-            import_common.Logger.error(`Command Error: ${import_chalk.default.red(errMsg)}`);
+            import_common.Logger.rawLog(`
+${import_chalk.default.red(errMsg)}`);
             throw e;
           }
         });

package/cjs/src/dependencyScanner.js

@@ -34,11 +34,37 @@ var fs = __toESM(require("fs"));
 var path = __toESM(require("path"));
 var ts = __toESM(require("typescript"));
 class TypeScriptDependencyScanner {
-  constructor(directory) {
-    this.directory = directory;
-  }
   #fileDependencies = /* @__PURE__ */ new Map();
   #visitedFiles = /* @__PURE__ */ new Set();
+  directory;
+  tsconfig;
+  rootPackageJson;
+  constructor(directory, { tsconfig, rootPackageJson }) {
+    this.directory = directory;
+    this.tsconfig = tsconfig;
+    this.rootPackageJson = rootPackageJson;
+  }
+  async getMonorepoDependencies(projectName) {
+    const npmSet = new Set(
+      Object.keys({ ...this.rootPackageJson.dependencies, ...this.rootPackageJson.devDependencies })
+    );
+    const pkgPathSet = new Set(
+      Object.keys(this.tsconfig.compilerOptions.paths ?? {}).filter((path2) => this.tsconfig.compilerOptions.paths?.[path2]?.some((resolve) => resolve.startsWith("pkgs/"))).map((path2) => path2.replace("/*", ""))
+    );
+    const libPathSet = new Set(
+      Object.keys(this.tsconfig.compilerOptions.paths ?? {}).filter((path2) => this.tsconfig.compilerOptions.paths?.[path2]?.some((resolve) => resolve.startsWith("libs/"))).map((path2) => path2.replace("/*", ""))
+    );
+    const [npmDepSet, pkgPathDepSet, libPathDepSet] = await this.getImportSets([npmSet, pkgPathSet, libPathSet]);
+    const pkgDeps = [...pkgPathDepSet].map((path2) => {
+      const pathSplitLength = path2.split("/").length;
+      return (this.tsconfig.compilerOptions.paths?.[path2]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
+    });
+    const libDeps = [...libPathDepSet].map((path2) => {
+      const pathSplitLength = path2.split("/").length;
+      return (this.tsconfig.compilerOptions.paths?.[path2]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
+    }).filter((libName) => libName !== projectName);
+    return { pkgDeps, libDeps, npmDeps: [...npmDepSet] };
+  }
   async getImportSets(depSets) {
     const fileDependencies = await this.getDependencies();
     const importedDepSets = new Array(depSets.length);

package/cjs/src/executors.js

@@ -45,9 +45,9 @@ var import_dotenv = __toESM(require("dotenv"));
 var import_fs = __toESM(require("fs"));
 var import_promises = __toESM(require("fs/promises"));
 var import_path = __toESM(require("path"));
-var import_dependencyScanner = require("./dependencyScanner");
 var import_getDirname = require("./getDirname");
 var import_linter = require("./linter");
+var import_scanInfo = require("./scanInfo");
 var import_spinner = require("./spinner");
 var import_typeChecker = require("./typeChecker");
 const import_meta = {};
@@ -195,6 +195,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 import_promises.default.stat(import_path.default.join(fullDirPath, p));
+        if (stats.isDirectory())
+          dirs.push(p);
+        else
+          files.push(p);
+      })
+    );
+    return { files, dirs };
+  }
   exists(filePath) {
     const readPath = this.getPath(filePath);
     return import_fs.default.existsSync(readPath);
@@ -226,11 +242,12 @@ class Executor {
         contentStr = import_fs.default.readFileSync(writePath, "utf-8");
       } else {
         import_fs.default.writeFileSync(writePath, contentStr, "utf8");
-        this.logger.verbose(`File ${writePath} is changed`);
+        if (import_common.Logger.isVerbose())
+          this.logger.rawLog(import_chalk.default.yellow(`File Update: ${filePath}`));
       }
     } else {
       import_fs.default.writeFileSync(writePath, contentStr, "utf8");
-      this.logger.verbose(`File ${writePath} is created`);
+      this.logger.rawLog(import_chalk.default.green(`File Create: ${filePath}`));
     }
     return { filePath: writePath, content: contentStr };
   }
@@ -267,7 +284,10 @@ class Executor {
   spinning(msg, { prefix = `${this.emoji}${this.name}`, indent = 0, enableSpin = !Executor.verbose } = {}) {
     return new import_spinner.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);
@@ -277,17 +297,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 : import_path.default.basename(targetPath).replace(".js", ".ts");
@@ -317,7 +354,7 @@ class Executor {
   async _applyTemplate({
     basePath,
     template,
-    scanResult,
+    scanInfo,
     dict = {},
     overwrite = true
   }) {
@@ -326,7 +363,7 @@ class Executor {
     if (import_fs.default.statSync(prefixTemplatePath).isFile()) {
       const filename = import_path.default.basename(prefixTemplatePath);
       const fileContent = await this.#applyTemplateFile(
-        { templatePath: prefixTemplatePath, targetPath: import_path.default.join(basePath, filename), scanResult, overwrite },
+        { templatePath: prefixTemplatePath, targetPath: import_path.default.join(basePath, filename), scanInfo, overwrite },
         dict
       );
       return fileContent ? [fileContent] : [];
@@ -337,7 +374,7 @@ class Executor {
           const subpath = import_path.default.join(templatePath, subdir);
           if (import_fs.default.statSync(subpath).isFile()) {
             const fileContent = await this.#applyTemplateFile(
-              { templatePath: subpath, targetPath: import_path.default.join(basePath, subdir), scanResult, overwrite },
+              { templatePath: subpath, targetPath: import_path.default.join(basePath, subdir), scanInfo, overwrite },
               dict
             );
             return fileContent ? [fileContent] : [];
@@ -345,7 +382,7 @@ class Executor {
             return await this._applyTemplate({
               basePath: import_path.default.join(basePath, subdir),
               template: import_path.default.join(template, subdir),
-              scanResult,
+              scanInfo,
               dict,
               overwrite
             });
@@ -395,9 +432,12 @@ class WorkspaceExecutor extends Executor {
     this.workspaceRoot = workspaceRoot;
     this.repoName = repoName;
   }
-  static fromRoot() {
-    const repoName = import_path.default.basename(process.cwd());
-    return new WorkspaceExecutor({ workspaceRoot: process.cwd(), repoName });
+  static #execs = /* @__PURE__ */ new Map();
+  static fromRoot({
+    workspaceRoot = process.cwd(),
+    repoName = import_path.default.basename(process.cwd())
+  } = {}) {
+    return this.#execs.get(repoName) ?? new WorkspaceExecutor({ workspaceRoot, repoName });
   }
   getBaseDevEnv() {
     const envFile = import_dotenv.default.parse(this.readFile(".env"));
@@ -415,36 +455,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 import_scanInfo.WorkspaceInfo.fromExecutor(this);
   }
   async getApps() {
     if (!import_fs.default.existsSync(`${this.workspaceRoot}/apps`))
@@ -592,160 +603,103 @@ class SysExecutor extends Executor {
     this.type = type;
     this.emoji = execEmoji[type];
   }
-  async getConfig(command) {
-    return this.type === "app" ? await (0, import_config.getAppConfig)(this.cwdPath, { ...this.workspace.getBaseDevEnv(), type: "app", name: this.name, command }) : await (0, import_config.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 (0, import_config.getAppConfig)(this.cwdPath, { ...this.workspace.getBaseDevEnv(), type: "app", name: this.name }) : await (0, import_config.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 import_dependencyScanner.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 (!import_fs.default.existsSync(`${this.cwdPath}/lib/__scalar`))
-      import_fs.default.mkdirSync(`${this.cwdPath}/lib/__scalar`, { recursive: true });
-    const files = (0, import_config.getDefaultFileScan)();
-    const dirnames = (await this.readdir("lib")).filter(
-      (name) => import_fs.default.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(import_path.default.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(import_path.default.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(import_path.default.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 import_scanInfo.AppInfo.fromExecutor(this, { refresh }) : await import_scanInfo.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: (0, import_common.capitalize)(model) }
+          })
+        ),
+        ...scanInfo.getServiceModules().map(
+          (model) => this._applyTemplate({
+            basePath: `lib/_${model}`,
+            template: "moduleRoot",
+            scanInfo,
+            dict: { model, Model: (0, import_common.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: (0, import_common.capitalize)(model) }
+              })
+            ),
+            ...libInfo.getServiceModules().map(
+              (model) => libInfo.exec._applyTemplate({
+                basePath: `lib/_${model}`,
+                template: "moduleRoot",
+                scanInfo: libInfo,
+                dict: { model, Model: (0, import_common.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 = import_path.default.isAbsolute(targetPath) ? targetPath : `${this.type}s/${this.name}/${targetPath}`;
@@ -828,9 +782,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() {
@@ -845,21 +799,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 (0, import_config.getAppConfig)(this.cwdPath, {
+  #akanConfig = null;
+  async getConfig({ refresh } = {}) {
+    if (this.#akanConfig && !refresh)
+      return this.#akanConfig;
+    this.#akanConfig = await (0, import_config.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`;
@@ -896,18 +858,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 (0, import_config.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 (0, import_config.getLibConfig)(this.cwdPath, {
       ...this.workspace.getBaseDevEnv(),
       type: "lib",
-      name: this.name,
-      command
+      name: this.name
     });
+    return this.#akanConfig;
   }
 }
 class PkgExecutor extends Executor {
@@ -926,27 +896,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 import_dependencyScanner.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 import_scanInfo.PkgInfo.fromExecutor(this, { refresh });
+    this.#scanInfo = scanInfo;
+    return scanInfo;
   }
 }
 class ModuleExecutor extends Executor {

package/cjs/src/index.js

@@ -36,6 +36,7 @@ __reExport(src_exports, require("./prompter"), module.exports);
 __reExport(src_exports, require("./guideline"), module.exports);
 __reExport(src_exports, require("./getDirname"), module.exports);
 __reExport(src_exports, require("./useStdoutDimensions"), module.exports);
+__reExport(src_exports, require("./scanInfo"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./createTunnel"),
@@ -59,5 +60,6 @@ __reExport(src_exports, require("./useStdoutDimensions"), module.exports);
   ...require("./prompter"),
   ...require("./guideline"),
   ...require("./getDirname"),
-  ...require("./useStdoutDimensions")
+  ...require("./useStdoutDimensions"),
+  ...require("./scanInfo")
 });