@akanjs/devkit 0.0.143 → 0.0.145

package/cjs/src/linter.js

@@ -0,0 +1,238 @@
+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 linter_exports = {};
+__export(linter_exports, {
+  Linter: () => Linter
+});
+module.exports = __toCommonJS(linter_exports);
+var import_common = require("@akanjs/common");
+var import_chalk = __toESM(require("chalk"));
+var import_eslint = require("eslint");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+class Linter {
+  #logger = new import_common.Logger("Linter");
+  #eslint;
+  lintRoot;
+  constructor(cwdPath) {
+    this.lintRoot = this.#findEslintRootPath(cwdPath);
+    this.#eslint = new import_eslint.ESLint({ cwd: this.lintRoot, errorOnUnmatchedPattern: false });
+  }
+  #findEslintRootPath(dir) {
+    const configPath = path.join(dir, "eslint.config.ts");
+    if (fs.existsSync(configPath))
+      return dir;
+    const parentDir = path.dirname(dir);
+    return this.#findEslintRootPath(parentDir);
+  }
+  async lint(filePath, { fix = false, dryRun = false } = {}) {
+    if (fix)
+      return await this.fixFile(filePath, dryRun);
+    return await this.lintFile(filePath);
+  }
+  /**
+   * Lint a single file using ESLint
+   * @param filePath - Path to the file to lint
+   * @returns Array of ESLint results
+   */
+  async lintFile(filePath) {
+    if (!fs.existsSync(filePath))
+      throw new Error(`File not found: ${filePath}`);
+    const isIgnored = await this.#eslint.isPathIgnored(filePath);
+    if (isIgnored) {
+      this.#logger.warn(`File ${filePath} is ignored by ESLint configuration`);
+      return { fixed: false, results: [], errors: [], warnings: [] };
+    }
+    const results = await this.#eslint.lintFiles([filePath]);
+    const errors = results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
+    const warnings = results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
+    return { fixed: false, results, errors, warnings };
+  }
+  /**
+   * Format lint results for console output
+   * @param results - Array of ESLint results
+   * @returns Formatted string
+   */
+  formatLintResults(results) {
+    if (results.length === 0)
+      return "No files to lint";
+    const output = [];
+    let totalErrors = 0;
+    let totalWarnings = 0;
+    results.forEach((result) => {
+      totalErrors += result.errorCount;
+      totalWarnings += result.warningCount;
+      if (result.messages.length > 0) {
+        output.push(`
+${import_chalk.default.cyan(result.filePath)}`);
+        let sourceLines = [];
+        if (fs.existsSync(result.filePath)) {
+          try {
+            const sourceContent = fs.readFileSync(result.filePath, "utf8");
+            sourceLines = sourceContent.split("\n");
+          } catch (error) {
+          }
+        }
+        result.messages.forEach((message) => {
+          const type = message.severity === 2 ? "error" : "warning";
+          const typeColor = message.severity === 2 ? import_chalk.default.red : import_chalk.default.yellow;
+          const icon = message.severity === 2 ? "\u274C" : "\u26A0\uFE0F";
+          const ruleInfo = message.ruleId ? import_chalk.default.dim(` (${message.ruleId})`) : "";
+          output.push(`
+  ${icon} ${typeColor(type)}: ${message.message}${ruleInfo}`);
+          output.push(`     ${import_chalk.default.gray("at")} ${result.filePath}:${import_chalk.default.bold(`${message.line}:${message.column}`)}`);
+          if (sourceLines.length > 0 && message.line <= sourceLines.length) {
+            const sourceLine = sourceLines[message.line - 1];
+            const lineNumber = message.line.toString().padStart(5, " ");
+            output.push(`
+${import_chalk.default.dim(lineNumber + " |")} ${sourceLine}`);
+            const underlinePrefix = " ".repeat(message.column - 1);
+            const underlineLength = message.endColumn ? message.endColumn - message.column : 1;
+            const underline = "^".repeat(Math.max(1, underlineLength));
+            output.push(`${import_chalk.default.dim(" ".repeat(lineNumber.length) + " |")} ${underlinePrefix}${typeColor(underline)}`);
+          }
+        });
+      }
+    });
+    if (totalErrors === 0 && totalWarnings === 0)
+      return import_chalk.default.bold("\u2705 No ESLint errors or warnings found");
+    const errorText = totalErrors > 0 ? import_chalk.default.red(`${totalErrors} error(s)`) : "0 errors";
+    const warningText = totalWarnings > 0 ? import_chalk.default.yellow(`${totalWarnings} warning(s)`) : "0 warnings";
+    const summary = [`
+${errorText}, ${warningText} found`];
+    return summary.concat(output).join("\n");
+  }
+  /**
+   * Get detailed lint information
+   * @param filePath - Path to the file to lint
+   * @returns Object containing detailed lint information
+   */
+  async getDetailedLintInfo(filePath) {
+    const { results } = await this.lintFile(filePath);
+    const details = results.flatMap(
+      (result) => result.messages.map((message) => ({
+        line: message.line,
+        column: message.column,
+        message: message.message,
+        ruleId: message.ruleId,
+        severity: message.severity === 2 ? "error" : "warning",
+        fix: message.fix,
+        suggestions: message.suggestions
+      }))
+    );
+    const stats = results.reduce(
+      (acc, result) => ({
+        errorCount: acc.errorCount + result.errorCount,
+        warningCount: acc.warningCount + result.warningCount,
+        fixableErrorCount: acc.fixableErrorCount + result.fixableErrorCount,
+        fixableWarningCount: acc.fixableWarningCount + result.fixableWarningCount
+      }),
+      { errorCount: 0, warningCount: 0, fixableErrorCount: 0, fixableWarningCount: 0 }
+    );
+    return { results, details, stats };
+  }
+  /**
+   * Check if a file has lint errors
+   * @param filePath - Path to the file to check
+   * @returns true if there are no errors, false otherwise
+   */
+  async hasNoLintErrors(filePath) {
+    try {
+      const { results } = await this.lintFile(filePath);
+      return results.every((result) => result.errorCount === 0);
+    } catch (error) {
+      return false;
+    }
+  }
+  /**
+   * Get only error messages (excluding warnings)
+   * @param filePath - Path to the file to lint
+   * @returns Array of error messages
+   */
+  async getErrors(filePath) {
+    const { results } = await this.lintFile(filePath);
+    return results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
+  }
+  /**
+   * Get only warning messages
+   * @param filePath - Path to the file to lint
+   * @returns Array of warning messages
+   */
+  async getWarnings(filePath) {
+    const { results } = await this.lintFile(filePath);
+    return results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
+  }
+  /**
+   * Fix lint errors automatically
+   * @param filePath - Path to the file to fix
+   * @param dryRun - If true, returns the fixed content without writing to file
+   * @returns Fixed content and remaining issues
+   */
+  async fixFile(filePath, dryRun = false) {
+    if (!fs.existsSync(filePath))
+      throw new Error(`File not found: ${filePath}`);
+    const eslint = new import_eslint.ESLint({ cwd: this.lintRoot, fix: true });
+    const results = await eslint.lintFiles([filePath]);
+    const errors = results.flatMap((result) => result.messages.filter((message) => message.severity === 2));
+    const warnings = results.flatMap((result) => result.messages.filter((message) => message.severity === 1));
+    if (!dryRun)
+      await import_eslint.ESLint.outputFixes(results);
+    const fixedResult = results[0];
+    return { fixed: fixedResult.output !== void 0, output: fixedResult.output, results, errors, warnings };
+  }
+  /**
+   * Get ESLint configuration for a file
+   * @param filePath - Path to the file
+   * @returns ESLint configuration object
+   */
+  async getConfigForFile(filePath) {
+    const eslint = new import_eslint.ESLint();
+    const config = await eslint.calculateConfigForFile(filePath);
+    return config;
+  }
+  /**
+   * Get rules that are causing errors in a file
+   * @param filePath - Path to the file to check
+   * @returns Object mapping rule IDs to their error counts
+   */
+  async getProblematicRules(filePath) {
+    const { results } = await this.lintFile(filePath);
+    const ruleCounts = {};
+    results.forEach((result) => {
+      result.messages.forEach((message) => {
+        if (message.ruleId)
+          ruleCounts[message.ruleId] = (ruleCounts[message.ruleId] || 0) + 1;
+      });
+    });
+    return ruleCounts;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Linter
+});

package/cjs/src/prompter.js

@@ -0,0 +1,78 @@
+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 prompter_exports = {};
+__export(prompter_exports, {
+  Prompter: () => Prompter
+});
+module.exports = __toCommonJS(prompter_exports);
+var import_prompts = require("@inquirer/prompts");
+var import_promises = __toESM(require("fs/promises"));
+class Prompter {
+  static async selectGuideline() {
+    const guideNames = (await import_promises.default.readdir(`${__dirname}/src/guidelines`)).filter((name) => !name.startsWith("_"));
+    return await (0, import_prompts.select)({ message: "Select a guideline", choices: guideNames.map((name) => ({ name, value: name })) });
+  }
+  static async getGuideJson(guideName) {
+    const filePath = `${__dirname}/src/guidelines/${guideName}/${guideName}.generate.json`;
+    const guideJson = await import_promises.default.readFile(filePath, "utf-8");
+    return JSON.parse(guideJson);
+  }
+  static async getInstruction(guideName) {
+    const filePath = `${__dirname}/src/guidelines/${guideName}/${guideName}.instruction.md`;
+    const content = await import_promises.default.readFile(filePath, "utf-8");
+    return content;
+  }
+  async makeTsFileUpdatePrompt({ context, request }) {
+    return `You are a senior developer writing TypeScript-based programs using Akan.js, an in-house framework. Here's an overview of the Akan.js framework:
+${await this.getDocumentation("framework")}
+Please understand the following background information, write code that meets the requirements, verify that it satisfies the validation conditions, and return the result.
+
+# Background Information
+\`\`\`markdown
+${context}
+\`\`\`
+
+# Requirements
+\`\`\`markdown
+${request}
+\`\`\`
+`;
+  }
+  async getDocumentation(guideName) {
+    const filePath = `${__dirname}/src/guidelines/${guideName}/${guideName}.instruction.md`;
+    const document = await import_promises.default.readFile(filePath, "utf-8");
+    return `\`\`\`markdown
+${document}
+\`\`\`
+`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Prompter
+});

package/cjs/src/typeChecker.js

@@ -0,0 +1,203 @@
+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 typeChecker_exports = {};
+__export(typeChecker_exports, {
+  TypeChecker: () => TypeChecker
+});
+module.exports = __toCommonJS(typeChecker_exports);
+var import_chalk = __toESM(require("chalk"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var ts = __toESM(require("typescript"));
+class TypeChecker {
+  configPath;
+  configFile;
+  config;
+  constructor(executor) {
+    const configPath = this.#findConfigFile(executor.cwdPath);
+    if (!configPath)
+      throw new Error("No tsconfig.json found in the project");
+    this.configPath = configPath;
+    this.configFile = ts.readConfigFile(this.configPath, (fileName) => ts.sys.readFile(fileName));
+    const parsedConfig = ts.parseJsonConfigFileContent(
+      this.configFile.config,
+      ts.sys,
+      path.dirname(this.configPath),
+      void 0,
+      this.configPath
+    );
+    if (parsedConfig.errors.length > 0) {
+      const errorMessages = parsedConfig.errors.map((error) => ts.flattenDiagnosticMessageText(error.messageText, "\n")).join("\n");
+      throw new Error(`Error parsing tsconfig.json:
+${errorMessages}`);
+    }
+    this.config = parsedConfig;
+  }
+  /**
+   * Find tsconfig.json by walking up the directory tree
+   */
+  #findConfigFile(searchPath) {
+    return ts.findConfigFile(searchPath, (fileName) => ts.sys.fileExists(fileName), "tsconfig.json");
+  }
+  /**
+   * Type-check a single TypeScript file
+   * @param filePath - Path to the TypeScript file to check
+   * @returns Array of diagnostic messages
+   */
+  check(filePath) {
+    const program = ts.createProgram([filePath], this.config.options);
+    const diagnostics = [
+      ...program.getSemanticDiagnostics(),
+      ...program.getSyntacticDiagnostics(),
+      ...program.getDeclarationDiagnostics()
+    ];
+    const errors = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
+    const warnings = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Warning);
+    return { diagnostics, errors, warnings };
+  }
+  /**
+   * Format diagnostics for console output
+   * @param diagnostics - Array of TypeScript diagnostics
+   * @returns Formatted string
+   */
+  formatDiagnostics(diagnostics) {
+    if (diagnostics.length === 0)
+      return import_chalk.default.bold("\u2705 No type errors found");
+    const output = [];
+    let errorCount = 0;
+    let warningCount = 0;
+    let suggestionCount = 0;
+    const diagnosticsByFile = /* @__PURE__ */ new Map();
+    diagnostics.forEach((diagnostic) => {
+      if (diagnostic.category === ts.DiagnosticCategory.Error)
+        errorCount++;
+      else if (diagnostic.category === ts.DiagnosticCategory.Warning)
+        warningCount++;
+      else if (diagnostic.category === ts.DiagnosticCategory.Suggestion)
+        suggestionCount++;
+      if (diagnostic.file) {
+        const fileName = diagnostic.file.fileName;
+        if (!diagnosticsByFile.has(fileName))
+          diagnosticsByFile.set(fileName, []);
+        const fileDiagnostics = diagnosticsByFile.get(fileName);
+        if (fileDiagnostics)
+          fileDiagnostics.push(diagnostic);
+      } else {
+        if (!diagnosticsByFile.has(""))
+          diagnosticsByFile.set("", []);
+        const fileDiagnostics = diagnosticsByFile.get("");
+        if (fileDiagnostics)
+          fileDiagnostics.push(diagnostic);
+      }
+    });
+    diagnosticsByFile.forEach((fileDiagnostics, fileName) => {
+      if (fileName)
+        output.push(`
+${import_chalk.default.cyan(fileName)}`);
+      fileDiagnostics.forEach((diagnostic) => {
+        const categoryText = diagnostic.category === ts.DiagnosticCategory.Error ? "error" : diagnostic.category === ts.DiagnosticCategory.Warning ? "warning" : "suggestion";
+        const categoryColor = diagnostic.category === ts.DiagnosticCategory.Error ? import_chalk.default.red : diagnostic.category === ts.DiagnosticCategory.Warning ? import_chalk.default.yellow : import_chalk.default.blue;
+        const icon = diagnostic.category === ts.DiagnosticCategory.Error ? "\u274C" : diagnostic.category === ts.DiagnosticCategory.Warning ? "\u26A0\uFE0F" : "\u{1F4A1}";
+        const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+        const tsCode = import_chalk.default.dim(`(TS${diagnostic.code})`);
+        if (diagnostic.file && diagnostic.start !== void 0) {
+          const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+          output.push(`
+  ${icon} ${categoryColor(categoryText)}: ${message} ${tsCode}`);
+          output.push(`     ${import_chalk.default.gray("at")} ${fileName}:${import_chalk.default.bold(`${line + 1}:${character + 1}`)}`);
+          const sourceLines = diagnostic.file.text.split("\n");
+          if (line < sourceLines.length) {
+            const sourceLine = sourceLines[line];
+            const lineNumber = (line + 1).toString().padStart(5, " ");
+            output.push(`
+${import_chalk.default.dim(lineNumber + " |")} ${sourceLine}`);
+            const underlinePrefix = " ".repeat(character);
+            const length = diagnostic.length ?? 1;
+            const underline = "~".repeat(Math.max(1, length));
+            output.push(
+              `${import_chalk.default.dim(" ".repeat(lineNumber.length) + " |")} ${underlinePrefix}${categoryColor(underline)}`
+            );
+          }
+        } else
+          output.push(`
+  ${icon} ${categoryColor(categoryText)}: ${message} ${tsCode}`);
+      });
+    });
+    const summary = [];
+    if (errorCount > 0)
+      summary.push(import_chalk.default.red(`${errorCount} error(s)`));
+    if (warningCount > 0)
+      summary.push(import_chalk.default.yellow(`${warningCount} warning(s)`));
+    if (suggestionCount > 0)
+      summary.push(import_chalk.default.blue(`${suggestionCount} suggestion(s)`));
+    return `
+${summary.join(", ")} found` + output.join("\n");
+  }
+  /**
+   * Get detailed diagnostic information with code snippet
+   * @param filePath - Path to the TypeScript file to check
+   * @returns Object containing diagnostics and detailed information
+   */
+  getDetailedDiagnostics(filePath) {
+    const { diagnostics } = this.check(filePath);
+    const sourceFile = ts.createSourceFile(filePath, fs.readFileSync(filePath, "utf8"), ts.ScriptTarget.Latest, true);
+    const details = diagnostics.map((diagnostic) => {
+      if (diagnostic.file && diagnostic.start !== void 0) {
+        const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
+        const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+        const lines = sourceFile.text.split("\n");
+        const codeSnippet = line < lines.length ? lines[line] : void 0;
+        return { line: line + 1, column: character + 1, message, code: diagnostic.code, codeSnippet };
+      }
+      return {
+        line: 0,
+        column: 0,
+        message: ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n"),
+        code: diagnostic.code
+      };
+    });
+    return { diagnostics, details };
+  }
+  /**
+   * Check if a file has type errors
+   * @param filePath - Path to the TypeScript file to check
+   * @returns true if there are no type errors, false otherwise
+   */
+  hasNoTypeErrors(filePath) {
+    try {
+      const { diagnostics } = this.check(filePath);
+      return diagnostics.length === 0;
+    } catch (error) {
+      return false;
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TypeChecker
+});

package/cjs/src/uploadRelease.js

@@ -30,52 +30,78 @@ __export(uploadRelease_exports, {
   uploadRelease: () => uploadRelease
 });
 module.exports = __toCommonJS(uploadRelease_exports);
+var import_common = require("@akanjs/common");
 var import_axios = __toESM(require("axios"));
 var import_form_data = __toESM(require("form-data"));
 var import_fs = __toESM(require("fs"));
-const uploadRelease = async (projectName, {
+var import_spinner = require("./spinner");
+const spinning = (message) => {
+  const spinner = new import_spinner.Spinner(message, { prefix: message, enableSpin: true }).start();
+  return spinner;
+};
+const uploadRelease = async (appName, {
   workspaceRoot,
   environment,
   buildNum,
   platformVersion,
   local
 }) => {
+  const logger = new import_common.Logger("uploadRelease");
   const basePath = 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_fs.default.readFileSync(buildPath);
-  const source = import_fs.default.readFileSync(sourcePath);
-  const appBuild = import_fs.default.readFileSync(appBuildPath);
-  const buildStat = import_fs.default.statSync(buildPath);
-  const sourceStat = import_fs.default.statSync(sourcePath);
-  const appBuildStat = import_fs.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");
+  const buildPath = `${workspaceRoot}/releases/builds/${appName}-release.tar.gz`;
+  const appBuildPath = `${workspaceRoot}/releases/builds/${appName}-appBuild.zip`;
+  const sourcePath = `${workspaceRoot}/releases/sources/${appName}-source.tar.gz`;
+  const readingFilesSpinner = spinning("Reading files...");
   try {
-    const [buildFile, sourceFile, appBuildFile] = (await import_axios.default.post(`${basePath}/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(
-      `${basePath}/release/findVersionRelease?appName=${projectName}&branch=${environment}&major=${major}&minor=${minor}`
+    const build = import_fs.default.readFileSync(buildPath);
+    const source = import_fs.default.readFileSync(sourcePath);
+    const appBuild = import_fs.default.readFileSync(appBuildPath);
+    const buildStat = import_fs.default.statSync(buildPath);
+    const sourceStat = import_fs.default.statSync(sourcePath);
+    const appBuildStat = import_fs.default.statSync(appBuildPath);
+    readingFilesSpinner.succeed("Reading files... done");
+    const preparingFormSpinner = spinning("Preparing form data...");
+    const formData = new import_form_data.default();
+    formData.append("files", build, `${appName}-release.tar.gz`);
+    formData.append("files", source, `${appName}-source.tar.gz`);
+    formData.append("files", appBuild, `${appName}-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 }
+      ])
     );
-    const release = (await import_axios.default.post(
-      `${basePath}/release/pushRelease/${projectName}/${environment}/${major}/${minor}/${sourceFile.id}/${buildFile.id}/${appBuildFile.id}`
-    )).data;
-    return release;
+    formData.append("type", "release");
+    preparingFormSpinner.succeed("Preparing form data... done");
+    try {
+      const uploadingFilesSpinner = spinning("Uploading files to server...");
+      const [buildFile, sourceFile, appBuildFile] = (await import_axios.default.post(`${basePath}/file/addFilesRestApi`, formData)).data;
+      uploadingFilesSpinner.succeed("Uploading files to server... done");
+      const fetchingAppSpinner = spinning(`Fetching dev app information for ${appName}...`);
+      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 devApp = (await import_axios.default.get(`${basePath}/devApp/devAppInName/${appName}`)).data;
+      fetchingAppSpinner.succeed(`Fetching dev app information for ${appName}... done`);
+      const pushingReleaseSpinner = spinning(`Pushing release to ${environment} environment...`);
+      const release = (await import_axios.default.post(
+        `${basePath}/release/pushRelease/${devApp.id}/${environment}/${major}/${minor}/${sourceFile.id}/${buildFile.id}/${appBuildFile.id}`
+      )).data;
+      pushingReleaseSpinner.succeed(`Pushing release to ${environment} environment... done`);
+      new import_spinner.Spinner(`Successfully pushed release to ${appName}-${environment} server. `, {
+        prefix: `Successfully pushed release to ${appName}-${environment} server. `,
+        enableSpin: false
+      }).succeed(`Successfully pushed release to ${appName}-${environment} server. `);
+      return release;
+    } catch (e) {
+      const errorMessage = e instanceof Error ? e.message : "Unknown error";
+      return null;
+    }
   } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : "Unknown error";
+    readingFilesSpinner.fail(`Reading files failed: ${errorMessage}`);
     return null;
   }
 };