@akanjs/devkit 0.0.40 → 0.0.41

package/index.js

@@ -1,21 +1,1950 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var index_exports = {};
-module.exports = __toCommonJS(index_exports);
-__reExport(index_exports, require("./src"), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require("./src")
-});
+(() => {
+  var __create = Object.create;
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
+
+  // pkgs/@akanjs/devkit/src/baseDevEnv.ts
+  var appName = process.env.NEXT_PUBLIC_APP_NAME;
+  var repoName = process.env.NEXT_PUBLIC_REPO_NAME;
+  if (!repoName)
+    throw new Error("NEXT_PUBLIC_REPO_NAME is not set");
+  var serveDomain = process.env.NEXT_PUBLIC_SERVE_DOMAIN;
+  if (!serveDomain)
+    throw new Error("NEXT_PUBLIC_SERVE_DOMAIN is not set");
+  var env = process.env.NEXT_PUBLIC_ENV ?? "debug";
+  if (!env)
+    throw new Error("NEXT_PUBLIC_ENV is not set");
+  var baseDevEnv = { ...appName ? { appName } : {}, repoName, serveDomain, env };
+  var getSshTunnelOptions = (appName2, environment) => ({
+    host: `${appName2}-${environment}.${serveDomain}`,
+    port: process.env.SSU_TUNNEL_PORT ? parseInt(process.env.SSU_TUNNEL_PORT) : 32767,
+    username: process.env.SSU_TUNNEL_USERNAME ?? "root",
+    password: process.env.SSU_TUNNEL_PASSWORD ?? repoName
+  });
+
+  // pkgs/@akanjs/devkit/src/createTunnel.ts
+  var import_tunnel_ssh = __require("tunnel-ssh");
+  var createTunnel = async ({ appName: appName2, environment, port = 27017 }) => {
+    const tunnelOptions = { autoClose: true, reconnectOnError: true };
+    const sshOptions = getSshTunnelOptions(appName2, environment);
+    const serverOptions = { port };
+    const forwardOptions = {
+      srcAddr: "0.0.0.0",
+      srcPort: port,
+      dstAddr: `mongo-0.mongo-svc.${appName2}-${environment}`,
+      dstPort: 27017
+    };
+    const [server, client] = await (0, import_tunnel_ssh.createTunnel)(tunnelOptions, serverOptions, sshOptions, forwardOptions);
+    return `localhost:${port}`;
+  };
+
+  // pkgs/@akanjs/devkit/src/getCredentials.ts
+  var import_fs = __toESM(__require("fs"));
+  var import_js_yaml = __toESM(__require("js-yaml"));
+  var getCredentials = (app, environment) => {
+    const secret = import_js_yaml.default.load(
+      import_fs.default.readFileSync(`${app.workspace.workspaceRoot}/infra/app/values/${app.name}-secret.yaml`, "utf-8")
+    );
+    return secret[environment];
+  };
+
+  // pkgs/@akanjs/devkit/src/getDependencies.ts
+  var import_devkit = __require("@nx/devkit");
+  var addLibDepSet = (depName, { libDepSet, npmDepSet, dependencies }) => {
+    const deps = dependencies[depName];
+    if (!deps)
+      throw new Error(`No dependencies found for project or library ${depName}`);
+    for (const dep of deps) {
+      if (dep.target.startsWith("npm:"))
+        npmDepSet.add(dep.target);
+      else if (libDepSet.has(dep.target))
+        continue;
+      else {
+        libDepSet.add(dep.target);
+        addLibDepSet(dep.target, { libDepSet, npmDepSet, dependencies });
+      }
+    }
+  };
+  var getDependencies = async (projectName) => {
+    const graph = await (0, import_devkit.createProjectGraphAsync)();
+    const [libDepSet, npmDepSet] = [/* @__PURE__ */ new Set(), /* @__PURE__ */ new Set()];
+    const dependencies = graph.dependencies;
+    const projectDeps = dependencies[projectName];
+    if (!projectDeps)
+      throw new Error(`No dependencies found for project ${projectName}`);
+    addLibDepSet(projectName, { libDepSet, npmDepSet, dependencies });
+    return {
+      libDeps: [...libDepSet.values()],
+      npmDeps: [...npmDepSet.values()].map((depName) => depName.replace("npm:", ""))
+    };
+  };
+
+  // pkgs/@akanjs/devkit/src/uploadRelease.ts
+  var import_axios = __toESM(__require("axios"));
+  var import_form_data = __toESM(__require("form-data"));
+  var import_fs2 = __toESM(__require("fs"));
+  var uploadRelease = async (projectName, {
+    workspaceRoot,
+    environment,
+    buildNum,
+    platformVersion,
+    local
+  }) => {
+    const basePath2 = local ? "http://localhost:8080/backend" : "https://akasys.akamir.com/backend";
+    const buildPath = `${workspaceRoot}/releases/builds/${projectName}-release.tar.gz`;
+    const appBuildPath = `${workspaceRoot}/releases/builds/${projectName}-appBuild.zip`;
+    const sourcePath = `${workspaceRoot}/releases/sources/${projectName}-source.tar.gz`;
+    const formData = new import_form_data.default();
+    const build = import_fs2.default.readFileSync(buildPath);
+    const source = import_fs2.default.readFileSync(sourcePath);
+    const appBuild = import_fs2.default.readFileSync(appBuildPath);
+    const buildStat = import_fs2.default.statSync(buildPath);
+    const sourceStat = import_fs2.default.statSync(sourcePath);
+    const appBuildStat = import_fs2.default.statSync(appBuildPath);
+    formData.append("files", build, `${projectName}-release.tar.gz`);
+    formData.append("files", source, `${projectName}-source.tar.gz`);
+    formData.append("files", appBuild, `${projectName}-appBuild.zip`);
+    formData.append(
+      "metas",
+      JSON.stringify([
+        { lastModifiedAt: buildStat.mtime, size: buildStat.size },
+        { lastModifiedAt: sourceStat.mtime, size: sourceStat.size },
+        { lastModifiedAt: appBuildStat.mtime, size: appBuildStat.size }
+      ])
+    );
+    formData.append("type", "release");
+    try {
+      const [buildFile, sourceFile, appBuildFile] = (await import_axios.default.post(`${basePath2}/file/addFilesRestApi`, formData)).data;
+      const major = platformVersion ? parseInt(platformVersion.split(".")[0]) : 1;
+      const minor = platformVersion ? parseInt(platformVersion.split(".")[1]) : 0;
+      const patch = platformVersion ? parseInt(platformVersion.split(".")[2]) : 0;
+      const latestRelease = await import_axios.default.get(
+        `${basePath2}/release/findVersionRelease?appName=${projectName}&branch=${environment}&major=${major}&minor=${minor}`
+      );
+      const release = (await import_axios.default.post(
+        `${basePath2}/release/pushRelease/${projectName}/${environment}/${major}/${minor}/${sourceFile.id}/${buildFile.id}/${appBuildFile.id}`
+      )).data;
+      return release;
+    } catch (e) {
+      return null;
+    }
+  };
+
+  // pkgs/@akanjs/devkit/src/getModelFileData.ts
+  var import_fs3 = __toESM(__require("fs"));
+  var getModelFileData = (modulePath, modelName) => {
+    const moduleType = modulePath.startsWith("apps") ? "app" : "lib";
+    const moduleName = modulePath.split("/")[1];
+    const constantFilePath = `${modulePath}/lib/${modelName}/${modelName}.constant.ts`;
+    const unitFilePath = `${modulePath}/lib/${modelName}/${modelName}.Unit.tsx`;
+    const viewFilePath = `${modulePath}/lib/${modelName}/${modelName}.View.tsx`;
+    const constantFileStr = import_fs3.default.readFileSync(constantFilePath, "utf8");
+    const unitFileStr = import_fs3.default.readFileSync(unitFilePath, "utf8");
+    const viewFileStr = import_fs3.default.readFileSync(viewFilePath, "utf8");
+    const constantFileLines = constantFileStr.split("\n");
+    const importLibNames = constantFileLines.filter((line) => line.startsWith("import { cnst as ")).map((line) => line.split("cnst as ")[1].split(" ")[0]);
+    const importLocalPaths = constantFileLines.filter((line) => line.startsWith("import { ") && line.includes('from "../')).map((line) => line.split("from ")[1].split('"')[1]);
+    const importModelNames = importLocalPaths.map((path5) => path5.split("/")[1]).filter((name) => !name.startsWith("_"));
+    const hasImportScalar = !!importLocalPaths.map((path5) => path5.split("/")[1]).filter((name) => name.startsWith("_")).length;
+    return {
+      moduleType,
+      moduleName,
+      modelName,
+      constantFilePath,
+      unitFilePath,
+      viewFilePath,
+      importModelNames,
+      hasImportScalar,
+      importLibNames,
+      constantFileStr,
+      unitFileStr,
+      viewFileStr
+    };
+  };
+
+  // pkgs/@akanjs/devkit/src/getRelatedCnsts.ts
+  var import_fs4 = __toESM(__require("fs"));
+  var import_ora = __toESM(__require("ora"));
+  var ts = __toESM(__require("typescript"));
+  var getRelatedCnsts = (constantFilePath) => {
+    const tsConfigPath = `./tsconfig.json`;
+    const configFile = ts.readConfigFile(tsConfigPath, (path5) => {
+      return ts.sys.readFile(path5);
+    });
+    const parsedConfig = ts.parseJsonConfigFileContent(
+      configFile.config,
+      ts.sys,
+      import_fs4.default.realpathSync(tsConfigPath).replace(/[^/\\]+$/, "")
+    );
+    const propertyMap = /* @__PURE__ */ new Map();
+    function findPropertyOriginAll(filePath) {
+      const program2 = ts.createProgram([filePath], parsedConfig.options);
+      const checker = program2.getTypeChecker();
+      const source = program2.getSourceFile(filePath);
+      if (!source)
+        return null;
+      function visit(node) {
+        if (!source)
+          return;
+        if (ts.isPropertyAccessExpression(node)) {
+          const left = node.expression;
+          const right = node.name;
+          const { line } = ts.getLineAndCharacterOfPosition(source, node.getStart());
+          const sourceLines = source.getFullText().split("\n");
+          if (ts.isIdentifier(left) && sourceLines.length && (sourceLines[line].includes(`@Field.Prop(() => ${left.text}.${right.text}`) || sourceLines[line].includes(`base.Filter(${left.text}.${right.text},`))) {
+            const symbol = checker.getSymbolAtLocation(right);
+            if (symbol?.declarations && symbol.declarations.length > 0) {
+              const key = symbol.declarations[0].getSourceFile().fileName.split("/").pop()?.split(".")[0] ?? "";
+              const property = propertyMap.get(key);
+              const isScalar = symbol.declarations[0].getSourceFile().fileName.includes("_");
+              const filePath2 = symbol.declarations[0].getSourceFile().fileName.replace(`${ts.sys.getCurrentDirectory()}/`, "");
+              if (property) {
+                propertyMap.set(`${left.text}.${right.text}`, {
+                  filePath: filePath2,
+                  isLibModule: true,
+                  isImport: false,
+                  libName: left.text,
+                  isScalar
+                });
+              } else
+                propertyMap.set(key, {
+                  filePath: filePath2,
+                  isLibModule: true,
+                  isImport: false,
+                  libName: left.text,
+                  isScalar
+                });
+              findPropertyOriginAll(filePath2);
+            }
+          }
+        } else if (ts.isImportDeclaration(node)) {
+          const importPath = node.moduleSpecifier.getText().slice(1, -1);
+          if (importPath.startsWith(".")) {
+            const resolved = ts.resolveModuleName(importPath, filePath, parsedConfig.options, ts.sys).resolvedModule?.resolvedFileName;
+            const moduleName = importPath.split("/").pop()?.split(".")[0] ?? "";
+            const property = propertyMap.get(moduleName);
+            const isScalar = importPath.includes("_");
+            if (moduleName && resolved && (!property || property.filePath !== resolved)) {
+              propertyMap.set(moduleName, {
+                filePath: resolved,
+                isLibModule: false,
+                isImport: true,
+                isScalar
+              });
+              findPropertyOriginAll(resolved);
+            }
+          }
+        }
+        ts.forEachChild(node, visit);
+      }
+      visit(source);
+      return propertyMap;
+    }
+    function findPropertyOrigin(filePath, aliasName, libName) {
+      const program2 = ts.createProgram([filePath], parsedConfig.options);
+      const checker = program2.getTypeChecker();
+      const source = program2.getSourceFile(filePath);
+      const propertyMap2 = /* @__PURE__ */ new Map();
+      if (!source)
+        return null;
+      function visit(node) {
+        if (ts.isPropertyAccessExpression(node)) {
+          const left = node.expression;
+          const right = node.name;
+          if (ts.isIdentifier(left) && left.text === aliasName && right.text === libName) {
+            const symbol = checker.getSymbolAtLocation(right);
+            if (symbol?.declarations && symbol.declarations.length > 0) {
+              return symbol.declarations[0].getSourceFile().fileName;
+            }
+          }
+        }
+        return ts.forEachChild(node, visit) || null;
+      }
+      return visit(source);
+    }
+    const spinner = (0, import_ora.default)("Finding property origin...");
+    spinner.start();
+    const paths = findPropertyOriginAll(constantFilePath);
+    spinner.succeed("property origin found.");
+    return { paths };
+  };
+
+  // pkgs/@akanjs/devkit/src/selectModel.ts
+  var import_prompts = __require("@inquirer/prompts");
+  var import_fs5 = __toESM(__require("fs"));
+  var selectModel = async (modulePath) => {
+    const modelNames = import_fs5.default.readdirSync(`${modulePath}/lib`).filter((dir) => !dir.includes(".") && !dir.startsWith("_"));
+    const modelName = await (0, import_prompts.select)({
+      message: "Select the model to create the unit for",
+      choices: modelNames.map((name) => ({ name, value: name }))
+    });
+    return modelName;
+  };
+
+  // pkgs/@akanjs/devkit/src/streamAi.ts
+  var import_prompts2 = __require("@langchain/core/prompts");
+  var import_runnables = __require("@langchain/core/runnables");
+  var import_openai = __require("@langchain/openai");
+  var streamAi = async (question, callback) => {
+    const createStreamingModel = (apiKey = process.env.DEEPSEEK_API_KEY) => {
+      if (!apiKey)
+        throw new Error(`process.env.DEEPSEEK_API_KEY is not set`);
+      return new import_openai.ChatOpenAI({
+        modelName: "deepseek-reasoner",
+        temperature: 0.7,
+        streaming: true,
+        // Enable streaming
+        configuration: { baseURL: "https://api.deepseek.com/v1", apiKey }
+      });
+    };
+    const createProcessingChain = () => {
+      return import_runnables.RunnableSequence.from([import_prompts2.PromptTemplate.fromTemplate(`Answer concisely: {question}`), createStreamingModel()]);
+    };
+    try {
+      const chain = createProcessingChain();
+      const stream = await chain.stream({ question });
+      let fullResponse = "";
+      for await (const chunk of stream) {
+        const content = chunk.content;
+        if (typeof content === "string") {
+          fullResponse += content;
+          callback(content);
+        }
+      }
+      return { content: fullResponse };
+    } catch (error) {
+      throw new Error("Failed to stream response");
+    }
+  };
+
+  // pkgs/@akanjs/common/src/isDayjs.ts
+  var import_dayjs = __require("dayjs");
+
+  // pkgs/@akanjs/common/src/isQueryEqual.ts
+  var import_dayjs2 = __toESM(__require("dayjs"));
+
+  // pkgs/@akanjs/common/src/isValidDate.ts
+  var import_dayjs3 = __toESM(__require("dayjs"));
+  var import_customParseFormat = __toESM(__require("dayjs/plugin/customParseFormat"));
+  import_dayjs3.default.extend(import_customParseFormat.default);
+
+  // pkgs/@akanjs/common/src/pluralize.ts
+  var import_pluralize = __toESM(__require("pluralize"));
+
+  // pkgs/@akanjs/common/src/capitalize.ts
+  var capitalize = (str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  };
+
+  // pkgs/@akanjs/common/src/Logger.ts
+  var import_dayjs4 = __toESM(__require("dayjs"));
+  var logLevels = ["trace", "verbose", "debug", "log", "info", "warn", "error"];
+  var clc = {
+    bold: (text) => `\x1B[1m${text}\x1B[0m`,
+    green: (text) => `\x1B[32m${text}\x1B[39m`,
+    yellow: (text) => `\x1B[33m${text}\x1B[39m`,
+    red: (text) => `\x1B[31m${text}\x1B[39m`,
+    magentaBright: (text) => `\x1B[95m${text}\x1B[39m`,
+    cyanBright: (text) => `\x1B[96m${text}\x1B[39m`
+  };
+  var colorizeMap = {
+    trace: clc.bold,
+    verbose: clc.cyanBright,
+    debug: clc.magentaBright,
+    log: clc.green,
+    info: clc.green,
+    warn: clc.yellow,
+    error: clc.red
+  };
+  var Logger = class _Logger {
+    static #ignoreCtxSet = /* @__PURE__ */ new Set([
+      "InstanceLoader",
+      "RoutesResolver",
+      "RouterExplorer",
+      "NestFactory",
+      "WebSocketsController",
+      "GraphQLModule",
+      "NestApplication"
+    ]);
+    static level = process.env.NEXT_PUBLIC_LOG_LEVEL ?? "log";
+    static #levelIdx = logLevels.findIndex((l) => l === process.env.NEXT_PUBLIC_LOG_LEVEL);
+    static #startAt = (0, import_dayjs4.default)();
+    static setLevel(level) {
+      this.level = level;
+      this.#levelIdx = logLevels.findIndex((l) => l === level);
+    }
+    name;
+    constructor(name) {
+      this.name = name;
+    }
+    trace(msg, context = "") {
+      if (_Logger.#levelIdx <= 0)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "trace");
+    }
+    verbose(msg, context = "") {
+      if (_Logger.#levelIdx <= 1)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "verbose");
+    }
+    debug(msg, context = "") {
+      if (_Logger.#levelIdx <= 2)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "debug");
+    }
+    log(msg, context = "") {
+      if (_Logger.#levelIdx <= 3)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "log");
+    }
+    info(msg, context = "") {
+      if (_Logger.#levelIdx <= 4)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "info");
+    }
+    warn(msg, context = "") {
+      if (_Logger.#levelIdx <= 5)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "warn");
+    }
+    error(msg, context = "") {
+      if (_Logger.#levelIdx <= 6)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "error");
+    }
+    raw(msg, method) {
+      _Logger.rawLog(msg, method);
+    }
+    rawLog(msg, method) {
+      _Logger.rawLog(msg, method);
+    }
+    static trace(msg, context = "") {
+      if (_Logger.#levelIdx <= 0)
+        _Logger.#printMessages("App", msg, context, "trace");
+    }
+    static verbose(msg, context = "") {
+      if (_Logger.#levelIdx <= 1)
+        _Logger.#printMessages("App", msg, context, "verbose");
+    }
+    static debug(msg, context = "") {
+      if (_Logger.#levelIdx <= 2)
+        _Logger.#printMessages("App", msg, context, "debug");
+    }
+    static log(msg, context = "") {
+      if (_Logger.#levelIdx <= 3)
+        _Logger.#printMessages("App", msg, context, "log");
+    }
+    static info(msg, context = "") {
+      if (_Logger.#levelIdx <= 4)
+        _Logger.#printMessages("App", msg, context, "info");
+    }
+    static warn(msg, context = "") {
+      if (_Logger.#levelIdx <= 5)
+        _Logger.#printMessages("App", msg, context, "warn");
+    }
+    static error(msg, context = "") {
+      if (_Logger.#levelIdx <= 6)
+        _Logger.#printMessages("App", msg, context, "error");
+    }
+    static #colorize(msg, logLevel) {
+      return colorizeMap[logLevel](msg);
+    }
+    static #printMessages(name, content, context, logLevel, writeStreamType = logLevel === "error" ? "stderr" : "stdout") {
+      if (this.#ignoreCtxSet.has(context))
+        return;
+      const now = (0, import_dayjs4.default)();
+      const processMsg = this.#colorize(
+        `[${name ?? "App"}] ${global.process?.pid ?? "window"} -`,
+        logLevel
+      );
+      const timestampMsg = now.format("MM/DD/YYYY, HH:mm:ss A");
+      const logLevelMsg = this.#colorize(logLevel.toUpperCase().padStart(7, " "), logLevel);
+      const contextMsg = context ? clc.yellow(`[${context}] `) : "";
+      const contentMsg = this.#colorize(content, logLevel);
+      const timeDiffMsg = clc.yellow(`+${now.diff(_Logger.#startAt, "ms")}ms`);
+      if (typeof window === "undefined")
+        process[writeStreamType].write(
+          `${processMsg} ${timestampMsg} ${logLevelMsg} ${contextMsg} ${contentMsg} ${timeDiffMsg}
+`
+        );
+      else
+        console.log(`${processMsg} ${timestampMsg} ${logLevelMsg} ${contextMsg} ${contentMsg} ${timeDiffMsg}
+`);
+    }
+    static rawLog(msg, method) {
+      this.raw(`${msg}
+`, method);
+    }
+    static raw(msg, method) {
+      if (typeof window === "undefined" && method !== "console" && global.process)
+        global.process.stdout.write(msg);
+      else
+        console.log(msg);
+    }
+  };
+
+  // pkgs/@akanjs/config/src/akanConfig.ts
+  var import_fs6 = __toESM(__require("fs"));
+  var import_path2 = __toESM(__require("path"));
+
+  // pkgs/@akanjs/config/src/baseConfigEnv.ts
+  var getBaseConfigEnv = (appName2 = process.env.NEXT_PUBLIC_APP_NAME) => {
+    if (!appName2)
+      throw new Error("NEXT_PUBLIC_APP_NAME is not set");
+    const repoName2 = process.env.NEXT_PUBLIC_REPO_NAME;
+    if (!repoName2)
+      throw new Error("NEXT_PUBLIC_REPO_NAME is not set");
+    const serveDomain2 = process.env.NEXT_PUBLIC_SERVE_DOMAIN;
+    if (!serveDomain2)
+      throw new Error("NEXT_PUBLIC_SERVE_DOMAIN is not set");
+    const env2 = process.env.NEXT_PUBLIC_ENV ?? "debug";
+    if (!env2)
+      throw new Error("NEXT_PUBLIC_ENV is not set");
+    return { appName: appName2, repoName: repoName2, serveDomain: serveDomain2, env: env2 };
+  };
+
+  // pkgs/@akanjs/config/src/nextConfig.ts
+  var import_bundle_analyzer = __toESM(__require("@next/bundle-analyzer"));
+  var import_next_pwa = __toESM(__require("next-pwa"));
+  var import_cache = __toESM(__require("next-pwa/cache"));
+  var import_path = __toESM(__require("path"));
+  var composePlugins = (...plugins) => {
+    return function(baseConfig) {
+      return async function combined(phase, context) {
+        let config = baseConfig;
+        for (const plugin of plugins) {
+          const fn = plugin;
+          const configOrFn = fn(config);
+          if (typeof configOrFn === "function")
+            config = await configOrFn(phase, context);
+          else
+            config = configOrFn;
+        }
+        return config;
+      };
+    };
+  };
+  var commandType = process.env.AKAN_COMMAND_TYPE?.includes("serve") ? "serve" : process.env.AKAN_COMMAND_TYPE?.includes("build") ? "build" : "deploy";
+  var withPWA = (0, import_next_pwa.default)({
+    dest: "public",
+    register: true,
+    skipWaiting: true,
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    runtimeCaching: import_cache.default,
+    disable: commandType === "serve"
+  });
+  var devDomain = process.env.NEXT_PUBLIC_SERVE_DOMAIN ?? "akanjs.com";
+  var withBase = (appName2, config, libs, routes = []) => {
+    return composePlugins(
+      (0, import_bundle_analyzer.default)({ enabled: process.env.ANALYZE === "true" }),
+      ...commandType !== "serve" || process.env.USE_PWA === "true" ? [withPWA] : []
+    )({
+      ...config,
+      eslint: { ...config.eslint, ignoreDuringBuilds: true },
+      env: {
+        ...config.env,
+        basePaths: routes.map(({ basePath: basePath2 }) => basePath2).join(",")
+      },
+      transpilePackages: [
+        "swiper",
+        "ssr-window",
+        "dom7",
+        ...libs.map((lib) => `@${lib}`),
+        "@akanjs/base",
+        "@akanjs/common",
+        "@akanjs/next",
+        "@akanjs/ui",
+        "@akanjs/client",
+        "@akanjs/server",
+        "@akanjs/service",
+        "@akanjs/signal",
+        "@akanjs/store",
+        "@akanjs/dictionary",
+        "@akanjs/constant",
+        "@akanjs/config",
+        "@akanjs/document"
+      ],
+      reactStrictMode: commandType === "serve" ? false : true,
+      experimental: {
+        ...config.experimental ?? {},
+        optimizePackageImports: [
+          ...[appName2, ...libs].map((lib) => [`@${lib}/ui`, `@${lib}/next`, `@${lib}/common`, `@${lib}/client`]).flat(),
+          "@contract",
+          "@akanjs/next",
+          "@akanjs/common"
+        ]
+      },
+      // modularizeImports: {
+      //   "react-icons/?(((\\w*)?/?)*)": {
+      //     transform: "@react-icons/all-files/{{ matches.[1] }}/{{member}}",
+      //     skipDefaultConversion: true,
+      //   },
+      //   lodash: { transform: "lodash/{{member}}", preventFullImport: true },
+      //   ...Object.fromEntries(
+      //     [appName, ...libs].reduce(
+      //       (acc, lib) => [
+      //         ...acc,
+      //         [`@${lib}/ui`, { transform: `@${lib}/ui/{{member}}`, skipDefaultConversion: true }],
+      //         [`@${lib}/next`, { transform: `@${lib}/next/{{member}}`, skipDefaultConversion: true }],
+      //         [`@${lib}/common`, { transform: `@${lib}/common/{{member}}`, skipDefaultConversion: true }],
+      //         [`@${lib}/client`, { transform: `@${lib}/lib/{{ camelCase member }}`, skipDefaultConversion: true }],
+      //       ],
+      //       [
+      //         ["@contract", { transform: `@contract/src/{{member}}`, skipDefaultConversion: true }],
+      //         [`@akanjs/next`, { transform: `@akanjs/next/src/{{member}}`, skipDefaultConversion: true }],
+      //         [`@akanjs/common`, { transform: `@akanjs/common/src/{{member}}`, skipDefaultConversion: true }],
+      //       ]
+      //     )
+      //   ),
+      //   ...(config.modularizeImports ?? {}),
+      // },
+      images: {
+        formats: ["image/avif", "image/webp"],
+        ...config.images ?? {},
+        remotePatterns: [
+          ...config.images?.remotePatterns ?? [],
+          ...routes.map(({ domains }) => [
+            ...domains.main?.map((domain) => ({ protocol: "https", hostname: `**.${domain}` })) ?? [],
+            ...domains.develop?.map((domain) => ({ protocol: "https", hostname: `**.${domain}` })) ?? [],
+            ...domains.debug?.map((domain) => ({ protocol: "https", hostname: `**.${domain}` })) ?? []
+          ]).flat(),
+          { protocol: "https", hostname: `**.${devDomain}` }
+        ]
+      },
+      webpack: (config2) => {
+        config2.resolve.alias.canvas = false;
+        config2.resolve.alias.encoding = false;
+        if (process.env.USE_AKANJS_PKGS === "true")
+          config2.resolve.alias["@akanjs/config"] = import_path.default.resolve(__dirname, "../../../../pkgs/@akanjs/config");
+        return config2;
+      },
+      redirects() {
+        return routes.map(({ basePath: basePath2, domains }) => [
+          { basePath: basePath2, domain: `${basePath2}-debug.${devDomain}` },
+          { basePath: basePath2, domain: `${basePath2}-develop.${devDomain}` },
+          { basePath: basePath2, domain: `${basePath2}-main.${devDomain}` },
+          ...domains.main?.map((domain) => ({ basePath: basePath2, domain })) ?? [],
+          ...domains.develop?.map((domain) => ({ basePath: basePath2, domain })) ?? [],
+          ...domains.debug?.map((domain) => ({ basePath: basePath2, domain })) ?? []
+        ]).flat().map(({ basePath: basePath2, domain }) => ({
+          source: `/:locale/${basePath2}/:path*`,
+          has: [{ type: "host", value: domain }],
+          permanent: true,
+          destination: "/:locale/:path*"
+        }));
+      },
+      rewrites() {
+        return routes.map(({ basePath: basePath2, domains }) => [
+          { basePath: basePath2, domain: `${basePath2}-debug.${devDomain}` },
+          { basePath: basePath2, domain: `${basePath2}-develop.${devDomain}` },
+          { basePath: basePath2, domain: `${basePath2}-main.${devDomain}` },
+          ...domains.main?.map((domain) => ({ basePath: basePath2, domain })) ?? [],
+          ...domains.develop?.map((domain) => ({ basePath: basePath2, domain })) ?? [],
+          ...domains.debug?.map((domain) => ({ basePath: basePath2, domain })) ?? []
+        ]).flat().map(({ basePath: basePath2, domain }) => [
+          {
+            source: "/:locale",
+            has: [{ type: "host", value: domain }],
+            destination: `/:locale/${basePath2}`
+          },
+          {
+            source: `/:locale/:path((?!${basePath2}$)(?!admin(?:/|$)).*)`,
+            has: [{ type: "host", value: domain }],
+            destination: `/:locale/${basePath2}/:path*`
+          }
+        ]).flat();
+      }
+    });
+  };
+
+  // pkgs/@akanjs/config/src/akanConfig.ts
+  var makeAppConfig = (config, props = {}) => {
+    const baseConfigEnv = getBaseConfigEnv(props.appName);
+    const {
+      appName: appName2 = baseConfigEnv.appName,
+      repoName: repoName2 = baseConfigEnv.repoName,
+      serveDomain: serveDomain2 = baseConfigEnv.serveDomain,
+      env: env2 = baseConfigEnv.env,
+      command = "build"
+    } = props;
+    return {
+      rootLib: config.rootLib,
+      libs: config.libs ?? [],
+      backend: {
+        dockerfile: config.backend?.dockerfile ?? `FROM node:22-slim
+RUN ln -sf /usr/share/zoneinfo/Asia/Seoul /etc/localtime
+RUN apt-get update && apt-get upgrade -y
+RUN apt-get install -y ca-certificates fonts-liberation libappindicator3-1 libasound2 libatk-bridge2.0-0 libatk1.0-0 libc6 libcairo2 libcups2 libdbus-1-3 libexpat1 libfontconfig1 libgbm1 libgcc1 libglib2.0-0 libgtk-3-0 libnspr4 libnss3 libpango-1.0-0 libpangocairo-1.0-0 libstdc++6 libx11-6 libx11-xcb1 libxcb1 libxcomposite1 libxcursor1 libxdamage1 libxext6 libxfixes3 libxi6 libxrandr2 libxrender1 libxss1 libxtst6 lsb-release wget xdg-utils udev
+ARG TARGETARCH
+RUN if [ "$TARGETARCH" = "amd64" ]; then       wget https://fastdl.mongodb.org/tools/db/mongodb-database-tools-debian92-x86_64-100.3.1.deb &&       apt-get install -y ./mongodb-database-tools-*.deb &&       rm -f mongodb-database-tools-*.deb;     fi
+RUN apt-get install -y git redis build-essential python3
+RUN rm -rf /var/lib/apt/lists/*
+RUN mkdir -p /workspace
+WORKDIR /workspace
+COPY ./package.json ./package.json
+RUN npx pnpm i --prod
+COPY . .
+ENV PORT 8080
+ENV NODE_OPTIONS=--max_old_space_size=8192
+ENV NEXT_PUBLIC_REPO_NAME=${repoName2}
+ENV NEXT_PUBLIC_SERVE_DOMAIN=${serveDomain2}
+ENV NEXT_PUBLIC_APP_NAME=${appName2}
+ENV NEXT_PUBLIC_ENV=${env2}
+ENV NEXT_PUBLIC_OPERATION_MODE=cloud
+CMD ["node", "main.js"]`,
+        explicitDependencies: config.backend?.explicitDependencies ?? []
+      },
+      frontend: {
+        dockerfile: config.frontend?.dockerfile ?? `FROM node:22-alpine
+RUN ln -sf /usr/share/zoneinfo/Asia/Seoul /etc/localtime
+RUN apk --no-cache add git
+RUN mkdir -p /workspace
+WORKDIR /workspace
+COPY ./package.json ./package.json
+RUN npx pnpm i --prod
+COPY . .
+ENV PORT 4200
+ENV NODE_OPTIONS=--max_old_space_size=8192
+ENV NEXT_PUBLIC_REPO_NAME=${repoName2}
+ENV NEXT_PUBLIC_SERVE_DOMAIN=${serveDomain2}
+ENV NEXT_PUBLIC_APP_NAME=${appName2}
+ENV NEXT_PUBLIC_ENV=${env2}
+ENV NEXT_PUBLIC_OPERATION_MODE=cloud
+CMD ["npm", "start"]`,
+        nextConfig: withBase(
+          appName2,
+          config.frontend?.nextConfig ? typeof config.frontend.nextConfig === "function" ? config.frontend.nextConfig() : config.frontend.nextConfig : {},
+          config.libs ?? [],
+          config.frontend?.routes
+        ),
+        explicitDependencies: config.frontend?.explicitDependencies ?? []
+      }
+    };
+  };
+  var getAppConfig = async (appRoot, props) => {
+    const akanConfigPath = import_path2.default.join(appRoot, "akan.config.ts");
+    if (!import_fs6.default.existsSync(akanConfigPath))
+      throw new Error(`application akan.config.ts is not found ${appRoot}`);
+    const configImp = (await import(`${appRoot}/akan.config.ts`)).default;
+    const config = typeof configImp === "function" ? configImp(props) : configImp;
+    return makeAppConfig(config, props);
+  };
+  var makeLibConfig = (config, props = {}) => {
+    return {
+      rootLib: config.rootLib,
+      libs: config.libs ?? [],
+      backend: {
+        explicitDependencies: config.backend?.explicitDependencies ?? []
+      },
+      frontend: {
+        explicitDependencies: config.frontend?.explicitDependencies ?? []
+      }
+    };
+  };
+  var getLibConfig = async (libRoot, props) => {
+    const akanConfigPath = import_path2.default.join(libRoot, "akan.config.ts");
+    if (!import_fs6.default.existsSync(akanConfigPath))
+      throw new Error(`library akan.config.ts is not found ${libRoot}`);
+    const configImp = (await import(`${libRoot}/akan.config.ts`)).default;
+    const config = typeof configImp === "function" ? configImp(props) : configImp;
+    return makeLibConfig(config, props);
+  };
+
+  // pkgs/@akanjs/config/index.ts
+  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/devkit/src/executors.ts
+  var import_child_process = __require("child_process");
+  var import_fs7 = __toESM(__require("fs"));
+  var import_promises = __toESM(__require("fs/promises"));
+  var import_path3 = __toESM(__require("path"));
+
+  // pkgs/@akanjs/devkit/src/dependencyScanner.ts
+  var fs7 = __toESM(__require("fs"));
+  var path3 = __toESM(__require("path"));
+  var ts2 = __toESM(__require("typescript"));
+  var TypeScriptDependencyScanner = class {
+    constructor(directory) {
+      this.directory = directory;
+    }
+    #fileDependencies = /* @__PURE__ */ new Map();
+    #visitedFiles = /* @__PURE__ */ new Set();
+    async getImportSets(depSets) {
+      const fileDependencies = await this.getDependencies();
+      const importedDepSets = new Array(depSets.length);
+      for (let i = 0; i < depSets.length; i++)
+        importedDepSets[i] = /* @__PURE__ */ new Set();
+      fileDependencies.forEach((imps) => {
+        imps.forEach((imp) => {
+          if (imp.startsWith("."))
+            return;
+          const moduleName = imp;
+          const moduleNameParts = moduleName.split("/");
+          const subModuleLength = moduleNameParts.length;
+          for (let i = 0; i < subModuleLength; i++) {
+            const importName = moduleNameParts.slice(0, i + 1).join("/");
+            for (let j = 0; j < depSets.length; j++) {
+              if (depSets[j].has(importName)) {
+                importedDepSets[j].add(importName);
+                return;
+              }
+            }
+          }
+        });
+      });
+      return importedDepSets;
+    }
+    async getDependencies() {
+      this.#fileDependencies.clear();
+      this.#visitedFiles.clear();
+      const files = await this.#findTypeScriptFiles(this.directory);
+      for (const file of files)
+        await this.#analyzeFile(file, this.directory);
+      return this.#fileDependencies;
+    }
+    async #findTypeScriptFiles(directory) {
+      const files = [];
+      const processDirectory = async (dir) => {
+        const entries = await fs7.promises.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+          const fullPath = path3.join(dir, entry.name);
+          if (entry.isDirectory()) {
+            if (!["node_modules", "dist", "build", ".git", ".next", "public", "ios", "android"].includes(entry.name))
+              await processDirectory(fullPath);
+          } else if (entry.isFile() && (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")))
+            files.push(fullPath);
+        }
+      };
+      await processDirectory(directory);
+      return files;
+    }
+    async #analyzeFile(filePath, baseDir) {
+      if (this.#visitedFiles.has(filePath))
+        return;
+      this.#visitedFiles.add(filePath);
+      try {
+        const fileContent = await fs7.promises.readFile(filePath, "utf-8");
+        const imports = this.#extractImports(fileContent, filePath);
+        const resolvedImports = imports.map((importPath) => {
+          if (importPath.startsWith(".")) {
+            const resolvedPath = "./" + path3.join(path3.relative(baseDir, filePath), importPath);
+            return this.#ensureExtension(resolvedPath);
+          }
+          return importPath;
+        });
+        const relativePath = path3.relative(baseDir, filePath);
+        this.#fileDependencies.set(relativePath, resolvedImports);
+      } catch (error) {
+      }
+    }
+    #ensureExtension(filePath) {
+      if (fs7.existsSync(`${filePath}.ts`))
+        return `${filePath}.ts`;
+      else if (fs7.existsSync(`${filePath}.tsx`))
+        return `${filePath}.tsx`;
+      else if (fs7.existsSync(filePath))
+        return filePath;
+      return `${filePath}.ts`;
+    }
+    #extractImports(source, filePath) {
+      const imports = [];
+      const sourceFile = ts2.createSourceFile(filePath, source, ts2.ScriptTarget.Latest, true);
+      const visit = (node) => {
+        if (ts2.isImportDeclaration(node)) {
+          const moduleSpecifier = node.moduleSpecifier;
+          if (ts2.isStringLiteral(moduleSpecifier))
+            imports.push(moduleSpecifier.text);
+        }
+        ts2.forEachChild(node, visit);
+      };
+      visit(sourceFile);
+      return imports;
+    }
+    generateDependencyGraph() {
+      let graph = "Dependency Graph:\n\n";
+      for (const [file, imports] of this.#fileDependencies.entries()) {
+        graph += `${file}:
+`;
+        const projectImports = imports.filter((i) => !i.startsWith("react") && !i.startsWith("@"));
+        const externalImports = imports.filter((i) => i.startsWith("react") || i.startsWith("@"));
+        if (projectImports.length > 0) {
+          graph += "  Project dependencies:\n";
+          projectImports.forEach((imp) => {
+            graph += `    \u2192 ${imp}
+`;
+          });
+        }
+        if (externalImports.length > 0) {
+          graph += "  External dependencies:\n";
+          externalImports.forEach((imp) => {
+            graph += `    \u2192 ${imp}
+`;
+          });
+        }
+        graph += "\n";
+      }
+      return graph;
+    }
+  };
+
+  // pkgs/@akanjs/devkit/src/executors.ts
+  var Executor = class {
+    logger;
+    cwdPath;
+    constructor(name, cwdPath) {
+      this.logger = new Logger(name);
+      this.cwdPath = cwdPath;
+      if (!import_fs7.default.existsSync(cwdPath))
+        import_fs7.default.mkdirSync(cwdPath, { recursive: true });
+    }
+    exec(command, options = {}) {
+      const proc = (0, import_child_process.exec)(command, { cwd: this.cwdPath, ...options });
+      proc.stdout?.on("data", (data) => {
+        Logger.raw(data.toString());
+      });
+      proc.stderr?.on("data", (data) => {
+        Logger.raw(data.toString());
+      });
+      return new Promise((resolve, reject) => {
+        proc.on("exit", (code, signal) => {
+          if (!!code || signal)
+            reject({ code, signal });
+          else
+            resolve({ code, signal });
+        });
+      });
+    }
+    spawn(command, args = [], options = {}) {
+      const proc = (0, import_child_process.spawn)(command, args, { cwd: this.cwdPath, stdio: "inherit", ...options });
+      proc.stderr?.on("data", (data) => {
+        Logger.raw(data.toString());
+      });
+      return new Promise((resolve, reject) => {
+        proc.on("exit", (code, signal) => {
+          if (!!code || signal)
+            reject({ code, signal });
+          else
+            resolve({ code, signal });
+        });
+      });
+    }
+    fork(modulePath, args = [], options = {}) {
+      const proc = (0, import_child_process.fork)(modulePath, args, {
+        cwd: this.cwdPath,
+        stdio: ["ignore", "inherit", "inherit", "ipc"],
+        ...options
+      });
+      proc.stdout?.on("data", (data) => {
+        Logger.raw(data.toString());
+      });
+      proc.stderr?.on("data", (data) => {
+        Logger.raw(data.toString());
+      });
+      return new Promise((resolve, reject) => {
+        proc.on("exit", (code, signal) => {
+          if (!!code || signal)
+            reject({ code, signal });
+          else
+            resolve({ code, signal });
+        });
+      });
+    }
+    mkdir(dirPath) {
+      const writePath = import_path3.default.isAbsolute(dirPath) ? dirPath : `${this.cwdPath}/${dirPath}`;
+      if (!import_fs7.default.existsSync(writePath))
+        import_fs7.default.mkdirSync(writePath, { recursive: true });
+      this.logger.verbose(`Make directory ${writePath}`);
+      return this;
+    }
+    writeFile(filePath, content) {
+      const writePath = import_path3.default.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
+      const dir = import_path3.default.dirname(writePath);
+      if (!import_fs7.default.existsSync(dir))
+        import_fs7.default.mkdirSync(dir, { recursive: true });
+      const contentStr = typeof content === "string" ? content : JSON.stringify(content, null, 2);
+      if (import_fs7.default.existsSync(writePath)) {
+        const currentContent = import_fs7.default.readFileSync(writePath, "utf8");
+        if (currentContent === contentStr)
+          this.logger.verbose(`File ${writePath} is unchanged`);
+        else {
+          import_fs7.default.writeFileSync(writePath, contentStr, "utf8");
+          this.logger.debug(`File ${writePath} is changed`);
+        }
+      } else {
+        import_fs7.default.writeFileSync(writePath, contentStr, "utf8");
+        this.logger.debug(`File ${writePath} is created`);
+      }
+      return this;
+    }
+    writeJson(filePath, content) {
+      this.writeFile(filePath, JSON.stringify(content, null, 2));
+      return this;
+    }
+    readFile(filePath) {
+      const readPath = import_path3.default.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
+      return import_fs7.default.readFileSync(readPath, "utf8");
+    }
+    readJson(filePath) {
+      const readPath = import_path3.default.isAbsolute(filePath) ? filePath : `${this.cwdPath}/${filePath}`;
+      return JSON.parse(import_fs7.default.readFileSync(readPath, "utf8"));
+    }
+    async cp(srcPath, destPath) {
+      const src = import_path3.default.isAbsolute(srcPath) ? srcPath : `${this.cwdPath}/${srcPath}`;
+      const dest = import_path3.default.isAbsolute(destPath) ? destPath : `${this.cwdPath}/${destPath}`;
+      await import_promises.default.cp(src, dest, { recursive: true });
+    }
+    log(msg) {
+      this.logger.info(msg);
+      return this;
+    }
+    verbose(msg) {
+      this.logger.verbose(msg);
+      return this;
+    }
+    getTsConfig(pathname) {
+      const tsconfig = this.readJson(pathname);
+      if (tsconfig.extends) {
+        const extendsTsconfig = this.getTsConfig(tsconfig.extends);
+        return {
+          ...extendsTsconfig,
+          ...tsconfig,
+          compilerOptions: { ...extendsTsconfig.compilerOptions, ...tsconfig.compilerOptions }
+        };
+      }
+      return tsconfig;
+    }
+    async #applyTemplateFile({
+      templatePath,
+      targetPath,
+      scanResult
+    }, dict = {}) {
+      if (targetPath.endsWith(".js")) {
+        const getContent = await import(templatePath);
+        const content = getContent.default(scanResult ?? null, dict);
+        const convertedTargetPath = Object.entries(dict).reduce(
+          (path5, [key, value]) => path5.replace(new RegExp(`__${key}__`, "g"), value),
+          targetPath.replace(".js", ".ts")
+        );
+        if (content === null)
+          return;
+        this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
+        this.writeFile(convertedTargetPath, content);
+      } else if (targetPath.endsWith(".template")) {
+        const content = await import_promises.default.readFile(templatePath, "utf8");
+        const convertedTargetPath = Object.entries(dict).reduce(
+          (path5, [key, value]) => path5.replace(new RegExp(`__${key}__`, "g"), value),
+          targetPath.slice(0, -9)
+        );
+        const convertedContent = Object.entries(dict).reduce(
+          (content2, [key, value]) => content2.replace(new RegExp(`<%= ${key} %>`, "g"), value),
+          content
+        );
+        this.logger.verbose(`Apply template ${templatePath} to ${convertedTargetPath}`);
+        this.writeFile(convertedTargetPath, convertedContent);
+      }
+    }
+    async applyTemplate({
+      basePath: basePath2,
+      template,
+      scanResult,
+      dict = {}
+    }) {
+      const templatePath = `${__dirname}/src/templates${template ? `/${template}` : ""}`.replace(".ts", ".js");
+      if (import_fs7.default.statSync(templatePath).isFile()) {
+        const filename = import_path3.default.basename(templatePath);
+        await this.#applyTemplateFile({ templatePath, targetPath: import_path3.default.join(basePath2, filename), scanResult }, dict);
+      } else {
+        if (!import_fs7.default.existsSync(basePath2))
+          await import_promises.default.mkdir(basePath2, { recursive: true });
+        const subdirs = await import_promises.default.readdir(templatePath);
+        await Promise.all(
+          subdirs.map(async (subdir) => {
+            const subpath = import_path3.default.join(templatePath, subdir);
+            if (import_fs7.default.statSync(subpath).isFile())
+              await this.#applyTemplateFile(
+                { templatePath: subpath, targetPath: import_path3.default.join(basePath2, subdir), scanResult },
+                dict
+              );
+            else
+              await this.applyTemplate({
+                basePath: import_path3.default.join(basePath2, subdir),
+                template: import_path3.default.join(template, subdir),
+                scanResult,
+                dict
+              });
+          })
+        );
+      }
+    }
+  };
+  var WorkspaceExecutor = class _WorkspaceExecutor extends Executor {
+    workspaceRoot;
+    repoName;
+    constructor({ workspaceRoot, repoName: repoName2 }) {
+      super(`${repoName2} Executor`, workspaceRoot);
+      this.workspaceRoot = workspaceRoot;
+      this.repoName = repoName2;
+    }
+    static fromRoot() {
+      const repoName2 = import_path3.default.basename(process.cwd());
+      return new _WorkspaceExecutor({ workspaceRoot: process.cwd(), repoName: repoName2 });
+    }
+    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 (appName2) => {
+            const app = AppExecutor.from(this, appName2);
+            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]))
+      };
+    }
+    async getApps() {
+      return await this.#getDirHasFile(`${this.workspaceRoot}/apps`, "akan.config.ts");
+    }
+    async getLibs() {
+      return await this.#getDirHasFile(`${this.workspaceRoot}/libs`, "akan.config.ts");
+    }
+    async getSyss() {
+      const [appNames, libNames] = await Promise.all([this.getApps(), this.getLibs()]);
+      return [appNames, libNames];
+    }
+    async getPkgs() {
+      return await this.#getDirHasFile(`${this.workspaceRoot}/pkgs`, "package.json");
+    }
+    async #getDirHasFile(basePath2, targetFilename) {
+      const AVOID_DIRS = ["node_modules", "dist", "public", "./next"];
+      const getDirs = async (dirname, maxDepth = 3, results = [], prefix = "") => {
+        const dirs = await import_promises.default.readdir(dirname);
+        await Promise.all(
+          dirs.map(async (dir) => {
+            if (AVOID_DIRS.includes(dir))
+              return;
+            const dirPath = import_path3.default.join(dirname, dir);
+            if (import_fs7.default.lstatSync(dirPath).isDirectory()) {
+              const hasTargetFile = import_fs7.default.existsSync(import_path3.default.join(dirPath, targetFilename));
+              if (hasTargetFile)
+                results.push(`${prefix}${dir}`);
+              if (maxDepth > 0)
+                await getDirs(dirPath, maxDepth - 1, results, `${prefix}${dir}/`);
+            }
+          })
+        );
+        return results;
+      };
+      return await getDirs(basePath2);
+    }
+  };
+  var SysExecutor = class extends Executor {
+    workspace;
+    name;
+    type;
+    constructor({ workspace = WorkspaceExecutor.fromRoot(), name, type }) {
+      super(`${name} Sys Executor`, `${workspace.workspaceRoot}/${type}s/${name}`);
+      this.workspace = workspace;
+      this.name = name;
+      this.type = type;
+    }
+    async getConfig(command) {
+      return this.type === "app" ? await getAppConfig(this.cwdPath, { ...baseDevEnv, appName: this.name, command }) : await getLibConfig(this.cwdPath, { ...baseDevEnv, appName: this.name, command });
+    }
+    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((path5) => tsconfig.compilerOptions.paths[path5].some((resolve) => resolve.startsWith("pkgs/"))).map((path5) => path5.replace("/*", ""))
+      );
+      const libPathSet = new Set(
+        Object.keys(tsconfig.compilerOptions.paths).filter((path5) => tsconfig.compilerOptions.paths[path5].some((resolve) => resolve.startsWith("libs/"))).map((path5) => path5.replace("/*", ""))
+      );
+      const [npmDepSet, pkgPathDepSet, libPathDepSet] = await scanner.getImportSets([npmSet, pkgPathSet, libPathSet]);
+      const pkgDeps = [...pkgPathDepSet].map((path5) => {
+        const pathSplitLength = path5.split("/").length;
+        return tsconfig.compilerOptions.paths[path5][0].split("/").slice(1, 1 + pathSplitLength).join("/");
+      });
+      const libDeps = [...libPathDepSet].map((path5) => {
+        const pathSplitLength = path5.split("/").length;
+        return tsconfig.compilerOptions.paths[path5][0].split("/").slice(1, 1 + pathSplitLength).join("/");
+      }).filter((libName) => libName !== this.name);
+      if (!import_fs7.default.existsSync(`${this.cwdPath}/lib/__scalar`))
+        import_fs7.default.mkdirSync(`${this.cwdPath}/lib/__scalar`, { recursive: true });
+      const files = getDefaultFileScan();
+      const dirnames = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter(
+        (name) => import_fs7.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 import_promises.default.readdir(import_path3.default.join(this.cwdPath, "lib", name));
+          filenames.forEach((filename) => {
+            if (filename.endsWith(".constant.ts"))
+              files.constants.databases.push(name);
+            else if (filename.endsWith(".dictionary.ts"))
+              files.dictionary.databases.push(name);
+            else if (filename.endsWith(".document.ts"))
+              files.documents.databases.push(name);
+            else if (filename.endsWith(".service.ts"))
+              files.services.databases.push(name);
+            else if (filename.endsWith(".signal.ts"))
+              files.signal.databases.push(name);
+            else if (filename.endsWith(".store.ts"))
+              files.store.databases.push(name);
+            else if (filename === "index.tsx")
+              files.components.databases.push(name);
+          });
+        })
+      );
+      await Promise.all(
+        serviceDirs.map(async (dirname) => {
+          const name = dirname.slice(1);
+          const filenames = await import_promises.default.readdir(import_path3.default.join(this.cwdPath, "lib", dirname));
+          filenames.forEach((filename) => {
+            if (filename.endsWith(".dictionary.ts"))
+              files.dictionary.services.push(name);
+            else if (filename.endsWith(".service.ts"))
+              files.services.services.push(name);
+            else if (filename.endsWith(".signal.ts"))
+              files.signal.services.push(name);
+            else if (filename.endsWith(".store.ts"))
+              files.store.services.push(name);
+            else if (filename === "index.tsx")
+              files.components.services.push(name);
+          });
+        })
+      );
+      const scalarDirs = (await import_promises.default.readdir(`${this.cwdPath}/lib/__scalar`)).filter(
+        (name) => !name.startsWith("_")
+      );
+      await Promise.all(
+        scalarDirs.map(async (name) => {
+          const filenames = await import_promises.default.readdir(import_path3.default.join(this.cwdPath, "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 libDeps) {
+        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);
+      }
+      const scanResult = {
+        name: this.name,
+        type: this.type,
+        akanConfig,
+        files,
+        libDeps,
+        pkgDeps,
+        dependencies: [...npmDepSet],
+        libs: Object.fromEntries(libDeps.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);
+      return scanResult;
+    }
+    async getDatabaseModules() {
+      const databaseModules = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter((name) => !name.startsWith("_")).filter((name) => import_fs7.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.constant.ts`));
+      return databaseModules;
+    }
+    async getServiceModules() {
+      const serviceModules = (await import_promises.default.readdir(`${this.cwdPath}/lib`)).filter((name) => name.startsWith("_") && !name.startsWith("__")).filter((name) => import_fs7.default.existsSync(`${this.cwdPath}/lib/${name}/${name}.service.ts`));
+      return serviceModules;
+    }
+    async getScalarModules() {
+      const scalarModules = (await import_promises.default.readdir(`${this.cwdPath}/lib/__scalar`)).filter((name) => !name.startsWith("_")).filter((name) => import_fs7.default.existsSync(`${this.cwdPath}/lib/__scalar/${name}/${name}.constant.ts`));
+      return scalarModules;
+    }
+  };
+  var AppExecutor = class _AppExecutor extends SysExecutor {
+    constructor({ workspace, name }) {
+      super({ workspace, name, type: "app" });
+    }
+    static from(executor, name) {
+      if (executor instanceof WorkspaceExecutor)
+        return new _AppExecutor({ workspace: executor, name });
+      return new _AppExecutor({ workspace: executor.workspace, name });
+    }
+    async getConfig(command) {
+      return await getAppConfig(this.cwdPath, { ...baseDevEnv, appName: this.name, command });
+    }
+    async syncAssets(libDeps) {
+      const projectPublicLibPath = `${this.cwdPath}/public/libs`;
+      if (import_fs7.default.existsSync(projectPublicLibPath))
+        await import_promises.default.rm(projectPublicLibPath, { recursive: true });
+      const targetDeps = libDeps.filter((dep) => import_fs7.default.existsSync(`${this.workspace.workspaceRoot}/libs/${dep}/public`));
+      await Promise.all(targetDeps.map((dep) => import_promises.default.mkdir(`${projectPublicLibPath}/${dep}`, { recursive: true })));
+      await Promise.all(
+        targetDeps.map(
+          (dep) => import_promises.default.cp(`${this.workspace.workspaceRoot}/libs/${dep}/public`, `${projectPublicLibPath}/${dep}`, {
+            recursive: true
+          })
+        )
+      );
+    }
+  };
+  var DistAppExecutor = class _DistAppExecutor extends Executor {
+    name;
+    constructor({ workspace, name }) {
+      super(`${name} Dist App Executor`, `${workspace.workspaceRoot}/dist/apps/${name}`);
+      this.name = name;
+    }
+    static from(executor, name) {
+      if (executor instanceof WorkspaceExecutor)
+        return new _DistAppExecutor({ workspace: executor, name });
+      return new _DistAppExecutor({ workspace: executor.workspace, name });
+    }
+  };
+  var LibExecutor = class _LibExecutor extends SysExecutor {
+    workspaceRoot;
+    repoName;
+    constructor({ workspace, name }) {
+      super({ workspace, name, type: "lib" });
+    }
+    static from(executor, name) {
+      if (executor instanceof WorkspaceExecutor)
+        return new _LibExecutor({ workspace: executor, name });
+      return new _LibExecutor({ workspace: executor.workspace, name });
+    }
+    async getConfig(command) {
+      return await getLibConfig(this.cwdPath, { ...baseDevEnv, appName: this.name, command });
+    }
+  };
+  var DistLibExecutor = class _DistLibExecutor extends Executor {
+    name;
+    constructor({ workspace, name }) {
+      super(`${name} Dist Lib Executor`, `${workspace.workspaceRoot}/dist/libs/${name}`);
+      this.name = name;
+    }
+    static from(executor, name) {
+      if (executor instanceof WorkspaceExecutor)
+        return new DistAppExecutor({ workspace: executor, name });
+      return new _DistLibExecutor({ workspace: executor.workspace, name });
+    }
+  };
+  var PkgExecutor = class _PkgExecutor extends Executor {
+    workspace;
+    name;
+    constructor({ workspace = WorkspaceExecutor.fromRoot(), name }) {
+      super(`${name} Pkg Executor`, `${workspace.workspaceRoot}/pkgs/${name}`);
+      this.workspace = workspace;
+      this.name = name;
+    }
+    static from(executor, name) {
+      if (executor instanceof WorkspaceExecutor)
+        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((path5) => tsconfig.compilerOptions.paths[path5].some((resolve) => resolve.startsWith("pkgs/"))).map((path5) => path5.replace("/*", ""))
+      );
+      const [npmDepSet, pkgPathDepSet] = await scanner.getImportSets([npmSet, pkgPathSet]);
+      const pkgDeps = [...pkgPathDepSet].map((path5) => {
+        const pathSplitLength = path5.split("/").length;
+        return tsconfig.compilerOptions.paths[path5][0].split("/").slice(1, 1 + pathSplitLength).join("/");
+      }).filter((pkg) => pkg !== this.name);
+      const pkgScanResult = {
+        name: this.name,
+        pkgDeps,
+        dependencies: [...npmDepSet]
+      };
+      return pkgScanResult;
+    }
+  };
+  var DistPkgExecutor = class _DistPkgExecutor extends Executor {
+    workspaceRoot;
+    repoName;
+    name;
+    constructor({ workspaceRoot, repoName: repoName2, name }) {
+      super(`${name} Dist Pkg Executor`, `${workspaceRoot}/dist/pkgs/${name}`);
+      this.workspaceRoot = workspaceRoot;
+      this.repoName = repoName2;
+      this.name = name;
+    }
+    static from(workspaceExecutor, name) {
+      return new _DistPkgExecutor({
+        workspaceRoot: workspaceExecutor.workspaceRoot,
+        repoName: workspaceExecutor.repoName,
+        name
+      });
+    }
+  };
+
+  // pkgs/@akanjs/devkit/src/constants.ts
+  var import_os = __require("os");
+  var basePath = `${(0, import_os.homedir)()}/.akan`;
+  var configPath = `${basePath}/config.json`;
+  var akanCloudHost = process.env.NEXT_PUBLIC_OPERATION_MODE === "local" ? "http://localhost" : "https://akasys-debug.akamir.com";
+  var akanCloudBackendUrl = `${akanCloudHost}${process.env.NEXT_PUBLIC_OPERATION_MODE === "local" ? ":8080" : ""}/backend`;
+  var akanCloudClientUrl = `${akanCloudHost}${process.env.NEXT_PUBLIC_OPERATION_MODE === "local" ? ":4200" : ""}`;
+  var defaultHostConfig = {};
+  var defaultAkanGlobalConfig = {};
+
+  // pkgs/@akanjs/devkit/src/auth.ts
+  var import_fs8 = __toESM(__require("fs"));
+  var getAkanGlobalConfig = () => {
+    const akanConfig = import_fs8.default.existsSync(configPath) ? JSON.parse(import_fs8.default.readFileSync(configPath, "utf8")) : defaultAkanGlobalConfig;
+    return akanConfig;
+  };
+  var setAkanGlobalConfig = (akanConfig) => {
+    import_fs8.default.mkdirSync(basePath, { recursive: true });
+    import_fs8.default.writeFileSync(configPath, JSON.stringify(akanConfig, null, 2));
+  };
+  var getHostConfig = (host = akanCloudHost) => {
+    const akanConfig = getAkanGlobalConfig();
+    return akanConfig[host] ?? defaultHostConfig;
+  };
+  var setHostConfig = (host = akanCloudHost, config = {}) => {
+    const akanConfig = getAkanGlobalConfig();
+    akanConfig[host] = config;
+    setAkanGlobalConfig(akanConfig);
+  };
+  var getSelf = async (token) => {
+    try {
+      const res = await fetch(`${akanCloudBackendUrl}/user/getSelf`, { headers: { Authorization: `Bearer ${token}` } });
+      const user = await res.json();
+      return user;
+    } catch (e) {
+      return null;
+    }
+  };
+
+  // pkgs/@akanjs/devkit/src/capacitorApp.ts
+  var import_project = __require("@trapezedev/project");
+  var import_fs9 = __toESM(__require("fs"));
+  var CapacitorApp = class {
+    constructor(app) {
+      this.app = app;
+    }
+    project;
+    iosTargetName = "App";
+    async init() {
+      const project = new import_project.MobileProject(this.app.cwdPath, {
+        android: { path: "android" },
+        ios: { path: "ios/App" }
+      });
+      await project.load();
+      if (!project.android)
+        throw new Error(`Android is not added, Please add platform first
+ akan serve-android ${this.app.name}`);
+      if (!project.ios)
+        throw new Error(`iOS is not added, Please add platform first
+ akan serve-ios ${this.app.name}`);
+      this.project = project;
+      return this;
+    }
+    async save() {
+      await this.project.commit();
+    }
+    async releaseIos() {
+      const isAdded = import_fs9.default.existsSync(`${this.app.cwdPath}/ios/App/Podfile`);
+      if (!isAdded) {
+        await this.app.spawn("npx cap add ios");
+        await this.app.spawn("npx @capacitor/assets generate");
+      } else
+        this.app.log(`iOS already added, skip adding process`);
+      await this.app.spawn("cross-env", ["APP_OPERATION_MODE=release", "npx", "cap", "sync", "ios"]);
+    }
+    async releaseAndroid() {
+      const isAdded = import_fs9.default.existsSync(`${this.app.cwdPath}/android/app/build.gradle`);
+      if (!isAdded) {
+        await this.app.spawn("npx cap add android");
+        await this.app.spawn("npx @capacitor/assets generate");
+      } else
+        this.app.log(`android already added, skip adding process`);
+      await this.app.spawn("cross-env", ["APP_OPERATION_MODE=release", "npx", "cap", "sync", "android"]);
+    }
+    async addCamera() {
+      await this.#setPermissionInIos({
+        cameraUsageDescription: "$(PRODUCT_NAME) requires access to the camera to take photos.",
+        photoAddUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos.",
+        photoUsageDescription: "$(PRODUCT_NAME) requires access to the photo library to take photos."
+      });
+      this.#setPermissionsInAndroid(["READ_MEDIA_IMAGES", "READ_EXTERNAL_STORAGE", "WRITE_EXTERNAL_STORAGE"]);
+    }
+    async addContact() {
+      await this.#setPermissionInIos({
+        contactsUsageDescription: "$(PRODUCT_NAME) requires access to the contacts to add new contacts."
+      });
+      this.#setPermissionsInAndroid(["READ_CONTACTS", "WRITE_CONTACTS"]);
+    }
+    async addLocation() {
+      await this.#setPermissionInIos({
+        locationAlwaysUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location.",
+        locationWhenInUseUsageDescription: "$(PRODUCT_NAME) requires access to the location to get the user's location."
+      });
+      this.#setPermissionsInAndroid(["ACCESS_COARSE_LOCATION", "ACCESS_FINE_LOCATION"]);
+      this.#setFeaturesInAndroid(["android.hardware.location.gps"]);
+    }
+    async #setPermissionInIos(permissions) {
+      const updateNs = Object.fromEntries(
+        Object.entries(permissions).map(([key, value]) => [`NS${capitalize(key)}`, value])
+      );
+      await Promise.all([
+        this.project.ios.updateInfoPlist(this.iosTargetName, "Debug", updateNs),
+        this.project.ios.updateInfoPlist(this.iosTargetName, "Release", updateNs)
+      ]);
+    }
+    #setFeaturesInAndroid(features) {
+      for (const feature of features) {
+        if (this.#hasFeatureInAndroid(feature)) {
+          this.app.logger.info(`${feature} already exists in android`);
+          return this;
+        }
+        this.app.logger.info(`Adding ${feature} to android`);
+        this.project.android.getAndroidManifest().injectFragment("manifest", `<uses-feature android:name="${feature}" />`);
+      }
+      return this;
+    }
+    #getFeaturesInAndroid() {
+      const androidManifest = this.project.android.getAndroidManifest();
+      const element = androidManifest.getDocumentElement();
+      if (!element)
+        throw new Error("manifest not found");
+      const usesFeature = element.getElementsByTagName("uses-feature");
+      return Array.from(usesFeature).map((feature) => feature.getAttribute("android:name"));
+    }
+    #hasFeatureInAndroid(feature) {
+      return this.#getFeaturesInAndroid().includes(feature);
+    }
+    #setPermissionsInAndroid(permissions) {
+      for (const permission of permissions) {
+        if (this.#hasPermissionInAndroid(permission)) {
+          this.app.logger.info(`${permission} already exists in android`);
+          return this;
+        }
+        this.app.logger.info(`Adding ${permission} to android`);
+        this.project.android.getAndroidManifest().injectFragment("manifest", `<uses-permission android:name="android.permission.${permission}" />`);
+      }
+      return this;
+    }
+    #getPermissionsInAndroid() {
+      const androidManifest = this.project.android.getAndroidManifest();
+      const element = androidManifest.getDocumentElement();
+      if (!element)
+        throw new Error("manifest not found");
+      const usesPermission = element.getElementsByTagName("uses-permission");
+      return Array.from(usesPermission).map((permission) => permission.getAttribute("android:name"));
+    }
+    #hasPermissionInAndroid(permission) {
+      return this.#getPermissionsInAndroid().includes(permission);
+    }
+  };
+
+  // pkgs/@akanjs/devkit/src/extractDeps.ts
+  var fs11 = __toESM(__require("fs"));
+  var NODE_NATIVE_MODULE_SET = /* @__PURE__ */ new Set([
+    "assert",
+    "async_hooks",
+    "buffer",
+    "child_process",
+    "cluster",
+    "console",
+    "constants",
+    "crypto",
+    "dgram",
+    "dns",
+    "domain",
+    "events",
+    "fs",
+    "http",
+    "http2",
+    "https",
+    "inspector",
+    "module",
+    "net",
+    "os",
+    "path",
+    "perf_hooks",
+    "process",
+    "punycode",
+    "querystring",
+    "readline",
+    "repl",
+    "stream",
+    "string_decoder",
+    "timers",
+    "tls",
+    "trace_events",
+    "tty",
+    "url",
+    "util",
+    "v8",
+    "vm",
+    "wasi",
+    "worker_threads",
+    "zlib"
+  ]);
+  var extractDependencies = (bundlePath, pacakgeJson, defaultDependencies = []) => {
+    if (!pacakgeJson.dependencies)
+      throw new Error("No dependencies found in package.json");
+    const code = fs11.readFileSync(bundlePath, "utf8");
+    const dependencies = new Set(defaultDependencies);
+    const existingDependencies = /* @__PURE__ */ new Set([
+      ...Object.keys(pacakgeJson.dependencies ?? {}),
+      ...Object.keys(pacakgeJson.devDependencies ?? {})
+    ]);
+    const versionObj = {
+      ...pacakgeJson.dependencies ?? {},
+      ...pacakgeJson.devDependencies ?? {}
+    };
+    const requireRegex = /require\s*\(\s*['"`]([^'"`]+)['"`]\s*\)/g;
+    let requireMatch;
+    while ((requireMatch = requireRegex.exec(code)) !== null) {
+      const moduleName = requireMatch[1];
+      const moduleNameParts = moduleName.split("/");
+      const subModuleLength = moduleNameParts.length;
+      for (let i = 0; i < subModuleLength; i++) {
+        const libName = moduleNameParts.slice(0, i + 1).join("/");
+        if (!NODE_NATIVE_MODULE_SET.has(libName) && existingDependencies.has(libName))
+          dependencies.add(libName);
+      }
+    }
+    return Object.fromEntries(
+      [...dependencies].sort().map((dep) => {
+        const version = versionObj[dep];
+        if (!version)
+          throw new Error(`No version found for ${dep}`);
+        return [dep, version];
+      })
+    );
+  };
+
+  // pkgs/@akanjs/devkit/src/commandDecorators/argMeta.ts
+  var import_reflect_metadata = __require("reflect-metadata");
+  var argTypes = ["Option"];
+  var internalArgTypes = ["Workspace", "App", "Lib", "Sys", "Pkg"];
+  var getArgMetas = (command, key) => {
+    const allArgMetas = getArgMetasOnPrototype(command.prototype, key);
+    const argMetas = allArgMetas.filter((argMeta) => argMeta.type === "Option");
+    const internalArgMetas = allArgMetas.filter((argMeta) => argMeta.type !== "Option");
+    return [allArgMetas, argMetas, internalArgMetas];
+  };
+  var getArgMetasOnPrototype = (prototype, key) => {
+    return Reflect.getMetadata("args", prototype, key) ?? [];
+  };
+  var setArgMetasOnPrototype = (prototype, key, argMetas) => {
+    Reflect.defineMetadata("args", argMetas, prototype, key);
+  };
+  var getArg = (type) => function(name, argsOption = {}) {
+    return function(prototype, key, idx) {
+      const argMetas = getArgMetasOnPrototype(prototype, key);
+      argMetas[idx] = { name, argsOption, key, idx, type };
+      setArgMetasOnPrototype(prototype, key, argMetas);
+    };
+  };
+  var Option = getArg("Option");
+  var createArgMetaDecorator = (type) => {
+    return function(option = {}) {
+      return function(prototype, key, idx) {
+        const argMetas = getArgMetasOnPrototype(prototype, key);
+        argMetas[idx] = { key, idx, type, option };
+        setArgMetasOnPrototype(prototype, key, argMetas);
+      };
+    };
+  };
+  var App = createArgMetaDecorator("App");
+  var Lib = createArgMetaDecorator("Lib");
+  var Sys = createArgMetaDecorator("Sys");
+  var Pkg = createArgMetaDecorator("Pkg");
+  var Workspace = createArgMetaDecorator("Workspace");
+
+  // pkgs/@akanjs/devkit/src/commandDecorators/commandMeta.ts
+  var Commands = () => {
+    return function(target) {
+    };
+  };
+
+  // pkgs/@akanjs/devkit/src/commandDecorators/targetMeta.ts
+  var getTargetMetas = (command) => {
+    const targetMetaMap = Reflect.getMetadata("target", command.prototype);
+    if (!targetMetaMap)
+      throw new Error(`TargetMeta is not defined for ${command.name}`);
+    return [...targetMetaMap.values()];
+  };
+  var getTargetMetaMapOnPrototype = (prototype) => {
+    const targetMetaMap = Reflect.getMetadata("target", prototype);
+    return targetMetaMap ?? /* @__PURE__ */ new Map();
+  };
+  var setTargetMetaMapOnPrototype = (prototype, targetMetaMap) => {
+    Reflect.defineMetadata("target", targetMetaMap, prototype);
+  };
+  var getTarget = (type) => (targetOption = {}) => {
+    return (prototype, key, descriptor) => {
+      const metadataMap = getTargetMetaMapOnPrototype(prototype);
+      metadataMap.set(key, {
+        key,
+        descriptor,
+        targetOption: { ...targetOption, type }
+      });
+      setTargetMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var Target = {
+    Public: getTarget("public"),
+    Cloud: getTarget("cloud"),
+    Dev: getTarget("dev")
+  };
+
+  // pkgs/@akanjs/devkit/src/commandDecorators/command.ts
+  var import_prompts3 = __require("@inquirer/prompts");
+  var import_commander = __require("commander");
+  var camelToKebabCase = (str) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
+  var handleOption = (programCommand, argMeta) => {
+    const {
+      type,
+      flag = argMeta.name.slice(0, 1).toLowerCase(),
+      desc = argMeta.name,
+      example,
+      enum: choices,
+      ask
+    } = argMeta.argsOption;
+    const kebabName = camelToKebabCase(argMeta.name);
+    programCommand.option(
+      `-${flag}, --${kebabName} <${kebabName}>`,
+      `${desc}${ask ? ` (${ask})` : ""}${example ? ` (example: ${example})` : ""}${choices ? ` (choices: ${choices.join(", ")})` : ""}`
+    );
+    return programCommand;
+  };
+  var convertOptionValue = (value, type) => {
+    if (type === "string")
+      return value;
+    else if (type === "number")
+      return Number(value);
+    else
+      return value === "true";
+  };
+  var getOptionValue = async (argMeta, opt) => {
+    const {
+      name,
+      argsOption: { enum: choices, default: defaultValue, type, desc, nullable, example, ask }
+    } = argMeta;
+    if (opt[argMeta.name] !== void 0)
+      return convertOptionValue(opt[argMeta.name], type ?? "string");
+    else if (defaultValue !== void 0)
+      return defaultValue;
+    else if (nullable)
+      return null;
+    if (choices) {
+      const choice = await (0, import_prompts3.select)({
+        message: ask ?? `Select the ${name} value`,
+        choices: choices.map((choice2) => choice2.toString())
+      });
+      return choice;
+    } else if (type === "boolean") {
+      const message = ask ?? `Do you want to set ${name}? ${desc ? ` (${desc})` : ""}: `;
+      return await (0, import_prompts3.confirm)({ message });
+    } else {
+      const message = ask ?? `Enter the ${name} value${example ? ` (example: ${example})` : ""}: `;
+      if (argMeta.argsOption.nullable)
+        return await (0, import_prompts3.input)({ message });
+      else
+        return convertOptionValue(await (0, import_prompts3.input)({ message }), type ?? "string");
+    }
+  };
+  var getArgumentValue = async (argMeta, value, workspace) => {
+    if (argMeta.type === "Workspace")
+      return workspace;
+    const sysType = argMeta.type.toLowerCase();
+    if (sysType === "sys") {
+      const [appNames, libNames] = await workspace.getSyss();
+      const sysName = await (0, import_prompts3.select)({
+        message: `Select the App or Lib name`,
+        choices: [...appNames, ...libNames]
+      });
+      if (appNames.includes(sysName))
+        return AppExecutor.from(workspace, sysName);
+      else
+        return LibExecutor.from(workspace, sysName);
+    } else if (sysType === "app") {
+      if (value)
+        return AppExecutor.from(workspace, value);
+      const apps = await workspace.getApps();
+      const appName2 = await (0, import_prompts3.select)({ message: `Select the ${sysType} name`, choices: apps });
+      return AppExecutor.from(workspace, appName2);
+    } else if (sysType === "lib") {
+      if (value)
+        return LibExecutor.from(workspace, value);
+      const libs = await workspace.getLibs();
+      const libName = await (0, import_prompts3.select)({ message: `Select the ${sysType} name`, choices: libs });
+      return LibExecutor.from(workspace, libName);
+    } else if (sysType === "pkg") {
+      if (value)
+        return PkgExecutor.from(workspace, value);
+      const pkgs = await workspace.getPkgs();
+      const pkgName = await (0, import_prompts3.select)({ message: `Select the ${sysType} name`, choices: pkgs });
+      return PkgExecutor.from(workspace, pkgName);
+    } else
+      throw new Error(`Invalid system type: ${argMeta.type}`);
+  };
+  var runCommands = async (...commands) => {
+    import_commander.program.version("0.0.1").description("An example CLI for managing a directory");
+    for (const command of commands) {
+      const targetMetas = getTargetMetas(command);
+      for (const targetMeta of targetMetas) {
+        const kebabKey = camelToKebabCase(targetMeta.key);
+        const commandNames = targetMeta.targetOption.short === true ? [
+          kebabKey,
+          typeof targetMeta.targetOption.short === "string" ? targetMeta.targetOption.short : kebabKey.split("-").map((s) => s.slice(0, 1)).join("")
+        ] : [kebabKey];
+        for (const commandName of commandNames) {
+          let programCommand = import_commander.program.command(commandName, {
+            hidden: targetMeta.targetOption.devOnly
+          });
+          const [allArgMetas] = getArgMetas(command, targetMeta.key);
+          for (const argMeta of allArgMetas) {
+            if (argMeta.type === "Option")
+              programCommand = handleOption(programCommand, argMeta);
+            else if (argMeta.type === "Workspace")
+              continue;
+            const sysType = argMeta.type.toLowerCase();
+            programCommand = programCommand.argument(
+              `[${sysType}]`,
+              `${sysType} in this workspace ${sysType}s/<${sysType}Name>`
+            );
+          }
+          programCommand.action(async (...args) => {
+            const cmdArgs = args.slice(0, args.length - 2);
+            const opt = args[args.length - 2];
+            const commandArgs = [];
+            const workspace = WorkspaceExecutor.fromRoot();
+            for (const argMeta of allArgMetas) {
+              if (argMeta.type === "Option")
+                commandArgs[argMeta.idx] = await getOptionValue(argMeta, opt);
+              else
+                commandArgs[argMeta.idx] = await getArgumentValue(argMeta, cmdArgs[argMeta.idx], workspace);
+            }
+            const cmd = new command();
+            await cmd[targetMeta.key](...commandArgs);
+          });
+        }
+      }
+    }
+    await import_commander.program.parseAsync(process.argv);
+  };
+
+  // pkgs/@akanjs/devkit/src/installExternalLib.ts
+  var installExternalLib = async (libName, workspace) => {
+    workspace.log(`Installing ${libName} library as git subtree...`);
+    await workspace.exec(`git remote add ${libName} git@github.com:akan-team/${libName}.git`);
+    await workspace.exec(`git subtree add --prefix=libs/${libName} ${libName} main`);
+  };
+})();
+//!Field.Prop 거르기가 빡세네.
+//! Temp