@akanjs/devkit 0.0.32

package/src/getModelFileData.js

@@ -0,0 +1,66 @@
+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 __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 = (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
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getModelFileData
+});

package/src/getRelatedCnsts.d.ts

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

package/src/getRelatedCnsts.js

@@ -0,0 +1,142 @@
+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 __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 = (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);
+    }
+    visit(source);
+    return propertyMap;
+  }
+  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;
+    }
+    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 };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getRelatedCnsts
+});

package/src/getScriptExecutor.d.ts

@@ -0,0 +1,13 @@
+export interface AppInfo {
+    appName: string;
+    projectConfig: any;
+}
+export interface LibInfo {
+    libName: string;
+    projectConfig: any;
+}
+export declare const getScriptExecutor: () => {
+    apps: AppInfo[];
+    libs: LibInfo[];
+    workspaceRoot: string;
+};

package/src/getScriptExecutor.js

@@ -0,0 +1,73 @@
+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 __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 getScriptExecutor_exports = {};
+__export(getScriptExecutor_exports, {
+  getScriptExecutor: () => getScriptExecutor
+});
+module.exports = __toCommonJS(getScriptExecutor_exports);
+var fs = __toESM(require("fs"));
+const getScriptExecutor = () => {
+  const workspaceRoot = process.cwd();
+  const apps = fs.readdirSync(`${workspaceRoot}/apps`).filter((appName) => {
+    const isDirectory = fs.lstatSync(`${workspaceRoot}/apps/${appName}`).isDirectory();
+    if (!isDirectory)
+      return false;
+    const hasProjectJson = fs.existsSync(`${workspaceRoot}/apps/${appName}/project.json`);
+    if (!hasProjectJson)
+      return false;
+    return true;
+  }).map((appName) => {
+    const projectConfig = JSON.parse(
+      fs.readFileSync(`${workspaceRoot}/apps/${appName}/project.json`, "utf8")
+    );
+    return { appName, projectConfig };
+  });
+  const libs = fs.readdirSync(`${workspaceRoot}/libs`).filter((libName) => {
+    const isDirectory = fs.lstatSync(`${workspaceRoot}/libs/${libName}`).isDirectory();
+    if (!isDirectory)
+      return false;
+    const hasProjectJson = fs.existsSync(`${workspaceRoot}/libs/${libName}/project.json`);
+    if (!hasProjectJson)
+      return false;
+    return true;
+  }).map((libName) => {
+    const projectConfig = JSON.parse(
+      fs.readFileSync(`${workspaceRoot}/libs/${libName}/project.json`, "utf8")
+    );
+    return { libName, projectConfig };
+  });
+  return {
+    apps,
+    libs,
+    workspaceRoot
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getScriptExecutor
+});

package/src/index.d.ts

@@ -0,0 +1,14 @@
+export * from "./addText";
+export * from "./createTunnel";
+export * from "./explicitPackages";
+export * from "./getCredentials";
+export * from "./getDependencies";
+export * from "./getExecutor";
+export * from "./getScriptExecutor";
+export * from "./makeDocker";
+export * from "./syncAssets";
+export * from "./uploadRelease";
+export * from "./getModelFileData";
+export * from "./getRelatedCnsts";
+export * from "./selectModel";
+export * from "./streamAi";

package/src/index.js

@@ -0,0 +1,47 @@
+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("./addText"), module.exports);
+__reExport(src_exports, require("./createTunnel"), module.exports);
+__reExport(src_exports, require("./explicitPackages"), module.exports);
+__reExport(src_exports, require("./getCredentials"), module.exports);
+__reExport(src_exports, require("./getDependencies"), module.exports);
+__reExport(src_exports, require("./getExecutor"), module.exports);
+__reExport(src_exports, require("./getScriptExecutor"), module.exports);
+__reExport(src_exports, require("./makeDocker"), module.exports);
+__reExport(src_exports, require("./syncAssets"), 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);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./addText"),
+  ...require("./createTunnel"),
+  ...require("./explicitPackages"),
+  ...require("./getCredentials"),
+  ...require("./getDependencies"),
+  ...require("./getExecutor"),
+  ...require("./getScriptExecutor"),
+  ...require("./makeDocker"),
+  ...require("./syncAssets"),
+  ...require("./uploadRelease"),
+  ...require("./getModelFileData"),
+  ...require("./getRelatedCnsts"),
+  ...require("./selectModel"),
+  ...require("./streamAi")
+});

package/src/makeDocker.d.ts

@@ -0,0 +1,8 @@
+interface MakeDockerParams {
+    workspaceRoot: string;
+    projectName: string;
+    repoName: string;
+    serveDomain: string;
+}
+export declare const makeDocker: (type: "backend" | "frontend", branch: "debug" | "develop" | "main", { workspaceRoot, projectName, repoName, serveDomain }: MakeDockerParams) => void;
+export {};

package/src/makeDocker.js

@@ -0,0 +1,61 @@
+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 __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 makeDocker_exports = {};
+__export(makeDocker_exports, {
+  makeDocker: () => makeDocker
+});
+module.exports = __toCommonJS(makeDocker_exports);
+var import_fs = __toESM(require("fs"));
+const makeDocker = (type, branch, { workspaceRoot, projectName, repoName, serveDomain }) => {
+  const dockerfileStr = `FROM ${type === "backend" ? "node:22-slim" : "node:22-alpine"}
+RUN ln -sf /usr/share/zoneinfo/Asia/Seoul /etc/localtime
+${type === "backend" ? `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 apk --no-cache add git"}
+RUN mkdir -p /workspace
+WORKDIR /workspace
+COPY ./package.json ./package.json
+RUN npx pnpm i --prod
+COPY . .
+ENV PORT ${type === "backend" ? "8080" : "4200"}
+ENV NODE_OPTIONS=--max_old_space_size=8192
+ENV NEXT_PUBLIC_REPO_NAME=${repoName}
+ENV NEXT_PUBLIC_SERVE_DOMAIN=${serveDomain}
+ENV NEXT_PUBLIC_APP_NAME=${projectName}
+ENV NEXT_PUBLIC_ENV=${branch}
+ENV NEXT_PUBLIC_OPERATION_MODE=cloud
+CMD ${type === "backend" ? `["node", "main.js"]` : "npm start"}`;
+  import_fs.default.writeFileSync(`${workspaceRoot}/dist/apps/${projectName}/${type}/Dockerfile`, dockerfileStr);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  makeDocker
+});

package/src/selectModel.d.ts

@@ -0,0 +1 @@
+export declare const selectModel: (modulePath: string) => Promise<string>;

package/src/selectModel.js

@@ -0,0 +1,46 @@
+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 __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 selectModel_exports = {};
+__export(selectModel_exports, {
+  selectModel: () => selectModel
+});
+module.exports = __toCommonJS(selectModel_exports);
+var import_prompts = require("@inquirer/prompts");
+var import_fs = __toESM(require("fs"));
+const selectModel = async (modulePath) => {
+  const modelNames = import_fs.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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  selectModel
+});

package/src/streamAi.d.ts

@@ -0,0 +1,6 @@
+interface StreamResponse {
+    content: string;
+    chunk?: string;
+}
+export declare const streamAi: (question: string, callback: (chunk: string) => void) => Promise<StreamResponse>;
+export {};

package/src/streamAi.js

@@ -0,0 +1,60 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 streamAi_exports = {};
+__export(streamAi_exports, {
+  streamAi: () => streamAi
+});
+module.exports = __toCommonJS(streamAi_exports);
+var import_prompts = require("@langchain/core/prompts");
+var import_runnables = require("@langchain/core/runnables");
+var import_openai = require("@langchain/openai");
+const 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_prompts.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");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  streamAi
+});

package/src/syncAssets.d.ts

@@ -0,0 +1,7 @@
+interface SyncAssetsParams {
+    workspaceRoot: string;
+    projectRoot: string;
+    libDeps: string[];
+}
+export declare const syncAssets: ({ workspaceRoot, projectRoot, libDeps }: SyncAssetsParams) => Promise<void>;
+export {};

package/src/syncAssets.js

@@ -0,0 +1,52 @@
+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 __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 syncAssets_exports = {};
+__export(syncAssets_exports, {
+  syncAssets: () => syncAssets
+});
+module.exports = __toCommonJS(syncAssets_exports);
+var import_fs = __toESM(require("fs"));
+var import_promises = __toESM(require("fs/promises"));
+const syncAssets = async ({ workspaceRoot, projectRoot, libDeps }) => {
+  const projectPublicLibPath = `${workspaceRoot}/${projectRoot}/public/libs`;
+  if (import_fs.default.existsSync(projectPublicLibPath))
+    await import_promises.default.rm(projectPublicLibPath, { recursive: true });
+  const targetDeps = libDeps.filter((dep) => import_fs.default.existsSync(`${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(`${workspaceRoot}/libs/${dep}/public`, `${projectPublicLibPath}/${dep}`, {
+        recursive: true
+      })
+    )
+  );
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  syncAssets
+});

package/src/uploadRelease.d.ts

@@ -0,0 +1,9 @@
+export declare const uploadRelease: (projectName: string, { workspaceRoot, branch, buildNum, platformVersion, local, }: {
+    workspaceRoot: string;
+    branch: "debug" | "develop" | "main";
+    buildNum: number;
+    platformVersion?: string;
+    local?: boolean;
+}) => Promise<{
+    id: string;
+} | null>;