@akanjs/cli 0.9.41 → 0.9.43

package/esm/index.js

@@ -122,6 +122,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;
@@ -380,8 +383,8 @@ import * as fs3 from "fs";
 import ora2 from "ora";
 import * as ts from "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,
@@ -700,46 +703,11 @@ 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 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 ?? [],
@@ -885,18 +853,254 @@ import { exec, fork, spawn } from "child_process";
 import dotenv from "dotenv";
 import fs8 from "fs";
 import fsPromise from "fs/promises";
-import path6 from "path";
+import path7 from "path";
 
-// pkgs/@akanjs/devkit/src/dependencyScanner.ts
+// pkgs/@akanjs/devkit/src/getDirname.ts
+import path2 from "path";
+var getDirname = (url) => path2.dirname(new URL(url).pathname);
+
+// pkgs/@akanjs/devkit/src/linter.ts
+import chalk from "chalk";
+import { ESLint } from "eslint";
 import * as fs5 from "fs";
-import * as path2 from "path";
+import * as path3 from "path";
+var Linter = class {
+  #logger = new Logger("Linter");
+  #eslint;
+  lintRoot;
+  constructor(cwdPath) {
+    this.lintRoot = this.#findEslintRootPath(cwdPath);
+    this.#eslint = new 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(`
+${chalk.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 ? chalk.red : chalk.yellow;
+          const icon = message.severity === 2 ? "\u274C" : "\u26A0\uFE0F";
+          const ruleInfo = message.ruleId ? chalk.dim(` (${message.ruleId})`) : "";
+          output.push(`
+  ${icon} ${typeColor(type)}: ${message.message}${ruleInfo}`);
+          output.push(`     ${chalk.gray("at")} ${result.filePath}:${chalk.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(`
+${chalk.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(`${chalk.dim(" ".repeat(lineNumber.length) + " |")} ${underlinePrefix}${typeColor(underline)}`);
+          }
+        });
+      }
+    });
+    if (totalErrors === 0 && totalWarnings === 0)
+      return chalk.bold("\u2705 No ESLint errors or warnings found");
+    const errorText = totalErrors > 0 ? chalk.red(`${totalErrors} error(s)`) : "0 errors";
+    const warningText = totalWarnings > 0 ? chalk.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 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 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 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
+import path5 from "path";
+
+// pkgs/@akanjs/devkit/src/dependencyScanner.ts
+import * as fs6 from "fs";
+import * as path4 from "path";
 import * as ts2 from "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);
@@ -933,9 +1137,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);
@@ -951,26 +1155,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`;
   }
@@ -1034,217 +1238,442 @@ var TypeScriptDependencyScanner = class {
   }
 };
 
-// pkgs/@akanjs/devkit/src/getDirname.ts
-import path3 from "path";
-var getDirname = (url) => path3.dirname(new URL(url).pathname);
-
-// pkgs/@akanjs/devkit/src/linter.ts
-import chalk from "chalk";
-import { ESLint } from "eslint";
-import * as fs6 from "fs";
-import * as path4 from "path";
-var Linter = class {
-  #logger = new Logger("Linter");
-  #eslint;
-  lintRoot;
-  constructor(cwdPath) {
-    this.lintRoot = this.#findEslintRootPath(cwdPath);
-    this.#eslint = new 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(`
-${chalk.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 ? chalk.red : chalk.yellow;
-          const icon = message.severity === 2 ? "\u274C" : "\u26A0\uFE0F";
-          const ruleInfo = message.ruleId ? chalk.dim(` (${message.ruleId})`) : "";
-          output.push(`
-  ${icon} ${typeColor(type)}: ${message.message}${ruleInfo}`);
-          output.push(`     ${chalk.gray("at")} ${result.filePath}:${chalk.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(`
-${chalk.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(`${chalk.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 chalk.bold("\u2705 No ESLint errors or warnings found");
-    const errorText = totalErrors > 0 ? chalk.red(`${totalErrors} error(s)`) : "0 errors";
-    const warningText = totalWarnings > 0 ? chalk.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(path5.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(path5.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(path5.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 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 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 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
 import chalk2 from "chalk";
 import * as fs7 from "fs";
-import * as path5 from "path";
+import * as path6 from "path";
 import * as ts3 from "typescript";
 var TypeChecker = class {
   configPath;
@@ -1259,7 +1688,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
     );
@@ -1525,7 +1954,7 @@ var Executor = class _Executor {
     });
   }
   getPath(filePath) {
-    if (path6.isAbsolute(filePath))
+    if (path7.isAbsolute(filePath))
       return filePath;
     const baseParts = this.cwdPath.split("/").filter(Boolean);
     const targetParts = filePath.split("/").filter(Boolean);
@@ -1558,6 +1987,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 fsPromise.stat(path7.join(fullDirPath, p));
+        if (stats.isDirectory())
+          dirs.push(p);
+        else
+          files.push(p);
+      })
+    );
+    return { files, dirs };
+  }
   exists(filePath) {
     const readPath = this.getPath(filePath);
     return fs8.existsSync(readPath);
@@ -1578,7 +2023,7 @@ var Executor = class _Executor {
   }
   writeFile(filePath, content, { overwrite = true } = {}) {
     const writePath = this.getPath(filePath);
-    const dir = path6.dirname(writePath);
+    const dir = path7.dirname(writePath);
     if (!fs8.existsSync(dir))
       fs8.mkdirSync(dir, { recursive: true });
     let contentStr = typeof content === "string" ? content : JSON.stringify(content, null, 2);
@@ -1589,11 +2034,12 @@ var Executor = class _Executor {
         contentStr = fs8.readFileSync(writePath, "utf-8");
       } else {
         fs8.writeFileSync(writePath, contentStr, "utf8");
-        this.logger.verbose(`File ${writePath} is changed`);
+        if (Logger.isVerbose())
+          this.logger.rawLog(chalk3.yellow(`File Update: ${filePath}`));
       }
     } else {
       fs8.writeFileSync(writePath, contentStr, "utf8");
-      this.logger.verbose(`File ${writePath} is created`);
+      this.logger.rawLog(chalk3.green(`File Create: ${filePath}`));
     }
     return { filePath: writePath, content: contentStr };
   }
@@ -1602,7 +2048,7 @@ var Executor = class _Executor {
     return this;
   }
   getLocalFile(targetPath) {
-    const filePath = path6.isAbsolute(targetPath) ? targetPath : targetPath.replace(this.cwdPath, "");
+    const filePath = path7.isAbsolute(targetPath) ? targetPath : targetPath.replace(this.cwdPath, "");
     const content = this.readFile(filePath);
     return { filePath, content };
   }
@@ -1630,7 +2076,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);
@@ -1640,24 +2089,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 : path6.basename(targetPath).replace(".js", ".ts");
+      const filename = typeof result === "object" ? result.filename : path7.basename(targetPath).replace(".js", ".ts");
       const content = typeof result === "object" ? result.content : result;
-      const dirname3 = path6.dirname(targetPath);
+      const dirname3 = path7.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}`);
@@ -1665,7 +2131,7 @@ var Executor = class _Executor {
     } else if (targetPath.endsWith(".template")) {
       const content = await fsPromise.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(
@@ -1680,16 +2146,16 @@ var Executor = class _Executor {
   async _applyTemplate({
     basePath: basePath2,
     template,
-    scanResult,
+    scanInfo,
     dict = {},
     overwrite = true
   }) {
     const templatePath = `${getDirname(import.meta.url)}/src/templates${template ? `/${template}` : ""}`;
     const prefixTemplatePath = templatePath.endsWith(".tsx") ? templatePath : templatePath.replace(".ts", ".js");
     if (fs8.statSync(prefixTemplatePath).isFile()) {
-      const filename = path6.basename(prefixTemplatePath);
+      const filename = path7.basename(prefixTemplatePath);
       const fileContent = await this.#applyTemplateFile(
-        { templatePath: prefixTemplatePath, targetPath: path6.join(basePath2, filename), scanResult, overwrite },
+        { templatePath: prefixTemplatePath, targetPath: path7.join(basePath2, filename), scanInfo, overwrite },
         dict
       );
       return fileContent ? [fileContent] : [];
@@ -1697,18 +2163,18 @@ var Executor = class _Executor {
       const subdirs = await this.readdir(templatePath);
       const fileContents = (await Promise.all(
         subdirs.map(async (subdir) => {
-          const subpath = path6.join(templatePath, subdir);
+          const subpath = path7.join(templatePath, subdir);
           if (fs8.statSync(subpath).isFile()) {
             const fileContent = await this.#applyTemplateFile(
-              { templatePath: subpath, targetPath: path6.join(basePath2, subdir), scanResult, overwrite },
+              { templatePath: subpath, targetPath: path7.join(basePath2, subdir), scanInfo, overwrite },
               dict
             );
             return fileContent ? [fileContent] : [];
           } else
             return await this._applyTemplate({
-              basePath: path6.join(basePath2, subdir),
-              template: path6.join(template, subdir),
-              scanResult,
+              basePath: path7.join(basePath2, subdir),
+              template: path7.join(template, subdir),
+              scanInfo,
               dict,
               overwrite
             });
@@ -1731,9 +2197,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 };
   }
@@ -1742,9 +2208,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 };
   }
@@ -1758,9 +2224,12 @@ var WorkspaceExecutor = class _WorkspaceExecutor extends Executor {
     this.workspaceRoot = workspaceRoot;
     this.repoName = repoName;
   }
-  static fromRoot() {
-    const repoName = path6.basename(process.cwd());
-    return new _WorkspaceExecutor({ workspaceRoot: process.cwd(), repoName });
+  static #execs = /* @__PURE__ */ new Map();
+  static fromRoot({
+    workspaceRoot = process.cwd(),
+    repoName = path7.basename(process.cwd())
+  } = {}) {
+    return this.#execs.get(repoName) ?? new _WorkspaceExecutor({ workspaceRoot, repoName });
   }
   getBaseDevEnv() {
     const envFile = dotenv.parse(this.readFile(".env"));
@@ -1778,36 +2247,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 (!fs8.existsSync(`${this.workspaceRoot}/apps`))
@@ -1869,7 +2309,7 @@ var WorkspaceExecutor = class _WorkspaceExecutor extends Executor {
         dirs.map(async (dir) => {
           if (dir.includes("_") || AVOID_DIRS.includes(dir))
             return;
-          const dirPath = path6.join(dirname3, dir);
+          const dirPath = path7.join(dirname3, dir);
           if (fs8.lstatSync(dirPath).isDirectory()) {
             results.push(`${prefix}${dir}`);
             if (maxDepth > 0)
@@ -1896,9 +2336,9 @@ var WorkspaceExecutor = class _WorkspaceExecutor extends Executor {
         dirs.map(async (dir) => {
           if (AVOID_DIRS.includes(dir))
             return;
-          const dirPath = path6.join(dirname3, dir);
+          const dirPath = path7.join(dirname3, dir);
           if (fs8.lstatSync(dirPath).isDirectory()) {
-            const hasTargetFile = fs8.existsSync(path6.join(dirPath, targetFilename));
+            const hasTargetFile = fs8.existsSync(path7.join(dirPath, targetFilename));
             if (hasTargetFile)
               results.push(`${prefix}${dir}`);
             if (maxDepth > 0)
@@ -1955,163 +2395,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 (!fs8.existsSync(`${this.cwdPath}/lib/__scalar`))
-      fs8.mkdirSync(`${this.cwdPath}/lib/__scalar`, { recursive: true });
-    const files = getDefaultFileScan();
-    const dirnames = (await this.readdir("lib")).filter(
-      (name) => fs8.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(path6.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(path6.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(path6.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 = path6.isAbsolute(targetPath) ? targetPath : `${this.type}s/${this.name}/${targetPath}`;
+    const filePath = path7.isAbsolute(targetPath) ? targetPath : `${this.type}s/${this.name}/${targetPath}`;
     const content = this.workspace.readFile(filePath);
     return { filePath, content };
   }
@@ -2191,9 +2574,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() {
@@ -2208,21 +2591,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`;
@@ -2259,18 +2650,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 {
@@ -2289,27 +2688,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 {
@@ -2613,7 +2998,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];
@@ -2895,8 +3280,18 @@ var runCommands = async (...commands) => {
   });
   const __dirname = getDirname(import.meta.url);
   const hasPackageJson = fs11.existsSync(`${__dirname}/../package.json`);
-  const version = hasPackageJson ? JSON.parse(fs11.readFileSync(`${__dirname}/../package.json`, "utf8")).version : "0.0.1";
-  program.version(version).description("Akan CLI");
+  process.env.AKAN_VERSION = hasPackageJson ? JSON.parse(fs11.readFileSync(`${__dirname}/../package.json`, "utf8")).version : "0.0.1";
+  program.version(process.env.AKAN_VERSION).description("Akan CLI");
+  const akanBasePackageJson = fs11.existsSync("./node_modules/@akanjs/base/package.json") ? JSON.parse(fs11.readFileSync("./node_modules/@akanjs/base/package.json", "utf8")) : null;
+  if (akanBasePackageJson && akanBasePackageJson.version !== process.env.AKAN_VERSION) {
+    Logger.rawLog(
+      chalk4.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) {
@@ -2959,7 +3354,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: ${chalk4.red(errMsg)}`);
+            Logger.rawLog(`
+${chalk4.red(errMsg)}`);
             throw e;
           }
         });
@@ -3319,8 +3715,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);
   }
 };
 
@@ -3414,8 +3810,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 };
@@ -3435,7 +3831,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`);
   }
@@ -3481,10 +3877,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`);
@@ -3546,6 +3941,7 @@ var MultiScrollList = ({ logList, maxLength = 100 }) => {
   const [boxHeight, setBoxHeight] = useState2(
     height - HEADER_HEIGHT - OUTER_BORDER_HEIGHT - FOOTER_HEIGHT - BORDER_HEIGHT
   );
+  const [boxWidth, setBoxWidth] = useState2(width - 28);
   const getLimitedLogs = (logs) => {
     return logs.length > maxLength ? logs.slice(logs.length - maxLength) : logs;
   };
@@ -3597,6 +3993,15 @@ var MultiScrollList = ({ logList, maxLength = 100 }) => {
   useEffect2(() => {
     const getLogsToRender = (logs, index) => {
       const limitedLogs = getLimitedLogs(logs);
+      const logWidth = limitedLogs.reduce((acc, log) => acc + log.content.length, 0);
+      if (logWidth > boxWidth) {
+        return limitedLogs.map((log) => {
+          return {
+            type: log.type,
+            content: log.content.slice(0, boxWidth)
+          };
+        });
+      }
       if (scrollPos > 0 && tabIndex === index) {
         return limitedLogs.slice(limitedLogs.length - boxHeight - scrollPos, limitedLogs.length - scrollPos);
       } else if (limitedLogs.length > boxHeight) {
@@ -3637,9 +4042,9 @@ var MultiScrollList = ({ logList, maxLength = 100 }) => {
       height: "100%"
     },
     scrollPos > 0 ? /* @__PURE__ */ React.createElement(React.Fragment, null, focusLog.slice(0, focusLog.length - 1).map((log, index) => {
-      return /* @__PURE__ */ React.createElement(Text, { key: index }, log);
+      return /* @__PURE__ */ React.createElement(Text, { color: log.type === "error" ? "red" : "white", key: index }, log.content);
     }), /* @__PURE__ */ React.createElement(Text, { backgroundColor: "green" }, "Scrolling... +", scrollPos)) : focusLog.map((log, index) => {
-      return /* @__PURE__ */ React.createElement(Text, { key: index }, log);
+      return /* @__PURE__ */ React.createElement(Text, { color: log.type === "error" ? "red" : "white", key: index }, log.content);
     })
   ))), /* @__PURE__ */ React.createElement(Box, { width: "100%", height: FOOTER_HEIGHT }, /* @__PURE__ */ React.createElement(Text, { dimColor: true }, /* @__PURE__ */ React.createElement(Text, null, "You can use the following shortcuts:"), /* @__PURE__ */ React.createElement(Newline, null), "* ", /* @__PURE__ */ React.createElement(Text, { backgroundColor: "green" }, "tab"), " to switch tab.", /* @__PURE__ */ React.createElement(Newline, null), "* ", /* @__PURE__ */ React.createElement(Text, { backgroundColor: "green" }, "up"), " and ", /* @__PURE__ */ React.createElement(Text, { backgroundColor: "green" }, "down"), " to scroll.", " ", /* @__PURE__ */ React.createElement(Text, { backgroundColor: "green" }, "shift"), " to scroll faster. (x10)", /* @__PURE__ */ React.createElement(Newline, null), "* ", /* @__PURE__ */ React.createElement(Text, { backgroundColor: "green" }, "space"), " to scroll.", /* @__PURE__ */ React.createElement(Newline, null), "* ", /* @__PURE__ */ React.createElement(Text, { backgroundColor: "green" }, "escape"), " to stop scrolling.")));
 };
@@ -3762,17 +4167,17 @@ var Start = ({ appName, bcp, fcp, csr, maxLength = 100 }) => {
       logList: [
         {
           title: `${appName} frontend`,
-          logs: frontendLogs.map((log) => log.content),
+          logs: frontendLogs,
           color: "#ff493b"
         },
         {
           title: `${appName} backend`,
-          logs: backendLogs.map((log) => log.content),
+          logs: backendLogs,
           color: "#e535ab"
         },
         {
           title: `${appName} react`,
-          logs: csrLogs.map((log) => log.content),
+          logs: csrLogs,
           color: "#7cc5d9"
         }
       ],
@@ -3837,7 +4242,7 @@ import fsPromise3 from "fs/promises";
 import yaml2 from "js-yaml";
 import openBrowser from "open";
 import ora3 from "ora";
-import path7 from "path";
+import path8 from "path";
 import * as vite from "vite";
 import commonjs from "vite-plugin-commonjs";
 import { nodePolyfills } from "vite-plugin-node-polyfills";
@@ -3857,17 +4262,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")) {
@@ -3923,12 +4323,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", path7.join(app.dist.cwdPath, "backend", "assets"));
+      await app.cp("assets", path8.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`],
@@ -3939,7 +4339,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 = {
@@ -3952,7 +4352,7 @@ var ApplicationRunner = class {
       dependencies
     };
     app.dist.writeJson("backend/package.json", appPackageJson);
-    app.dist.writeFile(path7.join(app.dist.cwdPath, "backend", "Dockerfile"), akanConfig.backend.docker.content);
+    app.dist.writeFile(path8.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");
@@ -3963,7 +4363,7 @@ var ApplicationRunner = class {
       packages: "external",
       platform: "node",
       format: "cjs",
-      outdir: path7.join(app.dist.cwdPath, "backend"),
+      outdir: path8.join(app.dist.cwdPath, "backend"),
       logLevel: "warning"
     });
     await ctx.watch();
@@ -3979,7 +4379,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`],
@@ -3991,7 +4391,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 = {
@@ -4004,8 +4404,8 @@ var ApplicationRunner = class {
     };
     app.dist.writeJson("frontend/package.json", appPackageJson);
     await Promise.all([
-      app.cp(".next", path7.join(app.dist.cwdPath, "frontend", ".next")),
-      app.cp("public", path7.join(app.dist.cwdPath, "frontend", "public"))
+      app.cp(".next", path8.join(app.dist.cwdPath, "frontend", ".next")),
+      app.cp("public", path8.join(app.dist.cwdPath, "frontend", "public"))
     ]);
     app.dist.writeFile("frontend/Dockerfile", akanConfig.frontend.docker.content);
   }
@@ -4204,6 +4604,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",
@@ -4280,8 +4685,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 (fs14.existsSync(targetPath))
           await fsPromise3.rm(targetPath, { recursive: true, force: true });
       })
@@ -4299,7 +4704,7 @@ var ApplicationRunner = class {
     ];
     await Promise.all(
       syncPaths.map(
-        (path9) => fsPromise3.cp(`${app.workspace.cwdPath}/${path9}`, `${sourceRoot}/${path9}`, { recursive: true })
+        (path10) => fsPromise3.cp(`${app.workspace.cwdPath}/${path10}`, `${sourceRoot}/${path10}`, { recursive: true })
       )
     );
     const tsconfig = app.workspace.readJson("tsconfig.json");
@@ -4422,10 +4827,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);
@@ -4869,8 +5273,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({
@@ -5044,7 +5448,7 @@ ${chalk6.green("\u27A4")} Authentication Required`));
   }
   async #updateAkanPkgs(workspace) {
     const latestPublishedVersionOfBase = await latestVersion("@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) => {
@@ -5055,7 +5459,7 @@ ${chalk6.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"]);
   }
 };
@@ -5611,8 +6015,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 });
@@ -5843,13 +6246,13 @@ PageCommand = __decorateClass([
 
 // pkgs/@akanjs/cli/src/workspace/workspace.runner.ts
 import latestVersion2 from "latest-version";
-import path8 from "path";
+import path9 from "path";
 import { v5 as uuid } from "uuid";
 var WorkspaceRunner = class {
   async createWorkspace(repoName, appName, dirname3 = ".") {
     const cwdPath = process.cwd();
-    const workspaceRoot = path8.join(cwdPath, dirname3, repoName);
-    const workspace = new WorkspaceExecutor({ workspaceRoot, repoName });
+    const workspaceRoot = path9.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: ".",
@@ -5857,7 +6260,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",
@@ -5888,7 +6291,7 @@ var WorkspaceRunner = class {
         ...Object.fromEntries(devDependencies.map((dependency) => [dependency, latestPublishedVersionOfBase]))
       }
     };
-    workspace.writeFile("package.json", packageJson);
+    workspace.setPackageJson(packageJson);
     const installSpinner = workspace.spinning("Installing dependencies with pnpm...");
     await workspace.spawn("pnpm", ["install", "--reporter=silent"]);
     installSpinner.succeed("Dependencies installed with pnpm");
@@ -6046,15 +6449,15 @@ var GuidelinePrompt = class extends Prompter {
   async #getScanFilePaths(matchPattern, { avoidDirs = ["node_modules", ".next"], filterText } = {}) {
     const matchingPaths = fsPromise5.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 = fs16.readFileSync(path9, "utf-8");
+    for await (const path10 of matchingPaths) {
+      const fileContent = fs16.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;
   }