@akanjs/devkit 0.0.39 → 0.0.40

package/src/extractDeps.d.ts

@@ -0,0 +1,7 @@
+import { PackageJson } from './types.js';
+
+declare const extractDependencies: (bundlePath: string, pacakgeJson: PackageJson, defaultDependencies?: string[]) => {
+    [k: string]: string;
+};
+
+export { extractDependencies };

package/src/extractDeps.js

@@ -0,0 +1,114 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var extractDeps_exports = {};
+__export(extractDeps_exports, {
+  extractDependencies: () => extractDependencies
+});
+module.exports = __toCommonJS(extractDeps_exports);
+var fs = __toESM(require("fs"));
+const 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"
+]);
+const extractDependencies = /* @__PURE__ */ __name((bundlePath, pacakgeJson, defaultDependencies = []) => {
+  if (!pacakgeJson.dependencies) throw new Error("No dependencies found in package.json");
+  const code = fs.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
+    ];
+  }));
+}, "extractDependencies");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extractDependencies
+});

package/src/getCredentials.d.ts

@@ -0,0 +1,18 @@
+import { AppExecutor } from './executors.js';
+import 'next';
+import 'child_process';
+import './types.js';
+
+interface AppSecret {
+    mongo: {
+        account: {
+            user: {
+                username: string;
+                password: string;
+            };
+        };
+    };
+}
+declare const getCredentials: (app: AppExecutor, environment: string) => AppSecret;
+
+export { type AppSecret, getCredentials };

package/src/getCredentials.js

@@ -0,0 +1,43 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getCredentials_exports = {};
+__export(getCredentials_exports, {
+  getCredentials: () => getCredentials
+});
+module.exports = __toCommonJS(getCredentials_exports);
+var import_fs = __toESM(require("fs"));
+var import_js_yaml = __toESM(require("js-yaml"));
+const getCredentials = /* @__PURE__ */ __name((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];
+}, "getCredentials");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCredentials
+});

package/src/getDependencies.d.ts

@@ -0,0 +1,6 @@
+declare const getDependencies: (projectName: string) => Promise<{
+    libDeps: string[];
+    npmDeps: string[];
+}>;
+
+export { getDependencies };

package/src/getDependencies.js

@@ -0,0 +1,67 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getDependencies_exports = {};
+__export(getDependencies_exports, {
+  getDependencies: () => getDependencies
+});
+module.exports = __toCommonJS(getDependencies_exports);
+var import_devkit = require("@nx/devkit");
+const addLibDepSet = /* @__PURE__ */ __name((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
+      });
+    }
+  }
+}, "addLibDepSet");
+const getDependencies = /* @__PURE__ */ __name(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:", ""))
+  };
+}, "getDependencies");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDependencies
+});

package/src/getModelFileData.d.ts

@@ -0,0 +1,17 @@
+interface ModelFileData {
+    moduleType: "lib" | "app";
+    moduleName: string;
+    modelName: string;
+    constantFilePath: string;
+    importModelNames: string[];
+    hasImportScalar: boolean;
+    importLibNames: string[];
+    constantFileStr: string;
+    unitFilePath: string;
+    unitFileStr: string;
+    viewFilePath: string;
+    viewFileStr: string;
+}
+declare const getModelFileData: (modulePath: string, modelName: string) => ModelFileData;
+
+export { getModelFileData };

package/src/getModelFileData.js

@@ -0,0 +1,67 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getModelFileData_exports = {};
+__export(getModelFileData_exports, {
+  getModelFileData: () => getModelFileData
+});
+module.exports = __toCommonJS(getModelFileData_exports);
+var import_fs = __toESM(require("fs"));
+const getModelFileData = /* @__PURE__ */ __name((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_fs.default.readFileSync(constantFilePath, "utf8");
+  const unitFileStr = import_fs.default.readFileSync(unitFilePath, "utf8");
+  const viewFileStr = import_fs.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((path) => path.split("/")[1]).filter((name) => !name.startsWith("_"));
+  const hasImportScalar = !!importLocalPaths.map((path) => path.split("/")[1]).filter((name) => name.startsWith("_")).length;
+  return {
+    moduleType,
+    moduleName,
+    modelName,
+    constantFilePath,
+    unitFilePath,
+    viewFilePath,
+    importModelNames,
+    hasImportScalar,
+    importLibNames,
+    constantFileStr,
+    unitFileStr,
+    viewFileStr
+  };
+}, "getModelFileData");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getModelFileData
+});

package/src/getRelatedCnsts.d.ts

@@ -0,0 +1,11 @@
+declare const getRelatedCnsts: (constantFilePath: string) => {
+    paths: Map<string, {
+        filePath: string;
+        isLibModule: boolean;
+        isImport: boolean;
+        isScalar: boolean;
+        libName?: string;
+    }> | null;
+};
+
+export { getRelatedCnsts };

package/src/getRelatedCnsts.js

@@ -0,0 +1,145 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var getRelatedCnsts_exports = {};
+__export(getRelatedCnsts_exports, {
+  getRelatedCnsts: () => getRelatedCnsts
+});
+module.exports = __toCommonJS(getRelatedCnsts_exports);
+var import_fs = __toESM(require("fs"));
+var import_ora = __toESM(require("ora"));
+var ts = __toESM(require("typescript"));
+const getRelatedCnsts = /* @__PURE__ */ __name((constantFilePath) => {
+  const tsConfigPath = `./tsconfig.json`;
+  const configFile = ts.readConfigFile(tsConfigPath, (path) => {
+    return ts.sys.readFile(path);
+  });
+  const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, import_fs.default.realpathSync(tsConfigPath).replace(/[^/\\]+$/, ""));
+  const propertyMap = /* @__PURE__ */ new Map();
+  function findPropertyOriginAll(filePath) {
+    const program = ts.createProgram([
+      filePath
+    ], parsedConfig.options);
+    const checker = program.getTypeChecker();
+    const source = program.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());
+        //!Field.Prop 거르기가 빡세네.
+        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);
+    }
+    __name(visit, "visit");
+    visit(source);
+    return propertyMap;
+  }
+  __name(findPropertyOriginAll, "findPropertyOriginAll");
+  function findPropertyOrigin(filePath, aliasName, libName) {
+    const program = ts.createProgram([
+      filePath
+    ], parsedConfig.options);
+    const checker = program.getTypeChecker();
+    const source = program.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;
+    }
+    __name(visit, "visit");
+    return visit(source);
+  }
+  __name(findPropertyOrigin, "findPropertyOrigin");
+  const spinner = (0, import_ora.default)("Finding property origin...");
+  spinner.start();
+  const paths = findPropertyOriginAll(constantFilePath);
+  spinner.succeed("property origin found.");
+  return {
+    paths
+  };
+}, "getRelatedCnsts");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRelatedCnsts
+});

package/src/index.d.ts

@@ -0,0 +1,101 @@
+export { baseDevEnv, getSshTunnelOptions } from './baseDevEnv.js';
+export { createTunnel } from './createTunnel.js';
+export { AppSecret, getCredentials } from './getCredentials.js';
+export { getDependencies } from './getDependencies.js';
+export { uploadRelease } from './uploadRelease.js';
+export { getModelFileData } from './getModelFileData.js';
+export { getRelatedCnsts } from './getRelatedCnsts.js';
+export { selectModel } from './selectModel.js';
+export { streamAi } from './streamAi.js';
+import { AppExecutor, LibExecutor, SysExecutor, PkgExecutor, WorkspaceExecutor } from './executors.js';
+export { DistAppExecutor, DistLibExecutor, DistPkgExecutor, Executor } from './executors.js';
+export { TypeScriptDependencyScanner } from './dependencyScanner.js';
+export { AkanGlobalConfig, HostConfig, akanCloudBackendUrl, akanCloudClientUrl, akanCloudHost, basePath, configPath, defaultAkanGlobalConfig, defaultHostConfig } from './constants.js';
+export { getAkanGlobalConfig, getHostConfig, getSelf, setAkanGlobalConfig, setHostConfig } from './auth.js';
+export { PackageJson, TsConfigJson } from './types.js';
+export { CapacitorApp } from './capacitorApp.js';
+export { extractDependencies } from './extractDeps.js';
+export { installExternalLib } from './installExternalLib.js';
+import 'tunnel-ssh';
+import 'next';
+import 'child_process';
+import '@trapezedev/project';
+import '@trapezedev/project/dist/android/project';
+import '@trapezedev/project/dist/ios/project';
+
+type Type<T = any> = new (...args: any[]) => T;
+
+declare const argTypes: readonly ["Option"];
+type ArgType = (typeof argTypes)[number];
+declare const internalArgTypes: readonly ["Workspace", "App", "Lib", "Sys", "Pkg"];
+type InternalArgType = (typeof internalArgTypes)[number];
+interface ArgsOption {
+    type?: "string" | "number" | "boolean";
+    flag?: string;
+    desc?: string;
+    default?: string | number | boolean;
+    nullable?: boolean;
+    example?: string | number | boolean;
+    enum?: (string | number)[] | readonly (string | number)[];
+    ask?: string;
+}
+interface ArgMeta {
+    name: string;
+    argsOption: ArgsOption;
+    key: string;
+    idx: number;
+    type: ArgType;
+}
+interface InternalArgMeta {
+    key: string;
+    idx: number;
+    type: InternalArgType;
+    option?: {
+        nullable?: boolean;
+    };
+}
+declare const getArgMetas: (command: Type, key: string) => [(ArgMeta | InternalArgMeta)[], ArgMeta[], InternalArgMeta[]];
+declare const Option: (name: string, argsOption?: ArgsOption) => (prototype: object, key: string, idx: number) => void;
+declare const App: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+type App = AppExecutor;
+declare const Lib: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+type Lib = LibExecutor;
+declare const Sys: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+type Sys = SysExecutor;
+declare const Pkg: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+type Pkg = PkgExecutor;
+declare const Workspace: (option?: {
+    nullable?: boolean;
+}) => (prototype: object, key: string, idx: number) => void;
+type Workspace = WorkspaceExecutor;
+
+declare const Commands: () => (target: Type) => void;
+
+interface TargetMeta {
+    key: string;
+    descriptor: PropertyDescriptor;
+    targetOption: TargetOption;
+}
+declare const getTargetMetas: (command: Type) => TargetMeta[];
+interface TargetOption {
+    type: "public" | "cloud" | "dev";
+    short?: string | true;
+    devOnly?: boolean;
+}
+declare const Target: {
+    Public: (targetOption?: Omit<TargetOption, "type">) => (prototype: object, key: string, descriptor: PropertyDescriptor) => void;
+    Cloud: (targetOption?: Omit<TargetOption, "type">) => (prototype: object, key: string, descriptor: PropertyDescriptor) => void;
+    Dev: (targetOption?: Omit<TargetOption, "type">) => (prototype: object, key: string, descriptor: PropertyDescriptor) => void;
+};
+
+declare const runCommands: (...commands: Type[]) => Promise<void>;
+
+export { App, AppExecutor, type ArgMeta, type ArgType, Commands, type InternalArgMeta, type InternalArgType, Lib, LibExecutor, Option, Pkg, PkgExecutor, Sys, SysExecutor, Target, type Type, Workspace, WorkspaceExecutor, argTypes, getArgMetas, getTargetMetas, internalArgTypes, runCommands };

package/src/index.js

@@ -0,0 +1,55 @@
+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 src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./baseDevEnv"), module.exports);
+__reExport(src_exports, require("./createTunnel"), module.exports);
+__reExport(src_exports, require("./getCredentials"), module.exports);
+__reExport(src_exports, require("./getDependencies"), module.exports);
+__reExport(src_exports, require("./uploadRelease"), module.exports);
+__reExport(src_exports, require("./getModelFileData"), module.exports);
+__reExport(src_exports, require("./getRelatedCnsts"), module.exports);
+__reExport(src_exports, require("./selectModel"), module.exports);
+__reExport(src_exports, require("./streamAi"), module.exports);
+__reExport(src_exports, require("./executors"), module.exports);
+__reExport(src_exports, require("./dependencyScanner"), module.exports);
+__reExport(src_exports, require("./constants"), module.exports);
+__reExport(src_exports, require("./auth"), module.exports);
+__reExport(src_exports, require("./types"), module.exports);
+__reExport(src_exports, require("./capacitorApp"), module.exports);
+__reExport(src_exports, require("./extractDeps"), module.exports);
+__reExport(src_exports, require("./commandDecorators"), module.exports);
+__reExport(src_exports, require("./installExternalLib"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./baseDevEnv"),
+  ...require("./createTunnel"),
+  ...require("./getCredentials"),
+  ...require("./getDependencies"),
+  ...require("./uploadRelease"),
+  ...require("./getModelFileData"),
+  ...require("./getRelatedCnsts"),
+  ...require("./selectModel"),
+  ...require("./streamAi"),
+  ...require("./executors"),
+  ...require("./dependencyScanner"),
+  ...require("./constants"),
+  ...require("./auth"),
+  ...require("./types"),
+  ...require("./capacitorApp"),
+  ...require("./extractDeps"),
+  ...require("./commandDecorators"),
+  ...require("./installExternalLib")
+});

package/src/installExternalLib.d.ts

@@ -0,0 +1,8 @@
+import { WorkspaceExecutor } from './executors.js';
+import 'next';
+import 'child_process';
+import './types.js';
+
+declare const installExternalLib: (libName: string, workspace: WorkspaceExecutor) => Promise<void>;
+
+export { installExternalLib };