@akanjs/cli 0.0.138 → 0.0.139

package/esm/index.js

@@ -903,28 +903,50 @@ var TypeScriptDependencyScanner = class {
 
 // pkgs/@akanjs/devkit/src/spinner.ts
 import ora2 from "ora";
-var Spinner = class {
+var Spinner = class _Spinner {
+  static padding = 12;
   spinner;
   stopWatch;
   startAt;
+  prefix;
   message;
-  constructor(message, { prefix = "", indent = 0 } = {}) {
+  enableSpin;
+  constructor(message, { prefix = "", indent = 0, enableSpin = true } = {}) {
+    _Spinner.padding = Math.max(_Spinner.padding, prefix.length);
+    this.prefix = prefix;
     this.message = message;
     this.spinner = ora2(message);
-    this.spinner.prefixText = prefix;
+    this.spinner.prefixText = prefix.padStart(_Spinner.padding, " ");
     this.spinner.indent = indent;
+    this.enableSpin = enableSpin;
   }
   start() {
     this.startAt = /* @__PURE__ */ new Date();
-    const spinner = this.spinner.start();
-    this.stopWatch = setInterval(() => {
-      spinner.text = `${this.message} (${this.#getElapsedTimeStr()})`;
-    }, 1e3);
+    if (this.enableSpin) {
+      this.spinner.start();
+      this.stopWatch = setInterval(() => {
+        this.spinner.prefixText = this.prefix.padStart(_Spinner.padding, " ");
+        this.spinner.text = `${this.message} (${this.#getElapsedTimeStr()})`;
+      }, 1e3);
+    } else
+      this.spinner.info();
     return this;
   }
   succeed(message) {
-    clearInterval(this.stopWatch);
     this.spinner.succeed(`${message} (${this.#getElapsedTimeStr()})`);
+    this.#reset();
+  }
+  fail(message) {
+    this.spinner.fail(`${message} (${this.#getElapsedTimeStr()})`);
+    this.#reset();
+  }
+  isSpinning() {
+    return this.spinner.isSpinning;
+  }
+  #reset() {
+    if (this.stopWatch)
+      clearInterval(this.stopWatch);
+    this.stopWatch = null;
   }
   #getElapsedTimeStr() {
     const ms = (/* @__PURE__ */ new Date()).getTime() - this.startAt.getTime();
@@ -948,7 +970,11 @@ var execEmoji = {
   default: "\u2708\uFE0F"
   // for sys executor
 };
-var Executor = class {
+var Executor = class _Executor {
+  static verbose = false;
+  static setVerbose(verbose) {
+    _Executor.verbose = verbose;
+  }
   name;
   logger;
   cwdPath;
@@ -978,7 +1004,11 @@ var Executor = class {
     });
   }
   spawn(command, args = [], options = {}) {
-    const proc = spawn(command, args, { cwd: this.cwdPath, stdio: "inherit", ...options });
+    const proc = spawn(command, args, {
+      cwd: this.cwdPath,
+      stdio: _Executor.verbose ? "inherit" : "ignore",
+      ...options
+    });
     proc.stdout?.on("data", (data) => {
       Logger.raw(chalk.dim(data.toString()));
     });
@@ -997,7 +1027,7 @@ var Executor = class {
   fork(modulePath, args = [], options = {}) {
     const proc = fork(modulePath, args, {
       cwd: this.cwdPath,
-      stdio: ["ignore", "inherit", "inherit", "ipc"],
+      stdio: _Executor.verbose ? ["ignore", "inherit", "inherit", "ipc"] : ["ignore", "ignore", "ignore", "ipc"],
       ...options
     });
     proc.stdout?.on("data", (data) => {
@@ -1079,8 +1109,8 @@ var Executor = class {
     this.logger.verbose(msg);
     return this;
   }
-  spinning(msg, { prefix = `${this.emoji}${this.name} -`, indent = 0 } = {}) {
-    return new Spinner(msg, { prefix, indent }).start();
+  spinning(msg, { prefix = `${this.emoji}${this.name}`, indent = 0, enableSpin = !_Executor.verbose } = {}) {
+    return new Spinner(msg, { prefix, indent, enableSpin }).start();
   }
   getTsConfig(pathname = "tsconfig.json") {
     const tsconfig = this.readJson(pathname);
@@ -1562,6 +1592,9 @@ var AppExecutor = class _AppExecutor extends SysExecutor {
       return new _AppExecutor({ workspace: executor, name });
     return new _AppExecutor({ workspace: executor.workspace, name });
   }
+  getEnv() {
+    return this.workspace.getBaseDevEnv().env;
+  }
   async getConfig(command) {
     return await getAppConfig(this.cwdPath, {
       ...this.workspace.getBaseDevEnv(),
@@ -2186,6 +2219,7 @@ var runCommands = async (...commands) => {
             `${sysType} in this workspace ${sysType}s/<${sysType}Name>`
           );
         }
+        programCommand = programCommand.option(`-v, --verbose [boolean]`, `verbose output`);
         programCommand.action(async (...args) => {
           const cmdArgs = args.slice(0, args.length - 2);
           const opt = args[args.length - 2];
@@ -2198,6 +2232,8 @@ var runCommands = async (...commands) => {
               commandArgs[argMeta.idx] = await getArgumentValue(argMeta, cmdArgs[argMeta.idx], workspace);
             if (commandArgs[argMeta.idx] instanceof AppExecutor)
               process.env.NEXT_PUBLIC_APP_NAME = commandArgs[argMeta.idx].name;
+            if (opt.verbose)
+              Executor.setVerbose(true);
           }
           const cmd = new command();
           try {
@@ -2220,7 +2256,6 @@ import { input as input2, select as select3 } from "@inquirer/prompts";
 import { AIMessage, HumanMessage } from "@langchain/core/messages";
 import { ChatOpenAI as ChatOpenAI2 } from "@langchain/openai";
 import chalk3 from "chalk";
-import ora3 from "ora";
 var MAX_ASK_TRY = 300;
 var supportedLlmModels = ["deepseek-chat", "deepseek-reasoner"];
 var AiSession = class _AiSession {
@@ -2228,8 +2263,11 @@ var AiSession = class _AiSession {
   static async init({ temperature = 0.7, useExisting = true } = {}) {
     if (useExisting) {
       const llmConfig2 = this.getLlmConfig();
-      if (llmConfig2)
-        return this.#setChatModel(llmConfig2.model, llmConfig2.apiKey);
+      if (llmConfig2) {
+        this.#setChatModel(llmConfig2.model, llmConfig2.apiKey);
+        Logger.rawLog(chalk3.dim(`\u{1F916}akan editor uses existing LLM config (${llmConfig2.model})`));
+        return this;
+      }
     }
     const llmConfig = await this.#requestLlmConfig();
     const { model, apiKey } = llmConfig;
@@ -2261,6 +2299,7 @@ var AiSession = class _AiSession {
     return { model, apiKey };
   }
   static async #validateApiKey(modelName, apiKey) {
+    const spinner = new Spinner("Validating LLM API key...", { prefix: `\u{1F916}akan-editor` }).start();
     const chat = new ChatOpenAI2({
       modelName,
       temperature: 0,
@@ -2268,9 +2307,10 @@ var AiSession = class _AiSession {
     });
     try {
       await chat.invoke("Hi, and just say 'ok'");
+      spinner.succeed("LLM API key is valid");
       return true;
     } catch (error) {
-      Logger.rawLog(
+      spinner.fail(
         chalk3.red(
           `LLM API key is invalid. Please check your API key and try again. You can set it again by running "akan set-llm" or reset by running "akan reset-llm"`
         )
@@ -2291,14 +2331,16 @@ var AiSession = class _AiSession {
       await _AiSession.init();
     if (!_AiSession.#chat)
       throw new Error("Failed to initialize the AI session");
-    const loader = ora3(`${_AiSession.#chat.model} is thinking...`).start();
+    const loader = new Spinner(`${_AiSession.#chat.model} is thinking...`, {
+      prefix: `\u{1F916}akan-editor`
+    }).start();
     try {
       const humanMessage = new HumanMessage(question);
       this.messageHistory.push(humanMessage);
       const stream = await _AiSession.#chat.stream(this.messageHistory);
       let fullResponse = "", tokenIdx = 0;
       for await (const chunk of stream) {
-        if (loader.isSpinning)
+        if (loader.isSpinning())
           loader.succeed(`${_AiSession.#chat.model} responded`);
         const content = chunk.content;
         if (typeof content === "string") {
@@ -2518,38 +2560,49 @@ var LibraryRunner = class {
 // pkgs/@akanjs/cli/src/library/library.script.ts
 var LibraryScript = class {
   #runner = new LibraryRunner();
-  async scanLibrary(lib, verbose = false) {
+  async syncLibrary(lib) {
+    const syncSpinner = lib.spinning("Syncing library...");
     const akanConfig = await lib.getConfig();
     const scanResult = await lib.scan({ akanConfig });
-    if (verbose)
-      lib.logger.rawLog(JSON.stringify(scanResult, null, 2));
+    syncSpinner.succeed(`Library ${lib.name} (libs/${lib.name}) is synced`);
     return scanResult;
   }
-  async syncLibrary(lib) {
-    const akanConfig = await lib.getConfig();
-    return await lib.scan({ akanConfig });
-  }
   async createLibrary(libName, workspace) {
+    const spinner = workspace.spinning(`Creating ${libName} library`);
     const lib = await this.#runner.createLibrary(libName, workspace);
+    spinner.succeed(`${libName} library (libs/${libName}) is created`);
     await this.syncLibrary(lib);
   }
   async removeLibrary(lib) {
+    const spinner = lib.spinning("Removing library...");
     await this.#runner.removeLibrary(lib);
+    spinner.succeed(`Library ${lib.name} (libs/${lib.name}) is removed`);
   }
   async installLibrary(workspace, libName) {
+    const installSpinner = workspace.spinning(`Installing ${libName} library`);
     const lib = await this.#runner.installLibrary(workspace, libName);
-    workspace.log(`${libName} library installed`);
+    installSpinner.succeed(`${libName} library (libs/${libName}) is installed`);
+    const mergeSpinner = workspace.spinning("Merging library dependencies...");
     await this.#runner.mergeLibraryDependencies(lib);
+    mergeSpinner.succeed(`${libName} library (libs/${libName}) dependencies merged to root package.json`);
   }
   async pushLibrary(lib, branch) {
+    const pushSpinner = lib.spinning("Pushing library...");
     await this.#runner.pushLibrary(lib, branch);
+    pushSpinner.succeed(`Library ${lib.name} (libs/${lib.name}) pushed to ${branch} branch`);
   }
   async pullLibrary(lib, branch) {
+    const pullSpinner = lib.spinning("Pulling library...");
     await this.#runner.pullLibrary(lib, branch);
+    pullSpinner.succeed(`Library ${lib.name} (libs/${lib.name}) pulled from ${branch} branch`);
+    const mergeSpinner = lib.spinning("Merging library dependencies...");
     await this.#runner.mergeLibraryDependencies(lib);
+    mergeSpinner.succeed(`Library ${lib.name} (libs/${lib.name}) dependencies merged to root package.json`);
   }
   async testLibrary(lib) {
+    const spinner = lib.spinning("Testing library...");
     await this.#runner.testLibrary(lib);
+    spinner.succeed(`Library ${lib.name} (libs/${lib.name}) test is successful`);
   }
 };
 
@@ -2566,7 +2619,7 @@ import fs11 from "fs";
 import fsPromise2 from "fs/promises";
 import yaml2 from "js-yaml";
 import openBrowser from "open";
-import ora4 from "ora";
+import ora3 from "ora";
 import path5 from "path";
 import * as vite from "vite";
 import commonjs from "vite-plugin-commonjs";
@@ -4474,7 +4527,6 @@ var ApplicationRunner = class {
   }
   async removeApplication(app) {
     await app.workspace.exec(`rm -rf apps/${app.name}`);
-    app.log(`Application ${app.name} removed`);
   }
   async getConfig(app) {
     return await getAppConfig(app.cwdPath, {
@@ -4537,7 +4589,7 @@ var ApplicationRunner = class {
     app.dist.writeJson("backend/package.json", appPackageJson);
     app.dist.writeFile(path5.join(app.dist.cwdPath, "backend", "Dockerfile"), akanConfig.backend.dockerfile);
   }
-  async startBackend(app, { open: open2 = false } = {}) {
+  async startBackend(app, { open: open2 = false, onStart } = {}) {
     const { env } = await this.#prepareCommand(app, "start", "backend");
     const ctx = await esbuild2.context({
       write: true,
@@ -4551,14 +4603,15 @@ var ApplicationRunner = class {
     });
     await ctx.watch();
     await sleep(100);
+    onStart?.();
     if (open2)
       setTimeout(() => openBrowser("http://localhost:8080/backend/graphql"), 3e3);
-    await app.dist.spawn("node", ["--watch", "backend/main.js"], { env });
+    await app.dist.spawn("node", ["--watch", "backend/main.js"], { env, stdio: "inherit" });
   }
   async buildFrontend(app) {
     const { env } = await this.#prepareCommand(app, "build", "frontend");
     const akanConfig = await app.getConfig("build");
-    await app.spawn("npx", ["next", "build", "--no-lint"], { env, stdio: "ignore" });
+    await app.spawn("npx", ["next", "build", "--no-lint"], { env });
     const buildResult = await esbuild2.build({
       entryPoints: [`${app.cwdPath}/next.config.ts`],
       outdir: `${app.dist.cwdPath}/frontend`,
@@ -4588,10 +4641,11 @@ var ApplicationRunner = class {
     ]);
     app.dist.writeFile("frontend/Dockerfile", akanConfig.frontend.dockerfile);
   }
-  async startFrontend(app, { open: open2 = false, turbo = true } = {}) {
+  async startFrontend(app, { open: open2 = false, turbo = true, onStart } = {}) {
     const { env } = await this.#prepareCommand(app, "start", "frontend");
     if (open2)
       setTimeout(() => openBrowser("http://localhost:4200"), 3e3);
+    onStart?.();
     await app.spawn("npx", ["next", "dev", "-p", "4200", ...turbo ? ["--turbo"] : []], { env });
   }
   async #getViteConfig(app, command) {
@@ -4674,10 +4728,11 @@ var ApplicationRunner = class {
     const config = await this.#getViteConfig(app, "build");
     await vite.build(config);
   }
-  async startCsr(app, { open: open2 = false } = {}) {
+  async startCsr(app, { open: open2 = false, onStart } = {}) {
     const config = await this.#getViteConfig(app, "start");
     const server = await vite.createServer(config);
     await server.listen(4201);
+    onStart?.();
     app.log(`CSR server is running on http://localhost:4201`);
     if (open2)
       setTimeout(() => openBrowser("http://localhost:4201"), 3e3);
@@ -4744,13 +4799,10 @@ var ApplicationRunner = class {
       dict: { repoName: workspace.repoName },
       overwrite: false
     });
-    await workspace.spawn(`docker`, ["compose", "up", "-d"], {
-      cwd: `${workspace.workspaceRoot}/local`,
-      stdio: "ignore"
-    });
+    await workspace.spawn(`docker`, ["compose", "up", "-d"], { cwd: `${workspace.workspaceRoot}/local` });
   }
   async dbdown(workspace) {
-    await workspace.spawn(`docker`, ["compose", "down"], { cwd: `${workspace.workspaceRoot}/local`, stdio: "ignore" });
+    await workspace.spawn(`docker`, ["compose", "down"], { cwd: `${workspace.workspaceRoot}/local` });
   }
   async configureApp(app) {
     const capacitorApp = new CapacitorApp(app);
@@ -4910,7 +4962,7 @@ var ApplicationRunner = class {
     const chatModel = new ChatOpenAI3({ modelName: "gpt-4o", openAIApiKey });
     const projectName = await input3({ message: "please enter project name." });
     const projectDesc = await input3({ message: "please enter project description. (40 ~ 60 characters)" });
-    const spinner = ora4("Gerating project files...");
+    const spinner = ora3("Gerating project files...");
     const mainPrompt = PromptTemplate2.fromTemplate(requestApplication());
     const chain = RunnableSequence2.from([mainPrompt, chatModel, new StringOutputParser()]);
     const resultOne = await chain.invoke({ projectName, projectDesc });
@@ -4949,20 +5001,22 @@ var ApplicationScript = class {
   #runner = new ApplicationRunner();
   libraryScript = new LibraryScript();
   async createApplication(appName, workspace, { start = false } = {}) {
+    const spinner = workspace.spinning("Creating application...");
     const app = await this.#runner.createApplication(appName, workspace);
+    spinner.succeed(`Application created in apps/${app.name}`);
     await this.syncApplication(app);
     if (start)
       await this.start(app, { open: true });
   }
   async removeApplication(app) {
+    const spinner = app.spinning("Removing application...");
     await this.#runner.removeApplication(app);
+    spinner.succeed(`Application ${app.name} (apps/${app.name}) removed`);
   }
-  async syncApplication(app, verbose = false) {
+  async syncApplication(app) {
     const spinner = app.spinning("Scanning application...");
     const akanConfig = await this.#runner.getConfig(app);
     const scanResult = await this.#runner.scanSync(app, akanConfig);
-    if (verbose)
-      app.logger.rawLog(JSON.stringify(scanResult, null, 2));
     spinner.succeed("Application scanned");
     return scanResult;
   }
@@ -4981,24 +5035,39 @@ var ApplicationScript = class {
       await this.syncApplication(app);
     const spinner = app.spinning("Building backend...");
     await this.#runner.buildBackend(app);
-    spinner.succeed(`Successfully built in dist/apps/${app.name}/backend`);
+    spinner.succeed(`Backend built in dist/apps/${app.name}/backend`);
   }
-  async startBackend(app, { open: open2 = false, sync = true } = {}) {
+  async startBackend(app, { open: open2 = false, dbup = true, sync = true } = {}) {
+    if (app.getEnv() === "local" && dbup)
+      await this.dbup(app.workspace);
     if (sync)
       await this.syncApplication(app);
-    await this.#runner.startBackend(app, { open: open2 });
+    const spinner = app.spinning("Preparing backend...");
+    await this.#runner.startBackend(app, {
+      open: open2,
+      onStart: () => {
+        spinner.succeed(`Backend prepared, ready to start`);
+      }
+    });
   }
   async buildFrontend(app, { sync = true } = {}) {
     if (sync)
       await this.syncApplication(app);
     const spinner = app.spinning("Building frontend...");
     await this.#runner.buildFrontend(app);
-    spinner.succeed(`Successfully built in dist/apps/${app.name}/frontend`);
+    spinner.succeed(`Frontend built in dist/apps/${app.name}/frontend`);
   }
   async startFrontend(app, { open: open2 = false, turbo = false, sync = true } = {}) {
     if (sync)
       await this.syncApplication(app);
-    await this.#runner.startFrontend(app, { open: open2, turbo });
+    const spinner = app.spinning("Preparing frontend...");
+    await this.#runner.startFrontend(app, {
+      open: open2,
+      turbo,
+      onStart: () => {
+        spinner.succeed(`Frontend prepared, ready to start`);
+      }
+    });
   }
   async buildCsr(app, { sync = true } = {}) {
     if (sync)
@@ -5010,7 +5079,13 @@ var ApplicationScript = class {
   async startCsr(app, { open: open2 = false, sync = true } = {}) {
     if (sync)
       await this.syncApplication(app);
-    await this.#runner.startCsr(app, { open: open2 });
+    const spinner = app.spinning("Preparing CSR...");
+    await this.#runner.startCsr(app, {
+      open: open2,
+      onStart: () => {
+        spinner.succeed(`CSR prepared, ready to start`);
+      }
+    });
   }
   async buildIos(app, { sync = true } = {}) {
     if (sync)
@@ -5049,13 +5124,17 @@ var ApplicationScript = class {
     await this.#runner.releaseAndroid(app);
   }
   async dumpDatabase(app, environment) {
+    await this.dbdown(app.workspace);
+    const spinner = app.spinning("Dumping database...");
     await this.#runner.dumpDatabase(app, environment);
+    spinner.succeed(`Database dumped to dump/${app.name}-${environment}`);
   }
   async restoreDatabase(app, source, target) {
+    const spinner = app.spinning("Restoring database...");
     await this.#runner.restoreDatabase(app, source, target);
+    spinner.succeed(`Database restored from dump/${app.name}-${source} to ${app.name}-${target}`);
   }
   async pullDatabase(app, environment, dump) {
-    await this.dbdown(app.workspace);
     const hasDump = app.workspace.exists(`dump/${app.name}-${environment}`);
     if (dump || !hasDump)
       await this.dumpDatabase(app, environment);
@@ -5071,14 +5150,12 @@ var ApplicationScript = class {
   async dbup(workspace) {
     const spinner = workspace.spinning("Starting local database...");
     await this.#runner.dbup(workspace);
-    spinner.succeed(
-      "Local database(/local/docker-compose.yaml) is up, you can start your application and connect to the database"
-    );
+    spinner.succeed("Local database (/local/docker-compose.yaml) is up");
   }
   async dbdown(workspace) {
     const spinner = workspace.spinning("Stopping local database...");
     await this.#runner.dbdown(workspace);
-    spinner.succeed("Local database(/local/docker-compose.yaml) is down");
+    spinner.succeed("Local database (/local/docker-compose.yaml) is down");
   }
   async testSys(sys2) {
     if (sys2.type === "app")
@@ -5087,7 +5164,9 @@ var ApplicationScript = class {
       await this.libraryScript.testLibrary(sys2);
   }
   async testApplication(app) {
+    const spinner = app.spinning("Testing application...");
     await this.#runner.testApplication(app);
+    spinner.succeed(`Application ${app.name} (apps/${app.name}) test is successful`);
   }
 };
 
@@ -5100,8 +5179,8 @@ var ApplicationCommand = class {
   async removeApplication(app) {
     await this.applicationScript.removeApplication(app);
   }
-  async syncApplication(app, verbose) {
-    await this.applicationScript.syncApplication(app, verbose);
+  async syncApplication(app) {
+    await this.applicationScript.syncApplication(app);
   }
   async build(app) {
     await this.applicationScript.build(app);
@@ -5182,8 +5261,7 @@ __decorateClass([
 ], ApplicationCommand.prototype, "removeApplication", 1);
 __decorateClass([
   Target.Public(),
-  __decorateParam(0, App()),
-  __decorateParam(1, Option("verbose", { type: "boolean", desc: "verbose", default: false }))
+  __decorateParam(0, App())
 ], ApplicationCommand.prototype, "syncApplication", 1);
 __decorateClass([
   Target.Public({ short: true }),
@@ -5352,17 +5430,25 @@ var PackageScript = class {
     await this.#runner.version(workspace);
   }
   async createPackage(workspace, pkgName) {
+    const spinner = workspace.spinning(`Creating package in pkgs/${pkgName}...`);
     await this.#runner.createPackage(workspace, pkgName);
+    spinner.succeed(`Package in pkgs/${pkgName} is created`);
   }
   async removePackage(pkg) {
+    const spinner = pkg.spinning(`Removing package in pkgs/${pkg.name}...`);
     await this.#runner.removePackage(pkg);
+    spinner.succeed("Package removed");
   }
-  async scanPackage(pkg) {
+  async syncPackage(pkg) {
+    const spinner = pkg.spinning("Scanning package...");
     const scanResult = await this.#runner.scanSync(pkg);
-    pkg.logger.rawLog(JSON.stringify(scanResult, null, 2));
+    spinner.succeed("Package scanned");
+    return scanResult;
   }
   async buildPackage(pkg) {
+    const spinner = pkg.spinning("Building package...");
     await this.#runner.buildPackage(pkg);
+    spinner.succeed("Package built");
   }
 };
 
@@ -5437,11 +5523,10 @@ ${chalk4.green("\u27A4")} Authentication Required`));
   }
   async setLlm() {
     await AiSession.init({ useExisting: true });
-    Logger.rawLog(chalk4.green("LLM model set successfully"));
   }
   resetLlm() {
     AiSession.setLlmConfig(null);
-    Logger.rawLog(chalk4.green("LLM model reset successfully"));
+    Logger.rawLog(chalk4.green("\u2611\uFE0F LLM model config is cleared. Please run `akan set-llm` to set a new LLM model."));
   }
   async getAkanPkgs(workspace) {
     const pkgs = await workspace.getPkgs();
@@ -5471,7 +5556,7 @@ ${chalk4.green("\u27A4")} Authentication Required`));
       message: "Are you sure you want to deploy the libraries?"
     });
     if (!isDeployConfirmed) {
-      Logger.info("Deployment cancelled");
+      Logger.error("Deployment cancelled");
       return;
     }
     await Promise.all(
@@ -5501,7 +5586,6 @@ ${chalk4.green("\u27A4")} Authentication Required`));
       workspace.spawn("npm", ["update", "-g", "@akanjs/cli", "--latest"]),
       workspace.spawn("pnpm", ["install"])
     ]);
-    Logger.info(`Akan.js is updated to the latest version ${latestPublishedVersionOfBase}`);
   }
 };
 
@@ -5509,19 +5593,19 @@ ${chalk4.green("\u27A4")} Authentication Required`));
 var CloudScript = class {
   #runner = new CloudRunner();
   #packageScript = new PackageScript();
-  async login() {
+  async login(workspace) {
     await this.#runner.login();
   }
-  logout() {
+  logout(workspace) {
     this.#runner.logout();
   }
-  async setLlm() {
+  async setLlm(workspace) {
     await this.#runner.setLlm();
   }
-  resetLlm() {
+  resetLlm(workspace) {
     this.#runner.resetLlm();
   }
-  async ask(question) {
+  async ask(question, workspace) {
     await AiSession.init();
     const session = new AiSession();
     await session.ask(question);
@@ -5534,27 +5618,31 @@ var CloudScript = class {
     await this.#runner.deployAkan(workspace, akanPkgs);
   }
   async update(workspace) {
+    const spinner = workspace.spinning("Updating Akan.js packages and CLI...");
     await this.#runner.update(workspace);
+    spinner.succeed("Akan.js packages and CLI updated, global version is below");
+    Logger.raw("> Akan version: ");
+    await workspace.spawn("akan", ["--version"], { stdio: "inherit" });
   }
 };
 
 // pkgs/@akanjs/cli/src/cloud/cloud.command.ts
 var CloudCommand = class {
   cloudScript = new CloudScript();
-  async login() {
-    await this.cloudScript.login();
+  async login(workspace) {
+    await this.cloudScript.login(workspace);
   }
-  logout() {
-    this.cloudScript.logout();
+  logout(workspace) {
+    this.cloudScript.logout(workspace);
   }
-  async setLlm() {
-    await this.cloudScript.setLlm();
+  async setLlm(workspace) {
+    await this.cloudScript.setLlm(workspace);
   }
-  resetLlm() {
-    this.cloudScript.resetLlm();
+  resetLlm(workspace) {
+    this.cloudScript.resetLlm(workspace);
   }
-  async ask(question) {
-    await this.cloudScript.ask(question);
+  async ask(question, workspace) {
+    await this.cloudScript.ask(question, workspace);
   }
   async deployAkan(workspace) {
     await this.cloudScript.deployAkan(workspace);
@@ -5564,20 +5652,25 @@ var CloudCommand = class {
   }
 };
 __decorateClass([
-  Target.Public()
+  Target.Public(),
+  __decorateParam(0, Workspace())
 ], CloudCommand.prototype, "login", 1);
 __decorateClass([
-  Target.Public()
+  Target.Public(),
+  __decorateParam(0, Workspace())
 ], CloudCommand.prototype, "logout", 1);
 __decorateClass([
-  Target.Public()
+  Target.Public(),
+  __decorateParam(0, Workspace())
 ], CloudCommand.prototype, "setLlm", 1);
 __decorateClass([
-  Target.Public()
+  Target.Public(),
+  __decorateParam(0, Workspace())
 ], CloudCommand.prototype, "resetLlm", 1);
 __decorateClass([
   Target.Public(),
-  __decorateParam(0, Option("question", { ask: "question to ask" }))
+  __decorateParam(0, Option("question", { ask: "question to ask" })),
+  __decorateParam(1, Workspace())
 ], CloudCommand.prototype, "ask", 1);
 __decorateClass([
   Target.Public({ devOnly: true }),
@@ -5600,10 +5693,8 @@ var LibraryCommand = class {
   async removeLibrary(lib) {
     await this.libraryScript.removeLibrary(lib);
   }
-  async scanLibrary(lib) {
-    await this.libraryScript.scanLibrary(lib, true);
-  }
-  async buildLibrary(lib) {
+  async syncLibrary(lib) {
+    await this.libraryScript.syncLibrary(lib);
   }
   async installLibrary(name, workspace) {
     await this.libraryScript.installLibrary(workspace, name);
@@ -5627,11 +5718,7 @@ __decorateClass([
 __decorateClass([
   Target.Public(),
   __decorateParam(0, Lib())
-], LibraryCommand.prototype, "scanLibrary", 1);
-__decorateClass([
-  Target.Public(),
-  __decorateParam(0, Lib())
-], LibraryCommand.prototype, "buildLibrary", 1);
+], LibraryCommand.prototype, "syncLibrary", 1);
 __decorateClass([
   Target.Public(),
   __decorateParam(0, Option("name", { desc: "name of library" })),
@@ -6025,8 +6112,8 @@ var PackageCommand = class {
   async removePackage(pkg) {
     await this.packageScript.removePackage(pkg);
   }
-  async scanPackage(pkg) {
-    await this.packageScript.scanPackage(pkg);
+  async syncPackage(pkg) {
+    await this.packageScript.syncPackage(pkg);
   }
   async buildPackage(pkg) {
     await this.packageScript.buildPackage(pkg);
@@ -6048,7 +6135,7 @@ __decorateClass([
 __decorateClass([
   Target.Public(),
   __decorateParam(0, Pkg())
-], PackageCommand.prototype, "scanPackage", 1);
+], PackageCommand.prototype, "syncPackage", 1);
 __decorateClass([
   Target.Public(),
   __decorateParam(0, Pkg())
@@ -6096,6 +6183,7 @@ var WorkspaceRunner = class {
     const cwdPath = process.cwd();
     const workspaceRoot = path6.join(cwdPath, dirname, repoName);
     const workspace = new WorkspaceExecutor({ workspaceRoot, repoName });
+    const templateSpinner = workspace.spinning(`Creating workspace template files in ${dirname}/${repoName}...`);
     await workspace.applyTemplate({
       basePath: ".",
       template: "workspaceRoot",
@@ -6107,6 +6195,7 @@ var WorkspaceRunner = class {
         serveDomain: "localhost"
       }
     });
+    templateSpinner.succeed(`Workspace files created in ${dirname}/${repoName}`);
     const rootPackageJson = workspace.readJson("package.json");
     const dependencies = [
       "@akanjs/base",
@@ -6139,10 +6228,12 @@ var WorkspaceRunner = class {
       }
     };
     workspace.writeFile("package.json", packageJson);
-    workspace.log("Installing dependencies...");
+    const installSpinner = workspace.spinning("Installing dependencies with pnpm...");
     await workspace.spawn("pnpm", ["install", "--reporter=silent"]);
-    workspace.log("Initializing git repository and commit...");
+    installSpinner.succeed("Dependencies installed with pnpm");
+    const gitSpinner = workspace.spinning("Initializing git repository and commit...");
     await workspace.commit("Initial commit", { init: true });
+    gitSpinner.succeed("Git repository initialized and committed");
     return workspace;
   }
   async generateMongo(workspace) {
@@ -6198,19 +6289,30 @@ var WorkspaceScript = class {
     await this.libraryScript.installLibrary(workspace, "util");
     await this.libraryScript.installLibrary(workspace, "shared");
     await this.applicationScript.createApplication(appName, workspace);
-    workspace.log(`Workspace created in ${workspace.workspaceRoot}`);
-    Logger.rawLog(`Run \`cd ${repoName} && akan start ${appName}\` to start the development server.`);
+    Logger.rawLog(`
+\u{1F389} Welcome aboard! Workspace created in ${dirname}/${repoName}`);
+    Logger.rawLog(`\u{1F680} Run \`cd ${repoName} && akan start ${appName}\` to start the development server.`);
+    Logger.rawLog(`
+\u{1F44B} Happy coding!`);
   }
   async generateMongo(workspace) {
+    const spinner = workspace.spinning("Generating Mongo connections...");
     await this.#runner.generateMongo(workspace);
-    workspace.log(`Mongo connections generated in infra/master/mongo-connections.json`);
+    spinner.succeed(`Mongo connections generated in infra/master/mongo-connections.json`);
   }
   async lint(exec2, workspace, { fix = true } = {}) {
     if (exec2 instanceof AppExecutor)
       await this.applicationScript.syncApplication(exec2);
     else if (exec2 instanceof LibExecutor)
       await this.libraryScript.syncLibrary(exec2);
-    await this.#runner.lint(exec2, workspace, { fix });
+    const spinner = workspace.spinning(`Linting${fix ? " with fix" : ""}...`);
+    try {
+      await this.#runner.lint(exec2, workspace, { fix });
+      spinner.succeed("Lint completed with no errors");
+    } catch (error) {
+      spinner.fail("Lint failed with errors");
+      throw error;
+    }
   }
   async lintAll(workspace, { fix = true } = {}) {
     const [appNames, libNames, pkgNames] = await workspace.getExecs();