@akanjs/cli 0.9.41 → 0.9.42

package/cjs/index.js

@@ -142,6 +142,9 @@ var Logger = class _Logger {
     this.level = level;
     this.#levelIdx = logLevels.findIndex((l) => l === level);
   }
+  static isVerbose() {
+    return this.#levelIdx <= 1;
+  }
   name;
   constructor(name) {
     this.name = name;
@@ -400,8 +403,8 @@ var fs3 = __toESM(require("fs"));
 var import_ora2 = __toESM(require("ora"));
 var ts = __toESM(require("typescript"));
 var parseTsConfig = (tsConfigPath = "./tsconfig.json") => {
-  const configFile = ts.readConfigFile(tsConfigPath, (path9) => {
-    return ts.sys.readFile(path9);
+  const configFile = ts.readConfigFile(tsConfigPath, (path10) => {
+    return ts.sys.readFile(path10);
   });
   return ts.parseJsonConfigFileContent(
     configFile.config,
@@ -720,47 +723,12 @@ export default getNextConfig(config, appInfo);
 
 // pkgs/@akanjs/config/src/types.ts
 var archs = ["amd64", "arm64"];
-var getDefaultFileScan = () => ({
-  constants: {
-    databases: [],
-    scalars: []
-  },
-  dictionary: {
-    databases: [],
-    services: [],
-    scalars: []
-  },
-  documents: {
-    databases: [],
-    scalars: []
-  },
-  services: {
-    databases: [],
-    services: [],
-    scalars: []
-  },
-  signal: {
-    databases: [],
-    services: [],
-    scalars: []
-  },
-  store: {
-    databases: [],
-    services: [],
-    scalars: []
-  },
-  components: {
-    databases: [],
-    services: [],
-    scalars: []
-  }
-});
 
 // pkgs/@akanjs/config/src/akanConfig.ts
 var import_meta = {};
 var jiti = (0, import_jiti.createJiti)(import_meta.url);
 var makeAppConfig = (config, props) => {
-  const { name, repoName, serveDomain, env, command = "build" } = props;
+  const { name, repoName } = props;
   return {
     rootLib: config.rootLib,
     libs: config.libs ?? [],
@@ -906,18 +874,254 @@ var import_child_process = require("child_process");
 var import_dotenv = __toESM(require("dotenv"));
 var import_fs4 = __toESM(require("fs"));
 var import_promises = __toESM(require("fs/promises"));
+var import_path4 = __toESM(require("path"));
+
+// pkgs/@akanjs/devkit/src/getDirname.ts
+var import_path2 = __toESM(require("path"));
+var getDirname = (url) => import_path2.default.dirname(new URL(url).pathname);
+
+// pkgs/@akanjs/devkit/src/linter.ts
+var import_chalk = __toESM(require("chalk"));
+var import_eslint = require("eslint");
+var fs5 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var Linter = class {
+  #logger = new Logger("Linter");
+  #eslint;
+  lintRoot;
+  constructor(cwdPath) {
+    this.lintRoot = this.#findEslintRootPath(cwdPath);
+    this.#eslint = new import_eslint.ESLint({ cwd: this.lintRoot, errorOnUnmatchedPattern: false });
+  }
+  #findEslintRootPath(dir) {
+    const configPath2 = path3.join(dir, "eslint.config.ts");
+    if (fs5.existsSync(configPath2))
+      return dir;
+    const parentDir = path3.dirname(dir);
+    return this.#findEslintRootPath(parentDir);
+  }
+  async lint(filePath, { fix = false, dryRun = false } = {}) {
+    if (fix)
+      return await this.fixFile(filePath, dryRun);
+    return await this.lintFile(filePath);
+  }
+  /**
+   * Lint a single file using ESLint
+   * @param filePath - Path to the file to lint
+   * @returns Array of ESLint results
+   */
+  async lintFile(filePath) {
+    if (!fs5.existsSync(filePath))
+      throw new Error(`File not found: ${filePath}`);
+    const isIgnored = await this.#eslint.isPathIgnored(filePath);
+    if (isIgnored) {
+      this.#logger.warn(`File ${filePath} is ignored by ESLint configuration`);
+      return { fixed: false, results: [], errors: [], warnings: [] };
+    }
+    const results = await this.#eslint.lintFiles([filePath]);
+    const errors = results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
+    const warnings = results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
+    return { fixed: false, results, errors, warnings };
+  }
+  /**
+   * Format lint results for console output
+   * @param results - Array of ESLint results
+   * @returns Formatted string
+   */
+  formatLintResults(results) {
+    if (results.length === 0)
+      return "No files to lint";
+    const output = [];
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    results.forEach((result) => {
+      totalErrors += result.errorCount;
+      totalWarnings += result.warningCount;
+      if (result.messages.length > 0) {
+        output.push(`
+${import_chalk.default.cyan(result.filePath)}`);
+        let sourceLines = [];
+        if (fs5.existsSync(result.filePath)) {
+          try {
+            const sourceContent = fs5.readFileSync(result.filePath, "utf8");
+            sourceLines = sourceContent.split("\n");
+          } catch (error) {
+          }
+        }
+        result.messages.forEach((message) => {
+          const type = message.severity === 2 ? "error" : "warning";
+          const typeColor = message.severity === 2 ? import_chalk.default.red : import_chalk.default.yellow;
+          const icon = message.severity === 2 ? "\u274C" : "\u26A0\uFE0F";
+          const ruleInfo = message.ruleId ? import_chalk.default.dim(` (${message.ruleId})`) : "";
+          output.push(`
+  ${icon} ${typeColor(type)}: ${message.message}${ruleInfo}`);
+          output.push(`     ${import_chalk.default.gray("at")} ${result.filePath}:${import_chalk.default.bold(`${message.line}:${message.column}`)}`);
+          if (sourceLines.length > 0 && message.line <= sourceLines.length) {
+            const sourceLine = sourceLines[message.line - 1];
+            const lineNumber = message.line.toString().padStart(5, " ");
+            output.push(`
+${import_chalk.default.dim(lineNumber + " |")} ${sourceLine}`);
+            const underlinePrefix = " ".repeat(message.column - 1);
+            const underlineLength = message.endColumn ? message.endColumn - message.column : 1;
+            const underline = "^".repeat(Math.max(1, underlineLength));
+            output.push(`${import_chalk.default.dim(" ".repeat(lineNumber.length) + " |")} ${underlinePrefix}${typeColor(underline)}`);
+          }
+        });
+      }
+    });
+    if (totalErrors === 0 && totalWarnings === 0)
+      return import_chalk.default.bold("\u2705 No ESLint errors or warnings found");
+    const errorText = totalErrors > 0 ? import_chalk.default.red(`${totalErrors} error(s)`) : "0 errors";
+    const warningText = totalWarnings > 0 ? import_chalk.default.yellow(`${totalWarnings} warning(s)`) : "0 warnings";
+    const summary = [`
+${errorText}, ${warningText} found`];
+    return summary.concat(output).join("\n");
+  }
+  /**
+   * Get detailed lint information
+   * @param filePath - Path to the file to lint
+   * @returns Object containing detailed lint information
+   */
+  async getDetailedLintInfo(filePath) {
+    const { results } = await this.lintFile(filePath);
+    const details = results.flatMap(
+      (result) => result.messages.map((message) => ({
+        line: message.line,
+        column: message.column,
+        message: message.message,
+        ruleId: message.ruleId,
+        severity: message.severity === 2 ? "error" : "warning",
+        fix: message.fix,
+        suggestions: message.suggestions
+      }))
+    );
+    const stats = results.reduce(
+      (acc, result) => ({
+        errorCount: acc.errorCount + result.errorCount,
+        warningCount: acc.warningCount + result.warningCount,
+        fixableErrorCount: acc.fixableErrorCount + result.fixableErrorCount,
+        fixableWarningCount: acc.fixableWarningCount + result.fixableWarningCount
+      }),
+      { errorCount: 0, warningCount: 0, fixableErrorCount: 0, fixableWarningCount: 0 }
+    );
+    return { results, details, stats };
+  }
+  /**
+   * Check if a file has lint errors
+   * @param filePath - Path to the file to check
+   * @returns true if there are no errors, false otherwise
+   */
+  async hasNoLintErrors(filePath) {
+    try {
+      const { results } = await this.lintFile(filePath);
+      return results.every((result) => result.errorCount === 0);
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Get only error messages (excluding warnings)
+   * @param filePath - Path to the file to lint
+   * @returns Array of error messages
+   */
+  async getErrors(filePath) {
+    const { results } = await this.lintFile(filePath);
+    return results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
+  }
+  /**
+   * Get only warning messages
+   * @param filePath - Path to the file to lint
+   * @returns Array of warning messages
+   */
+  async getWarnings(filePath) {
+    const { results } = await this.lintFile(filePath);
+    return results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
+  }
+  /**
+   * Fix lint errors automatically
+   * @param filePath - Path to the file to fix
+   * @param dryRun - If true, returns the fixed content without writing to file
+   * @returns Fixed content and remaining issues
+   */
+  async fixFile(filePath, dryRun = false) {
+    if (!fs5.existsSync(filePath))
+      throw new Error(`File not found: ${filePath}`);
+    const eslint = new import_eslint.ESLint({ cwd: this.lintRoot, fix: true });
+    const results = await eslint.lintFiles([filePath]);
+    const errors = results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
+    const warnings = results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
+    if (!dryRun)
+      await import_eslint.ESLint.outputFixes(results);
+    const fixedResult = results[0];
+    return { fixed: fixedResult.output !== void 0, output: fixedResult.output, results, errors, warnings };
+  }
+  /**
+   * Get ESLint configuration for a file
+   * @param filePath - Path to the file
+   * @returns ESLint configuration object
+   */
+  async getConfigForFile(filePath) {
+    const eslint = new import_eslint.ESLint();
+    const config = await eslint.calculateConfigForFile(filePath);
+    return config;
+  }
+  /**
+   * Get rules that are causing errors in a file
+   * @param filePath - Path to the file to check
+   * @returns Object mapping rule IDs to their error counts
+   */
+  async getProblematicRules(filePath) {
+    const { results } = await this.lintFile(filePath);
+    const ruleCounts = {};
+    results.forEach((result) => {
+      result.messages.forEach((message) => {
+        if (message.ruleId)
+          ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
+      });
+    });
+    return ruleCounts;
+  }
+};
+
+// pkgs/@akanjs/devkit/src/scanInfo.ts
 var import_path3 = __toESM(require("path"));
 
 // pkgs/@akanjs/devkit/src/dependencyScanner.ts
-var fs5 = __toESM(require("fs"));
-var path2 = __toESM(require("path"));
+var fs6 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
 var ts2 = __toESM(require("typescript"));
 var TypeScriptDependencyScanner = class {
-  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((path10) => this.tsconfig.compilerOptions.paths?.[path10]?.some((resolve) => resolve.startsWith("pkgs/"))).map((path10) => path10.replace("/*", ""))
+    );
+    const libPathSet = new Set(
+      Object.keys(this.tsconfig.compilerOptions.paths ?? {}).filter((path10) => this.tsconfig.compilerOptions.paths?.[path10]?.some((resolve) => resolve.startsWith("libs/"))).map((path10) => path10.replace("/*", ""))
+    );
+    const [npmDepSet, pkgPathDepSet, libPathDepSet] = await this.getImportSets([npmSet, pkgPathSet, libPathSet]);
+    const pkgDeps = [...pkgPathDepSet].map((path10) => {
+      const pathSplitLength = path10.split("/").length;
+      return (this.tsconfig.compilerOptions.paths?.[path10]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
+    });
+    const libDeps = [...libPathDepSet].map((path10) => {
+      const pathSplitLength = path10.split("/").length;
+      return (this.tsconfig.compilerOptions.paths?.[path10]?.[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);
@@ -954,9 +1158,9 @@ var TypeScriptDependencyScanner = class {
   async #findTypeScriptFiles(directory) {
     const files = [];
     const processDirectory = async (dir) => {
-      const entries = await fs5.promises.readdir(dir, { withFileTypes: true });
+      const entries = await fs6.promises.readdir(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = path2.join(dir, entry.name);
+        const fullPath = path4.join(dir, entry.name);
         if (entry.isDirectory()) {
           if (!["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android"].includes(entry.name))
             await processDirectory(fullPath);
@@ -972,26 +1176,26 @@ var TypeScriptDependencyScanner = class {
       return;
     this.#visitedFiles.add(filePath);
     try {
-      const fileContent = await fs5.promises.readFile(filePath, "utf-8");
+      const fileContent = await fs6.promises.readFile(filePath, "utf-8");
       const imports = this.#extractImports(fileContent, filePath);
       const resolvedImports = imports.map((importPath) => {
         if (importPath.startsWith(".")) {
-          const resolvedPath = "./" + path2.join(path2.relative(baseDir, filePath), importPath);
+          const resolvedPath = "./" + path4.join(path4.relative(baseDir, filePath), importPath);
           return this.#ensureExtension(resolvedPath);
         }
         return importPath;
       });
-      const relativePath = path2.relative(baseDir, filePath);
+      const relativePath = path4.relative(baseDir, filePath);
       this.#fileDependencies.set(relativePath, resolvedImports);
     } catch (error) {
     }
   }
   #ensureExtension(filePath) {
-    if (fs5.existsSync(`${filePath}.ts`))
+    if (fs6.existsSync(`${filePath}.ts`))
       return `${filePath}.ts`;
-    else if (fs5.existsSync(`${filePath}.tsx`))
+    else if (fs6.existsSync(`${filePath}.tsx`))
       return `${filePath}.tsx`;
-    else if (fs5.existsSync(filePath))
+    else if (fs6.existsSync(filePath))
       return filePath;
     return `${filePath}.ts`;
   }
@@ -1055,217 +1259,442 @@ var TypeScriptDependencyScanner = class {
   }
 };
 
-// pkgs/@akanjs/devkit/src/getDirname.ts
-var import_path2 = __toESM(require("path"));
-var getDirname = (url) => import_path2.default.dirname(new URL(url).pathname);
-
-// pkgs/@akanjs/devkit/src/linter.ts
-var import_chalk = __toESM(require("chalk"));
-var import_eslint = require("eslint");
-var fs6 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
-var Linter = class {
-  #logger = new Logger("Linter");
-  #eslint;
-  lintRoot;
-  constructor(cwdPath) {
-    this.lintRoot = this.#findEslintRootPath(cwdPath);
-    this.#eslint = new import_eslint.ESLint({ cwd: this.lintRoot, errorOnUnmatchedPattern: false });
-  }
-  #findEslintRootPath(dir) {
-    const configPath2 = path4.join(dir, "eslint.config.ts");
-    if (fs6.existsSync(configPath2))
-      return dir;
-    const parentDir = path4.dirname(dir);
-    return this.#findEslintRootPath(parentDir);
-  }
-  async lint(filePath, { fix = false, dryRun = false } = {}) {
-    if (fix)
-      return await this.fixFile(filePath, dryRun);
-    return await this.lintFile(filePath);
-  }
-  /**
-   * Lint a single file using ESLint
-   * @param filePath - Path to the file to lint
-   * @returns Array of ESLint results
-   */
-  async lintFile(filePath) {
-    if (!fs6.existsSync(filePath))
-      throw new Error(`File not found: ${filePath}`);
-    const isIgnored = await this.#eslint.isPathIgnored(filePath);
-    if (isIgnored) {
-      this.#logger.warn(`File ${filePath} is ignored by ESLint configuration`);
-      return { fixed: false, results: [], errors: [], warnings: [] };
-    }
-    const results = await this.#eslint.lintFiles([filePath]);
-    const errors = results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
-    const warnings = results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
-    return { fixed: false, results, errors, warnings };
-  }
-  /**
-   * Format lint results for console output
-   * @param results - Array of ESLint results
-   * @returns Formatted string
-   */
-  formatLintResults(results) {
-    if (results.length === 0)
-      return "No files to lint";
-    const output = [];
-    let totalErrors = 0;
-    let totalWarnings = 0;
-    results.forEach((result) => {
-      totalErrors += result.errorCount;
-      totalWarnings += result.warningCount;
-      if (result.messages.length > 0) {
-        output.push(`
-${import_chalk.default.cyan(result.filePath)}`);
-        let sourceLines = [];
-        if (fs6.existsSync(result.filePath)) {
-          try {
-            const sourceContent = fs6.readFileSync(result.filePath, "utf8");
-            sourceLines = sourceContent.split("\n");
-          } catch (error) {
-          }
-        }
-        result.messages.forEach((message) => {
-          const type = message.severity === 2 ? "error" : "warning";
-          const typeColor = message.severity === 2 ? import_chalk.default.red : import_chalk.default.yellow;
-          const icon = message.severity === 2 ? "\u274C" : "\u26A0\uFE0F";
-          const ruleInfo = message.ruleId ? import_chalk.default.dim(` (${message.ruleId})`) : "";
-          output.push(`
-  ${icon} ${typeColor(type)}: ${message.message}${ruleInfo}`);
-          output.push(`     ${import_chalk.default.gray("at")} ${result.filePath}:${import_chalk.default.bold(`${message.line}:${message.column}`)}`);
-          if (sourceLines.length > 0 && message.line <= sourceLines.length) {
-            const sourceLine = sourceLines[message.line - 1];
-            const lineNumber = message.line.toString().padStart(5, " ");
-            output.push(`
-${import_chalk.default.dim(lineNumber + " |")} ${sourceLine}`);
-            const underlinePrefix = " ".repeat(message.column - 1);
-            const underlineLength = message.endColumn ? message.endColumn - message.column : 1;
-            const underline = "^".repeat(Math.max(1, underlineLength));
-            output.push(`${import_chalk.default.dim(" ".repeat(lineNumber.length) + " |")} ${underlinePrefix}${typeColor(underline)}`);
-          }
-        });
-      }
+// pkgs/@akanjs/devkit/src/scanInfo.ts
+var databaseFileTypes = [
+  "constant",
+  "dictionary",
+  "document",
+  "service",
+  "signal",
+  "store",
+  "template",
+  "unit",
+  "util",
+  "view",
+  "zone"
+];
+var ScanInfo = class {
+  scanResult;
+  name;
+  scalar = /* @__PURE__ */ new Map();
+  service = /* @__PURE__ */ new Map();
+  database = /* @__PURE__ */ new Map();
+  file = Object.fromEntries(
+    databaseFileTypes.map((type) => [
+      type,
+      { all: /* @__PURE__ */ new Set(), databases: /* @__PURE__ */ new Set(), services: /* @__PURE__ */ new Set(), scalars: /* @__PURE__ */ new Set() }
+    ])
+  );
+  constants = /* @__PURE__ */ new Set();
+  dictionaries = /* @__PURE__ */ new Set();
+  documents = /* @__PURE__ */ new Set();
+  services = /* @__PURE__ */ new Set();
+  signals = /* @__PURE__ */ new Set();
+  stores = /* @__PURE__ */ new Set();
+  templates = /* @__PURE__ */ new Set();
+  units = /* @__PURE__ */ new Set();
+  utils = /* @__PURE__ */ new Set();
+  views = /* @__PURE__ */ new Set();
+  zones = /* @__PURE__ */ new Set();
+  static async getScanResult(exec2) {
+    const akanConfig = await exec2.getConfig();
+    const tsconfig = exec2.getTsConfig();
+    const rootPackageJson = exec2.workspace.getPackageJson();
+    const scanner = new TypeScriptDependencyScanner(exec2.cwdPath, { tsconfig, rootPackageJson });
+    const { pkgDeps, libDeps, npmDeps } = await scanner.getMonorepoDependencies(exec2.name);
+    const files = {
+      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 [{ dirs: dirnames }, scalarDirs] = await Promise.all([
+      exec2.getFilesAndDirs("lib"),
+      exec2.readdir("lib/__scalar")
+    ]);
+    const databaseDirs = [];
+    const serviceDirs = [];
+    dirnames.forEach((name) => {
+      if (name.startsWith("_")) {
+        if (name.startsWith("__"))
+          return;
+        else
+          serviceDirs.push(name);
+      } else
+        databaseDirs.push(name);
     });
-    if (totalErrors === 0 && totalWarnings === 0)
-      return import_chalk.default.bold("\u2705 No ESLint errors or warnings found");
-    const errorText = totalErrors > 0 ? import_chalk.default.red(`${totalErrors} error(s)`) : "0 errors";
-    const warningText = totalWarnings > 0 ? import_chalk.default.yellow(`${totalWarnings} warning(s)`) : "0 warnings";
-    const summary = [`
-${errorText}, ${warningText} found`];
-    return summary.concat(output).join("\n");
-  }
-  /**
-   * Get detailed lint information
-   * @param filePath - Path to the file to lint
-   * @returns Object containing detailed lint information
-   */
-  async getDetailedLintInfo(filePath) {
-    const { results } = await this.lintFile(filePath);
-    const details = results.flatMap(
-      (result) => result.messages.map((message) => ({
-        line: message.line,
-        column: message.column,
-        message: message.message,
-        ruleId: message.ruleId,
-        severity: message.severity === 2 ? "error" : "warning",
-        fix: message.fix,
-        suggestions: message.suggestions
-      }))
-    );
-    const stats = results.reduce(
-      (acc, result) => ({
-        errorCount: acc.errorCount + result.errorCount,
-        warningCount: acc.warningCount + result.warningCount,
-        fixableErrorCount: acc.fixableErrorCount + result.fixableErrorCount,
-        fixableWarningCount: acc.fixableWarningCount + result.fixableWarningCount
+    await Promise.all([
+      ...databaseDirs.map(async (name) => {
+        const filenames = await exec2.readdir(import_path3.default.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);
+        });
       }),
-      { errorCount: 0, warningCount: 0, fixableErrorCount: 0, fixableWarningCount: 0 }
+      ...serviceDirs.map(async (dirname3) => {
+        const name = dirname3.slice(1);
+        const filenames = await exec2.readdir(import_path3.default.join("lib", dirname3));
+        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 exec2.readdir(import_path3.default.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 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(", ")}] }`
+      );
+    const scanResult = {
+      name: exec2.name,
+      type: exec2.type,
+      repoName: exec2.workspace.repoName,
+      serveDomain: exec2.workspace.getBaseDevEnv().serveDomain,
+      akanConfig,
+      files,
+      libDeps,
+      pkgDeps,
+      dependencies: npmDeps.filter((dep) => !dep.startsWith("@akanjs"))
+    };
+    return scanResult;
+  }
+  constructor(scanResult) {
+    this.name = scanResult.name;
+    this.scanResult = scanResult;
+    Object.entries(scanResult.files).forEach(
+      ([key, value]) => {
+        const { databases, services, scalars } = value;
+        databases.forEach((modelName) => {
+          const model = this.database.get(modelName) ?? /* @__PURE__ */ new Set();
+          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) ?? /* @__PURE__ */ new Set();
+          service.add(key);
+          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) ?? /* @__PURE__ */ new Set();
+          scalar.add(key);
+          this.scalar.set(scalarName, scalar);
+          this.file[key].all.add(scalarName);
+          this.file[key].scalars.add(scalarName);
+        });
+      }
     );
-    return { results, details, stats };
   }
-  /**
-   * Check if a file has lint errors
-   * @param filePath - Path to the file to check
-   * @returns true if there are no errors, false otherwise
-   */
-  async hasNoLintErrors(filePath) {
-    try {
-      const { results } = await this.lintFile(filePath);
-      return results.every((result) => result.errorCount === 0);
-    } catch (error) {
-      return false;
-    }
+  getScanResult() {
+    return this.scanResult;
   }
-  /**
-   * Get only error messages (excluding warnings)
-   * @param filePath - Path to the file to lint
-   * @returns Array of error messages
-   */
-  async getErrors(filePath) {
-    const { results } = await this.lintFile(filePath);
-    return results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
+  getDatabaseModules() {
+    return [...this.database.keys()];
   }
-  /**
-   * Get only warning messages
-   * @param filePath - Path to the file to lint
-   * @returns Array of warning messages
-   */
-  async getWarnings(filePath) {
-    const { results } = await this.lintFile(filePath);
-    return results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
+  getServiceModules() {
+    return [...this.service.keys()];
   }
-  /**
-   * Fix lint errors automatically
-   * @param filePath - Path to the file to fix
-   * @param dryRun - If true, returns the fixed content without writing to file
-   * @returns Fixed content and remaining issues
-   */
-  async fixFile(filePath, dryRun = false) {
-    if (!fs6.existsSync(filePath))
-      throw new Error(`File not found: ${filePath}`);
-    const eslint = new import_eslint.ESLint({ cwd: this.lintRoot, fix: true });
-    const results = await eslint.lintFiles([filePath]);
-    const errors = results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
-    const warnings = results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
-    if (!dryRun)
-      await import_eslint.ESLint.outputFixes(results);
-    const fixedResult = results[0];
-    return { fixed: fixedResult.output !== void 0, output: fixedResult.output, results, errors, warnings };
+  getScalarModules() {
+    return [...this.scalar.keys()];
   }
-  /**
-   * Get ESLint configuration for a file
-   * @param filePath - Path to the file
-   * @returns ESLint configuration object
-   */
-  async getConfigForFile(filePath) {
-    const eslint = new import_eslint.ESLint();
-    const config = await eslint.calculateConfigForFile(filePath);
-    return config;
+};
+var AppInfo = class _AppInfo extends ScanInfo {
+  type = "app";
+  exec;
+  akanConfig;
+  static appInfos = /* @__PURE__ */ new Map();
+  static async fromExecutor(exec2, options = {}) {
+    const existingAppInfo = this.appInfos.get(exec2.name);
+    if (existingAppInfo && !options.refresh)
+      return existingAppInfo;
+    const scanResult = await super.getScanResult(exec2);
+    await Promise.all(
+      scanResult.libDeps.map(async (libName) => {
+        LibInfo.loadedLibs.add(libName);
+        const libExecutor = LibExecutor.from(exec2, libName);
+        LibInfo.libInfos.set(libName, await LibInfo.fromExecutor(libExecutor));
+      })
+    );
+    const appInfo = new _AppInfo(exec2, scanResult);
+    this.appInfos.set(exec2.name, appInfo);
+    return appInfo;
+  }
+  constructor(exec2, scanResult) {
+    super(scanResult);
+    this.exec = exec2;
+    this.akanConfig = scanResult.akanConfig;
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+  #sortedLibs = null;
+  #getSortedLibs() {
+    if (this.#sortedLibs)
+      return this.#sortedLibs;
+    const libIndices = LibInfo.getSortedLibIndices();
+    this.#sortedLibs = this.akanConfig.libs.sort((libNameA, libNameB) => {
+      const indexA = libIndices.get(libNameA);
+      const indexB = libIndices.get(libNameB);
+      if (indexA === void 0 || indexB === void 0)
+        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
+      return indexA - indexB;
+    });
+    return this.#sortedLibs;
+  }
+  getLibs() {
+    return this.#getSortedLibs();
+  }
+  getLibInfo(libName) {
+    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];
+      })
+    );
   }
-  /**
-   * Get rules that are causing errors in a file
-   * @param filePath - Path to the file to check
-   * @returns Object mapping rule IDs to their error counts
-   */
-  async getProblematicRules(filePath) {
-    const { results } = await this.lintFile(filePath);
-    const ruleCounts = {};
-    results.forEach((result) => {
-      result.messages.forEach((message) => {
-        if (message.ruleId)
-          ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
-      });
+};
+var LibInfo = class _LibInfo extends ScanInfo {
+  type = "lib";
+  exec;
+  akanConfig;
+  static loadedLibs = /* @__PURE__ */ new Set();
+  static libInfos = /* @__PURE__ */ new Map();
+  static #sortedLibIndices = null;
+  static getSortedLibIndices() {
+    if (this.#sortedLibIndices)
+      return this.#sortedLibIndices;
+    this.#sortedLibIndices = new Map(
+      [...this.libInfos.entries()].sort(([_, libInfoA], [__, libInfoB]) => libInfoA.akanConfig.libs.includes(libInfoB.name) ? 1 : -1).map(([libName], index) => [libName, index])
+    );
+    return this.#sortedLibIndices;
+  }
+  static async fromExecutor(exec2, { refresh } = {}) {
+    const existingLibInfo = this.libInfos.get(exec2.name);
+    if (existingLibInfo && !refresh)
+      return existingLibInfo;
+    const scanResult = await super.getScanResult(exec2);
+    await Promise.all(
+      scanResult.libDeps.filter((libName) => !this.loadedLibs.has(libName)).map(async (libName) => {
+        this.loadedLibs.add(libName);
+        this.libInfos.set(libName, await _LibInfo.fromExecutor(exec2));
+      })
+    );
+    const libInfo = new _LibInfo(exec2, scanResult);
+    this.libInfos.set(exec2.name, libInfo);
+    this.#sortedLibIndices = null;
+    return libInfo;
+  }
+  constructor(exec2, scanResult) {
+    super(scanResult);
+    this.exec = exec2;
+    this.akanConfig = scanResult.akanConfig;
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+  #sortedLibs = null;
+  #getSortedLibs() {
+    if (this.#sortedLibs)
+      return this.#sortedLibs;
+    const libs = _LibInfo.getSortedLibIndices();
+    this.#sortedLibs = this.akanConfig.libs.sort((libNameA, libNameB) => {
+      const indexA = libs.get(libNameA);
+      const indexB = libs.get(libNameB);
+      if (indexA === void 0 || indexB === void 0)
+        throw new Error(`LibInfo not found: ${libNameA} or ${libNameB}`);
+      return indexA - indexB;
     });
-    return ruleCounts;
+    return this.#sortedLibs;
+  }
+  getLibs() {
+    return this.#getSortedLibs();
+  }
+  getLibInfo(libName) {
+    if (!this.getScanResult().akanConfig.libs.includes(libName))
+      return void 0;
+    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];
+      })
+    );
+  }
+};
+var PkgInfo = class _PkgInfo {
+  exec;
+  name;
+  scanResult;
+  static async getScanResult(exec2) {
+    const tsconfig = exec2.getTsConfig();
+    const rootPackageJson = exec2.workspace.getPackageJson();
+    const scanner = new TypeScriptDependencyScanner(exec2.cwdPath, { tsconfig, rootPackageJson });
+    const npmSet = new Set(Object.keys({ ...rootPackageJson.dependencies, ...rootPackageJson.devDependencies }));
+    const pkgPathSet = new Set(
+      Object.keys(tsconfig.compilerOptions.paths ?? {}).filter((path10) => tsconfig.compilerOptions.paths?.[path10]?.some((resolve) => resolve.startsWith("pkgs/"))).map((path10) => path10.replace("/*", ""))
+    );
+    const [npmDepSet, pkgPathDepSet] = await scanner.getImportSets([npmSet, pkgPathSet]);
+    const pkgDeps = [...pkgPathDepSet].map((path10) => {
+      const pathSplitLength = path10.split("/").length;
+      return (tsconfig.compilerOptions.paths?.[path10]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
+    }).filter((pkg) => pkg !== this.name);
+    const pkgScanResult = {
+      name: this.name,
+      pkgDeps,
+      dependencies: [...npmDepSet]
+    };
+    return pkgScanResult;
+  }
+  static #pkgInfos = /* @__PURE__ */ new Map();
+  static async fromExecutor(exec2, options = {}) {
+    const existingPkgInfo = this.#pkgInfos.get(exec2.name);
+    if (existingPkgInfo && !options.refresh)
+      return existingPkgInfo;
+    const scanResult = await this.getScanResult(exec2);
+    const pkgInfo = new _PkgInfo(exec2, scanResult);
+    this.#pkgInfos.set(exec2.name, pkgInfo);
+    return pkgInfo;
+  }
+  constructor(exec2, scanResult) {
+    this.exec = exec2;
+    this.name = exec2.name;
+    this.scanResult = scanResult;
+  }
+  getScanResult() {
+    return this.scanResult;
+  }
+};
+var WorkspaceInfo = class _WorkspaceInfo {
+  constructor(appInfos = /* @__PURE__ */ new Map(), libInfos = /* @__PURE__ */ new Map(), pkgInfos = /* @__PURE__ */ new Map()) {
+    this.appInfos = appInfos;
+    this.libInfos = libInfos;
+    this.pkgInfos = pkgInfos;
+  }
+  static #workspaceInfos = /* @__PURE__ */ new Map();
+  static async fromExecutor(exec2, options = {}) {
+    const existingWorkspaceInfo = this.#workspaceInfos.get(exec2.name);
+    if (existingWorkspaceInfo && !options.refresh)
+      return existingWorkspaceInfo;
+    const [appNames, libNames, pkgNames] = await Promise.all([exec2.getApps(), exec2.getLibs(), exec2.getPkgs()]);
+    const [appInfos, libInfos, pkgInfos] = await Promise.all([
+      Promise.all(
+        appNames.map(async (appName) => {
+          const app = AppExecutor.from(exec2, appName);
+          return await app.scan();
+        })
+      ),
+      Promise.all(
+        libNames.map(async (libName) => {
+          const lib = LibExecutor.from(exec2, libName);
+          return await lib.scan();
+        })
+      ),
+      Promise.all(
+        pkgNames.map(async (pkgName) => {
+          return await PkgExecutor.from(exec2, pkgName).scan();
+        })
+      )
+    ]);
+    const workspaceInfo = new _WorkspaceInfo(
+      new Map(appInfos.map((app) => [app.exec.name, app])),
+      new Map(libInfos.map((lib) => [lib.exec.name, lib])),
+      new Map(pkgInfos.map((pkg) => [pkg.exec.name, pkg]))
+    );
+    this.#workspaceInfos.set(exec2.name, workspaceInfo);
+    return workspaceInfo;
   }
 };
 
 // pkgs/@akanjs/devkit/src/typeChecker.ts
 var import_chalk2 = __toESM(require("chalk"));
 var fs7 = __toESM(require("fs"));
-var path5 = __toESM(require("path"));
+var path6 = __toESM(require("path"));
 var ts3 = __toESM(require("typescript"));
 var TypeChecker = class {
   configPath;
@@ -1280,7 +1709,7 @@ var TypeChecker = class {
     const parsedConfig = ts3.parseJsonConfigFileContent(
       this.configFile.config,
       ts3.sys,
-      path5.dirname(this.configPath),
+      path6.dirname(this.configPath),
       void 0,
       this.configPath
     );
@@ -1547,7 +1976,7 @@ var Executor = class _Executor {
     });
   }
   getPath(filePath) {
-    if (import_path3.default.isAbsolute(filePath))
+    if (import_path4.default.isAbsolute(filePath))
       return filePath;
     const baseParts = this.cwdPath.split("/").filter(Boolean);
     const targetParts = filePath.split("/").filter(Boolean);
@@ -1580,6 +2009,22 @@ var Executor = 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_path4.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_fs4.default.existsSync(readPath);
@@ -1600,7 +2045,7 @@ var Executor = class _Executor {
   }
   writeFile(filePath, content, { overwrite = true } = {}) {
     const writePath = this.getPath(filePath);
-    const dir = import_path3.default.dirname(writePath);
+    const dir = import_path4.default.dirname(writePath);
     if (!import_fs4.default.existsSync(dir))
       import_fs4.default.mkdirSync(dir, { recursive: true });
     let contentStr = typeof content === "string" ? content : JSON.stringify(content, null, 2);
@@ -1611,11 +2056,12 @@ var Executor = class _Executor {
         contentStr = import_fs4.default.readFileSync(writePath, "utf-8");
       } else {
         import_fs4.default.writeFileSync(writePath, contentStr, "utf8");
-        this.logger.verbose(`File ${writePath} is changed`);
+        if (Logger.isVerbose())
+          this.logger.rawLog(import_chalk3.default.yellow(`File Update: ${filePath}`));
       }
     } else {
       import_fs4.default.writeFileSync(writePath, contentStr, "utf8");
-      this.logger.verbose(`File ${writePath} is created`);
+      this.logger.rawLog(import_chalk3.default.green(`File Create: ${filePath}`));
     }
     return { filePath: writePath, content: contentStr };
   }
@@ -1624,7 +2070,7 @@ var Executor = class _Executor {
     return this;
   }
   getLocalFile(targetPath) {
-    const filePath = import_path3.default.isAbsolute(targetPath) ? targetPath : targetPath.replace(this.cwdPath, "");
+    const filePath = import_path4.default.isAbsolute(targetPath) ? targetPath : targetPath.replace(this.cwdPath, "");
     const content = this.readFile(filePath);
     return { filePath, content };
   }
@@ -1652,7 +2098,10 @@ var Executor = 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);
@@ -1662,24 +2111,41 @@ var Executor = 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_path3.default.basename(targetPath).replace(".js", ".ts");
+      const filename = typeof result === "object" ? result.filename : import_path4.default.basename(targetPath).replace(".js", ".ts");
       const content = typeof result === "object" ? result.content : result;
-      const dirname3 = import_path3.default.dirname(targetPath);
+      const dirname3 = import_path4.default.dirname(targetPath);
       const convertedTargetPath = Object.entries(dict).reduce(
-        (path9, [key, value]) => path9.replace(new RegExp(`__${key}__`, "g"), value),
+        (path10, [key, value]) => path10.replace(new RegExp(`__${key}__`, "g"), value),
         `${dirname3}/${filename}`
       );
       this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
@@ -1687,7 +2153,7 @@ var Executor = class _Executor {
     } else if (targetPath.endsWith(".template")) {
       const content = await import_promises.default.readFile(templatePath, "utf8");
       const convertedTargetPath = Object.entries(dict).reduce(
-        (path9, [key, value]) => path9.replace(new RegExp(`__${key}__`, "g"), value),
+        (path10, [key, value]) => path10.replace(new RegExp(`__${key}__`, "g"), value),
         targetPath.slice(0, -9)
       );
       const convertedContent = Object.entries(dict).reduce(
@@ -1702,16 +2168,16 @@ var Executor = class _Executor {
   async _applyTemplate({
     basePath: basePath2,
     template,
-    scanResult,
+    scanInfo,
     dict = {},
     overwrite = true
   }) {
     const templatePath = `${getDirname(import_meta2.url)}/src/templates${template ? `/${template}` : ""}`;
     const prefixTemplatePath = templatePath.endsWith(".tsx") ? templatePath : templatePath.replace(".ts", ".js");
     if (import_fs4.default.statSync(prefixTemplatePath).isFile()) {
-      const filename = import_path3.default.basename(prefixTemplatePath);
+      const filename = import_path4.default.basename(prefixTemplatePath);
       const fileContent = await this.#applyTemplateFile(
-        { templatePath: prefixTemplatePath, targetPath: import_path3.default.join(basePath2, filename), scanResult, overwrite },
+        { templatePath: prefixTemplatePath, targetPath: import_path4.default.join(basePath2, filename), scanInfo, overwrite },
         dict
       );
       return fileContent ? [fileContent] : [];
@@ -1719,18 +2185,18 @@ var Executor = class _Executor {
       const subdirs = await this.readdir(templatePath);
       const fileContents = (await Promise.all(
         subdirs.map(async (subdir) => {
-          const subpath = import_path3.default.join(templatePath, subdir);
+          const subpath = import_path4.default.join(templatePath, subdir);
           if (import_fs4.default.statSync(subpath).isFile()) {
             const fileContent = await this.#applyTemplateFile(
-              { templatePath: subpath, targetPath: import_path3.default.join(basePath2, subdir), scanResult, overwrite },
+              { templatePath: subpath, targetPath: import_path4.default.join(basePath2, subdir), scanInfo, overwrite },
               dict
             );
             return fileContent ? [fileContent] : [];
           } else
             return await this._applyTemplate({
-              basePath: import_path3.default.join(basePath2, subdir),
-              template: import_path3.default.join(template, subdir),
-              scanResult,
+              basePath: import_path4.default.join(basePath2, subdir),
+              template: import_path4.default.join(template, subdir),
+              scanInfo,
               dict,
               overwrite
             });
@@ -1753,9 +2219,9 @@ var Executor = class _Executor {
     return this.typeChecker;
   }
   typeCheck(filePath) {
-    const path9 = this.getPath(filePath);
+    const path10 = this.getPath(filePath);
     const typeChecker = this.getTypeChecker();
-    const { fileDiagnostics, fileErrors, fileWarnings } = typeChecker.check(path9);
+    const { fileDiagnostics, fileErrors, fileWarnings } = typeChecker.check(path10);
     const message = typeChecker.formatDiagnostics(fileDiagnostics);
     return { fileDiagnostics, fileErrors, fileWarnings, message };
   }
@@ -1764,9 +2230,9 @@ var Executor = class _Executor {
     return this.linter;
   }
   async lint(filePath, { fix = false, dryRun = false } = {}) {
-    const path9 = this.getPath(filePath);
+    const path10 = this.getPath(filePath);
     const linter = this.getLinter();
-    const { results, errors, warnings } = await linter.lint(path9, { fix, dryRun });
+    const { results, errors, warnings } = await linter.lint(path10, { fix, dryRun });
     const message = linter.formatLintResults(results);
     return { results, message, errors, warnings };
   }
@@ -1780,9 +2246,12 @@ var WorkspaceExecutor = class _WorkspaceExecutor extends Executor {
     this.workspaceRoot = workspaceRoot;
     this.repoName = repoName;
   }
-  static fromRoot() {
-    const repoName = import_path3.default.basename(process.cwd());
-    return new _WorkspaceExecutor({ workspaceRoot: process.cwd(), repoName });
+  static #execs = /* @__PURE__ */ new Map();
+  static fromRoot({
+    workspaceRoot = process.cwd(),
+    repoName = import_path4.default.basename(process.cwd())
+  } = {}) {
+    return this.#execs.get(repoName) ?? new _WorkspaceExecutor({ workspaceRoot, repoName });
   }
   getBaseDevEnv() {
     const envFile = import_dotenv.default.parse(this.readFile(".env"));
@@ -1800,36 +2269,7 @@ var WorkspaceExecutor = 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 (!import_fs4.default.existsSync(`${this.workspaceRoot}/apps`))
@@ -1891,7 +2331,7 @@ var WorkspaceExecutor = class _WorkspaceExecutor extends Executor {
         dirs.map(async (dir) => {
           if (dir.includes("_") || AVOID_DIRS.includes(dir))
             return;
-          const dirPath = import_path3.default.join(dirname3, dir);
+          const dirPath = import_path4.default.join(dirname3, dir);
           if (import_fs4.default.lstatSync(dirPath).isDirectory()) {
             results.push(`${prefix}${dir}`);
             if (maxDepth > 0)
@@ -1918,9 +2358,9 @@ var WorkspaceExecutor = class _WorkspaceExecutor extends Executor {
         dirs.map(async (dir) => {
           if (AVOID_DIRS.includes(dir))
             return;
-          const dirPath = import_path3.default.join(dirname3, dir);
+          const dirPath = import_path4.default.join(dirname3, dir);
           if (import_fs4.default.lstatSync(dirPath).isDirectory()) {
-            const hasTargetFile = import_fs4.default.existsSync(import_path3.default.join(dirPath, targetFilename));
+            const hasTargetFile = import_fs4.default.existsSync(import_path4.default.join(dirPath, targetFilename));
             if (hasTargetFile)
               results.push(`${prefix}${dir}`);
             if (maxDepth > 0)
@@ -1977,163 +2417,106 @@ var SysExecutor = class 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 path9 = this.type === "app" ? `apps/${this.name}/lib` : `libs/${this.name}/lib`;
-    return await this.workspace.getDirInModule(path9, this.name);
+    const path10 = this.type === "app" ? `apps/${this.name}/lib` : `libs/${this.name}/lib`;
+    return await this.workspace.getDirInModule(path10, 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((path9) => tsconfig.compilerOptions.paths?.[path9]?.some((resolve) => resolve.startsWith("pkgs/"))).map((path9) => path9.replace("/*", ""))
-    );
-    const libPathSet = new Set(
-      Object.keys(tsconfig.compilerOptions.paths ?? {}).filter((path9) => tsconfig.compilerOptions.paths?.[path9]?.some((resolve) => resolve.startsWith("libs/"))).map((path9) => path9.replace("/*", ""))
-    );
-    const [npmDepSet, pkgPathDepSet, libPathDepSet] = await scanner.getImportSets([npmSet, pkgPathSet, libPathSet]);
-    const pkgDeps = [...pkgPathDepSet].map((path9) => {
-      const pathSplitLength = path9.split("/").length;
-      return (tsconfig.compilerOptions.paths?.[path9]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
-    });
-    const libDeps = [...libPathDepSet].map((path9) => {
-      const pathSplitLength = path9.split("/").length;
-      return (tsconfig.compilerOptions.paths?.[path9]?.[0] ?? "*").split("/").slice(1, 1 + pathSplitLength).join("/");
-    }).filter((libName) => libName !== this.name);
-    if (!import_fs4.default.existsSync(`${this.cwdPath}/lib/__scalar`))
-      import_fs4.default.mkdirSync(`${this.cwdPath}/lib/__scalar`, { recursive: true });
-    const files = getDefaultFileScan();
-    const dirnames = (await this.readdir("lib")).filter(
-      (name) => import_fs4.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_path3.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 (dirname3) => {
-        const name = dirname3.slice(1);
-        const filenames = await this.readdir(import_path3.default.join("lib", dirname3));
-        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_path3.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 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 = import_path3.default.isAbsolute(targetPath) ? targetPath : `${this.type}s/${this.name}/${targetPath}`;
+    const filePath = import_path4.default.isAbsolute(targetPath) ? targetPath : `${this.type}s/${this.name}/${targetPath}`;
     const content = this.workspace.readFile(filePath);
     return { filePath, content };
   }
@@ -2213,9 +2596,9 @@ var SysExecutor = class 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() {
@@ -2230,21 +2613,29 @@ var AppExecutor = 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`;
@@ -2281,18 +2672,26 @@ var LibExecutor = 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 });
+    else
+      return new _LibExecutor({ workspace: executor.workspace, name });
   }
-  async getConfig(command) {
-    return await getLibConfig(this.cwdPath, {
+  #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;
   }
 };
 var PkgExecutor = class _PkgExecutor extends Executor {
@@ -2311,27 +2710,13 @@ var PkgExecutor = 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((path9) => tsconfig.compilerOptions.paths?.[path9]?.some((resolve) => resolve.startsWith("pkgs/"))).map((path9) => path9.replace("/*", ""))
-    );
-    const [npmDepSet, pkgPathDepSet] = await scanner.getImportSets([npmSet, pkgPathSet]);
-    const pkgDeps = [...pkgPathDepSet].map((path9) => {
-      const pathSplitLength = path9.split("/").length;
-      return (tsconfig.compilerOptions.paths?.[path9]?.[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;
   }
 };
 var ModuleExecutor = class _ModuleExecutor extends Executor {
@@ -2635,7 +3020,7 @@ var extractDependencies = (filepaths, pacakgeJson, defaultDependencies = []) =>
     ...pacakgeJson.devDependencies ?? {}
   };
   const requireRegex = /(?:require\s*\(|import\s*(?:[\w\s{},*]*\s+from\s*)?|import\s*\()\s*['"`]([^'"`]+)['"`]/g;
-  for (const { text } of filepaths.filter(({ path: path9 }) => path9.endsWith(".js") || path9.endsWith(".ts"))) {
+  for (const { text } of filepaths.filter(({ path: path10 }) => path10.endsWith(".js") || path10.endsWith(".ts"))) {
     let requireMatch;
     while ((requireMatch = requireRegex.exec(text)) !== null) {
       const moduleName = requireMatch[1];
@@ -2918,8 +3303,18 @@ var runCommands = async (...commands) => {
   });
   const __dirname = getDirname(import_meta3.url);
   const hasPackageJson = import_fs7.default.existsSync(`${__dirname}/../package.json`);
-  const version = hasPackageJson ? JSON.parse(import_fs7.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_fs7.default.readFileSync(`${__dirname}/../package.json`, "utf8")).version : "0.0.1";
+  import_commander.program.version(process.env.AKAN_VERSION).description("Akan CLI");
+  const akanBasePackageJson = import_fs7.default.existsSync("./node_modules/@akanjs/base/package.json") ? JSON.parse(import_fs7.default.readFileSync("./node_modules/@akanjs/base/package.json", "utf8")) : null;
+  if (akanBasePackageJson && akanBasePackageJson.version !== process.env.AKAN_VERSION) {
+    Logger.rawLog(
+      import_chalk4.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 = getTargetMetas(command);
     for (const targetMeta of targetMetas) {
@@ -2982,7 +3377,8 @@ var runCommands = async (...commands) => {
             Logger.rawLog();
           } catch (e) {
             const errMsg = e instanceof Error ? e.message : typeof e === "string" ? e : JSON.stringify(e);
-            Logger.error(`Command Error: ${import_chalk4.default.red(errMsg)}`);
+            Logger.rawLog(`
+${import_chalk4.default.red(errMsg)}`);
             throw e;
           }
         });
@@ -3337,8 +3733,8 @@ var Builder = class {
       }
     };
     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);
   }
 };
 
@@ -3433,8 +3829,8 @@ var LibraryRunner = class {
     return LibExecutor.from(workspace, libName);
   }
   async mergeLibraryDependencies(lib) {
-    const libPackageJson = lib.readJson("package.json");
-    const rootPackageJson = lib.workspace.readJson("package.json");
+    const libPackageJson = lib.getPackageJson();
+    const rootPackageJson = lib.workspace.getPackageJson();
     const dependencies = {};
     const devDependencies = {};
     const libDependencies = { ...libPackageJson.dependencies, ...libPackageJson.devDependencies };
@@ -3454,7 +3850,7 @@ var LibraryRunner = class {
         devDependencies[dep] = allDependencies[dep];
     });
     const newRootPackageJson = { ...rootPackageJson, dependencies, devDependencies };
-    lib.workspace.writeJson("package.json", newRootPackageJson);
+    lib.workspace.setPackageJson(newRootPackageJson);
     await lib.workspace.spawn("pnpm", ["install", "--reporter=silent"]);
     await lib.workspace.commit(`Merge ${lib.name} library dependencies`);
   }
@@ -3500,10 +3896,9 @@ var LibraryScript = class {
   #runner = new LibraryRunner();
   async syncLibrary(lib) {
     const syncSpinner = lib.spinning("Syncing library...");
-    const akanConfig = await lib.getConfig();
-    const scanResult = await lib.scan({ akanConfig });
+    const scanInfo = await lib.scan();
     syncSpinner.succeed(`Library ${lib.name} (libs/${lib.name}) is synced`);
-    return scanResult;
+    return scanInfo;
   }
   async createLibrary(libName, workspace) {
     const spinner = workspace.spinning(`Creating ${libName} library`);
@@ -3856,7 +4251,7 @@ var import_promises3 = __toESM(require("fs/promises"), 1);
 var import_js_yaml2 = __toESM(require("js-yaml"), 1);
 var import_open = __toESM(require("open"), 1);
 var import_ora3 = __toESM(require("ora"), 1);
-var import_path4 = __toESM(require("path"), 1);
+var import_path5 = __toESM(require("path"), 1);
 var vite = __toESM(require("vite"), 1);
 var import_vite_plugin_commonjs = __toESM(require("vite-plugin-commonjs"), 1);
 var import_vite_plugin_node_polyfills = require("vite-plugin-node-polyfills");
@@ -3876,17 +4271,12 @@ var ApplicationRunner = class {
     app.workspace.unsetTsPaths("app", app.name);
   }
   async getConfig(app) {
-    return await getAppConfig(app.cwdPath, {
-      ...app.workspace.getBaseDevEnv(),
-      type: "app",
-      name: app.name,
-      command: "start"
-    });
+    return await app.getConfig();
   }
-  async scanSync(app, akanConfig) {
-    const scanResult = await app.scan({ akanConfig });
-    await app.syncAssets(scanResult.akanConfig.libs);
-    return scanResult;
+  async scanSync(app) {
+    const scanInfo = await app.scan();
+    await app.syncAssets(scanInfo.getScanResult().libDeps);
+    return scanInfo;
   }
   async getScriptFilename(app) {
     if (!app.exists("scripts")) {
@@ -3942,12 +4332,12 @@ var ApplicationRunner = class {
     } else if (target === "csr")
       await app.workspace.exec(`rm -rf ${app.workspace.workspaceRoot}/node_modules/.vite/${app.name}`);
     else if (target === "backend")
-      await app.cp("assets", import_path4.default.join(app.dist.cwdPath, "backend", "assets"));
+      await app.cp("assets", import_path5.default.join(app.dist.cwdPath, "backend", "assets"));
     return { env: this.#getEnv(app, target, { AKAN_COMMAND_TYPE: type }) };
   }
   async buildBackend(app) {
     await this.#prepareCommand(app, "start", "backend");
-    const akanConfig = await app.getConfig("build");
+    const akanConfig = await app.getConfig();
     const buildResult = await esbuild2.build({
       write: false,
       entryPoints: [`${app.cwdPath}/main.ts`],
@@ -3958,7 +4348,7 @@ var ApplicationRunner = class {
       outdir: `${app.dist.cwdPath}/backend`,
       logLevel: "warning"
     });
-    const rootPackageJson = app.workspace.readJson("package.json");
+    const rootPackageJson = app.workspace.getPackageJson();
     const dependencies = extractDependencies(buildResult.outputFiles, rootPackageJson);
     buildResult.outputFiles.map((file) => app.dist.writeFile(file.path, file.text));
     const appPackageJson = {
@@ -3971,7 +4361,7 @@ var ApplicationRunner = class {
       dependencies
     };
     app.dist.writeJson("backend/package.json", appPackageJson);
-    app.dist.writeFile(import_path4.default.join(app.dist.cwdPath, "backend", "Dockerfile"), akanConfig.backend.docker.content);
+    app.dist.writeFile(import_path5.default.join(app.dist.cwdPath, "backend", "Dockerfile"), akanConfig.backend.docker.content);
   }
   async startBackend(app, { open: open2 = false, onStart, withInk = false } = {}) {
     const { env } = await this.#prepareCommand(app, "start", "backend");
@@ -3982,7 +4372,7 @@ var ApplicationRunner = class {
       packages: "external",
       platform: "node",
       format: "cjs",
-      outdir: import_path4.default.join(app.dist.cwdPath, "backend"),
+      outdir: import_path5.default.join(app.dist.cwdPath, "backend"),
       logLevel: "warning"
     });
     await ctx.watch();
@@ -3998,7 +4388,7 @@ var ApplicationRunner = class {
   }
   async buildFrontend(app, { spawnOptions } = {}) {
     const { env } = await this.#prepareCommand(app, "build", "frontend");
-    const akanConfig = await app.getConfig("build");
+    const akanConfig = await app.getConfig();
     await app.spawn("npx", ["next", "build", "--no-lint"], { env, ...spawnOptions });
     const buildResult = await esbuild2.build({
       entryPoints: [`${app.cwdPath}/next.config.ts`],
@@ -4010,7 +4400,7 @@ var ApplicationRunner = class {
       write: false,
       logLevel: "warning"
     });
-    const rootPackageJson = app.workspace.readJson("package.json");
+    const rootPackageJson = app.workspace.getPackageJson();
     const dependencies = extractDependencies(buildResult.outputFiles, rootPackageJson, ["next", "react", "react-dom"]);
     buildResult.outputFiles.map((file) => app.dist.writeFile(file.path, file.text));
     const appPackageJson = {
@@ -4023,8 +4413,8 @@ var ApplicationRunner = class {
     };
     app.dist.writeJson("frontend/package.json", appPackageJson);
     await Promise.all([
-      app.cp(".next", import_path4.default.join(app.dist.cwdPath, "frontend", ".next")),
-      app.cp("public", import_path4.default.join(app.dist.cwdPath, "frontend", "public"))
+      app.cp(".next", import_path5.default.join(app.dist.cwdPath, "frontend", ".next")),
+      app.cp("public", import_path5.default.join(app.dist.cwdPath, "frontend", "public"))
     ]);
     app.dist.writeFile("frontend/Dockerfile", akanConfig.frontend.docker.content);
   }
@@ -4223,6 +4613,11 @@ var ApplicationRunner = class {
     ]);
   }
   async dbup(workspace) {
+    try {
+      await workspace.exec(`docker ps`);
+    } catch (e) {
+      throw new Error(`Docker daemon is not running. Please install docker or start docker daemon and try again.`);
+    }
     await workspace.applyTemplate({
       basePath: "local",
       template: "localDev",
@@ -4299,8 +4694,8 @@ var ApplicationRunner = class {
       )
     );
     await Promise.all(
-      [".next", "ios", "android", "public/libs"].map(async (path9) => {
-        const targetPath = `${sourceRoot}/apps/${app.name}/${path9}`;
+      [".next", "ios", "android", "public/libs"].map(async (path10) => {
+        const targetPath = `${sourceRoot}/apps/${app.name}/${path10}`;
         if (import_fs10.default.existsSync(targetPath))
           await import_promises3.default.rm(targetPath, { recursive: true, force: true });
       })
@@ -4318,7 +4713,7 @@ var ApplicationRunner = class {
     ];
     await Promise.all(
       syncPaths.map(
-        (path9) => import_promises3.default.cp(`${app.workspace.cwdPath}/${path9}`, `${sourceRoot}/${path9}`, { recursive: true })
+        (path10) => import_promises3.default.cp(`${app.workspace.cwdPath}/${path10}`, `${sourceRoot}/${path10}`, { recursive: true })
       )
     );
     const tsconfig = app.workspace.readJson("tsconfig.json");
@@ -4441,10 +4836,9 @@ var ApplicationScript = class {
   }
   async syncApplication(app) {
     const spinner = app.spinning("Scanning application...");
-    const akanConfig = await this.#runner.getConfig(app);
-    const scanResult = await this.#runner.scanSync(app, akanConfig);
+    const scanInfo = await this.#runner.scanSync(app);
     spinner.succeed("Application scanned");
-    return scanResult;
+    return scanInfo;
   }
   async script(app, filename) {
     const scriptFilename = filename ?? await this.#runner.getScriptFilename(app);
@@ -4888,8 +5282,8 @@ var PackageRunner = class {
     return scanResult;
   }
   async buildPackage(pkg) {
-    const rootPackageJson = pkg.workspace.readJson("package.json");
-    const pkgJson = pkg.readJson("package.json");
+    const rootPackageJson = pkg.workspace.getPackageJson();
+    const pkgJson = pkg.getPackageJson();
     const builder = new Builder({ executor: pkg, distExecutor: pkg.dist, pkgJson, rootPackageJson });
     if (pkg.name === "@akanjs/cli")
       await builder.build({
@@ -5063,7 +5457,7 @@ ${import_chalk6.default.green("\u27A4")} Authentication Required`));
   }
   async #updateAkanPkgs(workspace) {
     const latestPublishedVersionOfBase = await (0, import_latest_version.default)("@akanjs/base");
-    const rootPackageJson = workspace.readJson("package.json");
+    const rootPackageJson = workspace.getPackageJson();
     if (!rootPackageJson.dependencies)
       throw new Error("No dependencies found in package.json");
     Object.keys(rootPackageJson.dependencies).forEach((dependency) => {
@@ -5074,7 +5468,7 @@ ${import_chalk6.default.green("\u27A4")} Authentication Required`));
       if (dependency.startsWith("@akanjs/"))
         Object.assign(rootPackageJson.devDependencies ?? {}, { [dependency]: latestPublishedVersionOfBase });
     });
-    workspace.writeJson("package.json", rootPackageJson);
+    workspace.setPackageJson(rootPackageJson);
     await workspace.spawn("pnpm", ["install"]);
   }
 };
@@ -5630,8 +6024,7 @@ var ModuleScript = class {
     await this.#runner.createModuleTemplate(mod);
     if (page && sys3.type === "app")
       await this.pageScript.createCrudPage(mod, { app: sys3, basePath: null, single: false });
-    const akanConfig = await sys3.getConfig();
-    await sys3.scan({ akanConfig });
+    await sys3.scan();
   }
   async createModule(sys3, name, description, schemaDescription) {
     const session = new AiSession("createModule", { workspace: sys3.workspace, cacheKey: name });
@@ -5862,13 +6255,13 @@ PageCommand = __decorateClass([
 
 // pkgs/@akanjs/cli/src/workspace/workspace.runner.ts
 var import_latest_version2 = __toESM(require("latest-version"), 1);
-var import_path5 = __toESM(require("path"), 1);
+var import_path6 = __toESM(require("path"), 1);
 var import_uuid2 = require("uuid");
 var WorkspaceRunner = class {
   async createWorkspace(repoName, appName, dirname3 = ".") {
     const cwdPath = process.cwd();
-    const workspaceRoot = import_path5.default.join(cwdPath, dirname3, repoName);
-    const workspace = new WorkspaceExecutor({ workspaceRoot, repoName });
+    const workspaceRoot = import_path6.default.join(cwdPath, dirname3, repoName);
+    const workspace = WorkspaceExecutor.fromRoot({ workspaceRoot, repoName });
     const templateSpinner = workspace.spinning(`Creating workspace template files in ${dirname3}/${repoName}...`);
     await workspace.applyTemplate({
       basePath: ".",
@@ -5876,7 +6269,7 @@ var WorkspaceRunner = class {
       dict: { repoName, appName, serveDomain: "localhost" }
     });
     templateSpinner.succeed(`Workspace files created in ${dirname3}/${repoName}`);
-    const rootPackageJson = workspace.readJson("package.json");
+    const rootPackageJson = workspace.getPackageJson();
     const dependencies = [
       "@akanjs/base",
       "@akanjs/cli",
@@ -6066,15 +6459,15 @@ var GuidelinePrompt = class extends Prompter {
   async #getScanFilePaths(matchPattern, { avoidDirs = ["node_modules", ".next"], filterText } = {}) {
     const matchingPaths = import_promises5.default.glob(matchPattern, {
       cwd: this.workspace.workspaceRoot,
-      exclude: (path9) => avoidDirs.some((dir) => path9.includes(dir))
+      exclude: (path10) => avoidDirs.some((dir) => path10.includes(dir))
     });
     const paths = [];
-    for await (const path9 of matchingPaths) {
-      const fileContent = import_fs12.default.readFileSync(path9, "utf-8");
+    for await (const path10 of matchingPaths) {
+      const fileContent = import_fs12.default.readFileSync(path10, "utf-8");
       const textFilter = filterText ? new RegExp(filterText) : null;
       if (filterText && !textFilter?.test(fileContent))
         continue;
-      paths.push(path9);
+      paths.push(path10);
     }
     return paths;
   }