@akanjs/cli 3.0.0-beta.9 → 3.0.0

package/abstractCompactor-gmkc0z8j.js

@@ -1,102 +0,0 @@
-// @bun
-import"./index-q0y2jq9j.js";
-import"./index-m0xccmmm.js";
-import {
-  AiSession
-} from "./index-te54x9zm.js";
-import {
-  AbstractDoc
-} from "./index-meh558jy.js";
-
-// pkgs/@akanjs/devkit/abstractCompactor.ts
-import { Logger } from "akanjs/common";
-import chalk from "chalk";
-class AbstractCompactor {
-  static #reviewRequest = `Review the compacted file you just wrote against the original.
-- Did you drop an invariant, a security reason, or a workflow step that the source files cannot show by themselves? Restore it.
-- Did you keep anything that only restates code, scaffold wording, or history? Remove it.
-- Is it in the same language as the original, within the line budget, and one short line per bullet?
-Respond with exactly one \`\`\`markdown code block holding the corrected file and nothing else. If nothing needs to change, repeat the file unchanged.`;
-  #sys;
-  #minLines;
-  #interactive;
-  constructor(sys, { minLines = AbstractDoc.compactMinLines, interactive = false } = {}) {
-    this.#sys = sys;
-    this.#minLines = minLines;
-    this.#interactive = interactive;
-  }
-  async compactAll({ module } = {}) {
-    const docs = await AbstractDoc.findAll(this.#sys, { module });
-    const targets = docs.filter((doc) => doc.lineCount > this.#minLines);
-    const reports = [];
-    for (const doc of targets)
-      reports.push(await this.compact(doc));
-    return { scanned: docs.length, reports };
-  }
-  async compact(doc) {
-    const session = new AiSession("compactAbstract", {
-      workspace: this.#sys.workspace,
-      cacheKey: `${this.#sys.name}-${doc.moduleName}`
-    });
-    const approve = !this.#interactive;
-    const compacted = await session.editMarkdown(this.#request(doc), { approve });
-    const reviewed = await session.editMarkdown(AbstractCompactor.#reviewRequest, { approve });
-    const next = [reviewed, compacted].map((candidate) => candidate.trim()).find((candidate) => doc.canReplaceWith(candidate));
-    const beforeLines = doc.lineCount;
-    if (!next) {
-      Logger.rawLog(chalk.yellow(`${doc.path}: the editor returned no shorter abstract, keeping the current file`));
-      return { path: doc.path, beforeLines, afterLines: beforeLines, status: "failed" };
-    }
-    if (next === doc.content.trim())
-      return { path: doc.path, beforeLines, afterLines: beforeLines, status: "unchanged" };
-    const content = `${next}
-`;
-    await this.#sys.writeFile(doc.path, content);
-    return { path: doc.path, beforeLines, afterLines: AbstractDoc.lineCountOf(content), status: "compacted" };
-  }
-  #targetShape(kind) {
-    if (kind === "other")
-      return "  - keep the headings that still carry information and drop the rest; do not impose a new structure";
-    return [
-      "  - `# <name> Abstract` title line",
-      "  - one declarative sentence naming what this module owns",
-      "  - `## Rules` \u2014 two to five bullets, each an invariant the code cannot show by itself",
-      "  - optional `## Workflow` \u2014 the lifecycle as an arrow chain (`draft -> signed -> active`) or a few bullets"
-    ].join(`
-`);
-  }
-  #request(doc) {
-    return `You are compacting an Akan.js abstract file.
-
-An abstract is the summary a coding agent reads before changing a module. Repeated edits have made this one
-bloated, and it has to shrink back to what the source files cannot show by themselves.
-
-# Target file
-${this.#sys.type}s/${this.#sys.name}/${doc.path} (${doc.kind} module "${doc.moduleName}", ${doc.lineCount} lines)
-
-# Source files in the same folder
-${doc.siblingFiles.join(", ") || "none"}
-
-# Current content
-\`\`\`markdown
-${doc.content}
-\`\`\`
-
-# Rules for the compacted file
-- Write it in the SAME language as the current content. Never translate.
-- Keep every invariant, constraint, security reason, and workflow step that the source files cannot show by
-  themselves. Merge duplicates instead of dropping either one.
-- Delete what the code already states: field lists, types, labels, signatures, file lists, and imports.
-- Delete scaffold and placeholder wording, changelog or migration history, TODOs, and any instruction about
-  reading or updating this file.
-- Never invent a rule that the current content does not state.
-- Keep every bullet to one short line, and stay under ${AbstractDoc.compactMinLines} lines in total.
-- Shape:
-${this.#targetShape(doc.kind)}
-
-Respond with exactly one \`\`\`markdown code block holding the whole new file and nothing else.`;
-  }
-}
-export {
-  AbstractCompactor
-};

package/application.command-18y0s485.js

@@ -1,204 +0,0 @@
-// @bun
-import {
-  App,
-  Apps,
-  Sys,
-  Exec,
-  Workspace,
-  command
-} from "./index-0g7r8xz3.js";
-import"./index-q0y2jq9j.js";
-import"./index-2tv3fdx4.js";
-import"./index-6wwzs1bc.js";
-import {
-  ApplicationScript
-} from "./index-sj5vxr8f.js";
-import"./index-vxtad5bd.js";
-import"./index-hwkygn9s.js";
-import {
-  AbstractDoc
-} from "./index-meh558jy.js";
-import"./index-j9yhg404.js";
-import {
-  getMobileTargetChoices
-} from "./index-47pj3aee.js";
-
-// pkgs/@akanjs/cli/application/application.command.ts
-import { select } from "@inquirer/prompts";
-var mobileTargetOption = {
-  desc: "mobile target name or all",
-  ask: "Select mobile target",
-  enum: async ({ app }) => await getMobileTargetChoices(app)
-};
-
-class ApplicationCommand extends command("application", [ApplicationScript], ({ public: target }) => ({
-  createApplication: target({ desc: "Create a new application in the workspace" }).arg("appName", String, { desc: "name of application" }).option("start", Boolean, { desc: "start application", default: false }).with(Workspace).exec(async function(appName, start, workspace) {
-    await this.applicationScript.createApplication(appName.toLowerCase().replace(/ /g, "-"), workspace, { start });
-  }),
-  removeApplication: target({ desc: "Remove an application from the workspace" }).with(App).exec(async function(app) {
-    await this.applicationScript.removeApplication(app);
-  }),
-  planSlice: target({ desc: "List the exact files an app needs to live in a workspace of its own" }).with(App).option("format", String, { desc: "output format", default: "text", enum: ["text", "json"] }).exec(async function(app, format) {
-    await this.applicationScript.planSlice(app, format);
-  }),
-  sync: target({ desc: "Sync dependencies and configuration for an app or library" }).with(Sys).exec(async function(sys) {
-    await this.applicationScript.sync(sys);
-  }),
-  compact: target({ desc: "Compact the *.abstract.md files of an app or library with the AI editor" }).with(Sys).option("module", String, { desc: "single module to compact", nullable: true }).option("minLines", Number, {
-    flag: "n",
-    desc: "only compact abstracts longer than this",
-    default: AbstractDoc.compactMinLines
-  }).option("interactive", Boolean, { desc: "confirm or refine each rewrite", default: false }).exec(async function(sys, module, minLines, interactive) {
-    await this.applicationScript.compact(sys, { module, minLines, interactive });
-  }),
-  script: target({ desc: "Run a custom script in the application" }).with(App).arg("filename", String, { desc: "name of script", nullable: true }).exec(async function(app, filename) {
-    await this.applicationScript.script(app, filename);
-  }),
-  console: target({ desc: "Open an interactive server console for the application" }).with(App).exec(async function(app) {
-    await this.applicationScript.console(app);
-  }),
-  logs: target({ desc: "Tail the running application's logs, filtered (attaches to akan-control.sock)" }).with(App).option("level", String, { desc: "minimum level: trace, verbose, debug, info, warn, error", nullable: true }).option("grep", String, { desc: "substring the message must contain", nullable: true }).option("endpoint", String, {
-    desc: "endpoint glob(s), comma-separated: mutation:*, query:userList",
-    nullable: true
-  }).option("trace", String, { desc: "one request's traceId", nullable: true }).option("child", String, { desc: "replica index(es), comma-separated", nullable: true }).option("role", String, { flag: "R", desc: "process role(s): gateway, all, batch, rsc-worker", nullable: true }).option("origin", String, { desc: "call origin(s): http, websocket, mcp, internal, page", nullable: true }).option("since", String, { desc: "only records newer than this: 5m, 30s, or epoch ms", nullable: true }).option("replay", Number, { flag: "n", desc: "records to replay from the buffer before following", default: 0 }).option("json", Boolean, { desc: "print NDJSON records instead of rendered lines", default: false }).option("follow", Boolean, { desc: "keep streaming; pass --follow false for history only", default: true }).option("runtimeDir", String, {
-    flag: "d",
-    desc: "runtime dir holding akan-control.sock (default: local/apps/<app>/runtime)",
-    nullable: true
-  }).exec(async function(app, level, grep, endpoint, trace, child, role, origin, since, replay, json, follow, runtimeDir) {
-    await this.applicationScript.logs(app, {
-      level,
-      grep,
-      endpoint,
-      trace,
-      child,
-      role,
-      origin,
-      since,
-      replay,
-      json,
-      follow,
-      runtimeDir
-    });
-  }),
-  build: target({ short: true, desc: "Build the application for production (frontend + backend)" }).with(App).option("write", Boolean, { desc: "write code generation", default: true }).option("fast", Boolean, { desc: "fast build", default: false }).option("quiet", Boolean, { desc: "hide build progress output", default: false }).exec(async function(app, write, fast, quiet) {
-    await this.applicationScript.build(app, { write, fast, quiet });
-  }),
-  typecheck: target({ short: true, desc: "Typecheck the application" }).with(App).option("write", Boolean, { desc: "write code generation", default: true }).option("clean", Boolean, { desc: "clear typecheck cache before running", default: false }).option("incremental", Boolean, { desc: "reuse TypeScript incremental cache", default: true }).exec(async function(app, write, clean, incremental) {
-    await this.applicationScript.typecheck(app, { write, clean, incremental });
-  }),
-  test: target({ desc: "Prepare and test an app, library, or package" }).with(Exec).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(exec, write) {
-    await this.applicationScript.test(exec, { write });
-  }),
-  buildIos: target({ short: true, desc: "Build iOS app with Capacitor" }).with(App).option("target", String, mobileTargetOption).option("env", String, {
-    enum: ["local", "debug", "develop", "main"],
-    desc: "backend environment",
-    default: "debug"
-  }).option("write", Boolean, { desc: "write code generation", default: true }).option("regenerate", Boolean, { flag: "g", desc: "delete and regenerate native project", default: false }).exec(async function(app, target, env, write, regenerate) {
-    await this.applicationScript.buildIos(app, { target, env, write, regenerate });
-  }),
-  buildAndroid: target({ short: true, desc: "Build Android app with Capacitor" }).with(App).option("target", String, mobileTargetOption).option("env", String, {
-    enum: ["local", "debug", "develop", "main"],
-    desc: "backend environment",
-    default: "debug"
-  }).option("write", Boolean, { desc: "write code generation", default: true }).option("regenerate", Boolean, { flag: "g", desc: "delete and regenerate native project", default: false }).exec(async function(app, target, env, write, regenerate) {
-    await this.applicationScript.buildAndroid(app, { target, env, write, regenerate });
-  }),
-  start: target({ short: true, desc: "Start development server(s) (frontend SSR + backend)" }).with(Apps).option("plain", Boolean, { desc: "print prefixed lines instead of the full-screen view", default: false }).option("kill", Boolean, { flag: "k", desc: "free the dev ports first, whoever is holding them", default: false }).option("concurrency", Number, {
-    desc: "apps to boot at a time (default: what this machine's memory and cores allow)",
-    nullable: true
-  }).option("dbup", Boolean, { desc: "start the local database first", default: true }).option("open", Boolean, { desc: "open web browser?", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(apps, plain, kill, concurrency, dbup, open, write) {
-    await this.applicationScript.start(apps, { plain, kill, concurrency, dbup, open, write });
-  }),
-  startIos: target({ short: true, desc: "Start iOS app in simulator or device" }).with(App).option("target", String, mobileTargetOption).option("env", String, {
-    enum: ["local", "debug", "develop", "main"],
-    desc: "backend environment",
-    default: "local"
-  }).option("open", Boolean, { desc: "open ios simulator", default: false }).option("release", Boolean, { desc: "release mode", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).option("regenerate", Boolean, { flag: "g", desc: "delete and regenerate native project", default: false }).option("noAllowProvisioningUpdates", Boolean, {
-    desc: "disable automatic iOS provisioning updates for physical devices",
-    default: false
-  }).option("device", String, {
-    desc: "run target to select non-interactively: udid, device name, or runtime (e.g. 'iPhone 16' or 'iOS 18')",
-    default: ""
-  }).exec(async function(app, target, env, open, release, write, regenerate, noAllowProvisioningUpdates, device) {
-    await this.applicationScript.startIos(app, {
-      target,
-      env,
-      open,
-      operation: release ? "release" : "local",
-      write,
-      regenerate,
-      noAllowProvisioningUpdates,
-      device: device || undefined
-    });
-  }),
-  startAndroid: target({ short: true, desc: "Start Android app in emulator or device" }).with(App).option("target", String, mobileTargetOption).option("env", String, {
-    enum: ["local", "debug", "develop", "main"],
-    desc: "backend environment",
-    default: "local"
-  }).option("release", Boolean, { desc: "release mode", default: false }).option("open", Boolean, { desc: "open android simulator", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).option("regenerate", Boolean, { flag: "g", desc: "delete and regenerate native project", default: false }).exec(async function(app, target, env, release, open, write, regenerate) {
-    await this.applicationScript.startAndroid(app, {
-      target,
-      env,
-      open,
-      operation: release ? "release" : "local",
-      write,
-      regenerate
-    });
-  }),
-  releaseIos: target({ desc: "Build and package iOS app for release (App Store)" }).with(App).option("target", String, mobileTargetOption).option("env", String, {
-    enum: ["debug", "develop", "main", "local"],
-    desc: "backend environment",
-    default: "main"
-  }).option("write", Boolean, { desc: "write code generation", default: true }).option("regenerate", Boolean, { flag: "g", desc: "delete and regenerate native project", default: false }).option("allowLocalRelease", Boolean, { flag: "l", desc: "allow release with --env local", default: false }).exec(async function(app, target, env, write, regenerate, allowLocalRelease) {
-    await this.applicationScript.releaseIos(app, {
-      target,
-      env,
-      write,
-      regenerate,
-      allowLocalRelease
-    });
-  }),
-  releaseAndroid: target({ desc: "Build and package Android app for release (Play Store)" }).with(App).option("assembleType", String, { enum: ["apk", "aab"], default: "apk" }).option("target", String, mobileTargetOption).option("env", String, {
-    enum: ["debug", "develop", "main", "local"],
-    desc: "backend environment",
-    default: "main"
-  }).option("write", Boolean, { desc: "write code generation", default: true }).option("regenerate", Boolean, { flag: "g", desc: "delete and regenerate native project", default: false }).option("allowLocalRelease", Boolean, { flag: "l", desc: "allow release with --env local", default: false }).exec(async function(app, assembleType, target, env, write, regenerate, allowLocalRelease) {
-    await this.applicationScript.releaseAndroid(app, assembleType, {
-      target,
-      env,
-      write,
-      regenerate,
-      allowLocalRelease
-    });
-  }),
-  releaseSource: target({ desc: "Release app source code with OTA update support" }).with(App).option("rebuild", Boolean, { desc: "rebuild", default: false }).option("buildNum", Number, { desc: "build number", default: 0 }).option("environment", String, { desc: "environment", default: "debug" }).option("local", Boolean, { desc: "local", default: true }).exec(async function(app, rebuild, buildNum, environment, local) {
-    await this.applicationScript.releaseSource(app, { rebuild, buildNum, environment, local });
-  }),
-  codepush: target({ desc: "Deploy over-the-air (OTA) update for mobile app" }).with(App).exec(async function(app) {
-    const os = await select({
-      message: "Select os",
-      choices: [
-        { value: "ios", name: "ios", description: "ios" },
-        { value: "android", name: "android", description: "android" }
-      ]
-    });
-    await this.applicationScript.codepush(app, os);
-  }),
-  dbup: target({ desc: "Start local database services for a database mode" }).with(Workspace).option("mode", String, {
-    desc: "database mode",
-    default: "multiple",
-    enum: ["single", "multiple", "cluster"]
-  }).exec(async function(workspace, mode) {
-    await this.applicationScript.dbup(workspace, mode);
-  }),
-  dbdown: target({ desc: "Stop local database services" }).with(Workspace).exec(async function(workspace) {
-    await this.applicationScript.dbdown(workspace);
-  }),
-  configureApp: target({ desc: "Configure application settings interactively" }).with(App).exec(async function(app) {
-    await this.applicationScript.configureApp(app);
-  })
-})) {
-}
-export {
-  ApplicationCommand
-};

package/applicationReleasePackager-4yasxwv9.js

@@ -1,244 +0,0 @@
-// @bun
-import {
-  FileSys
-} from "./index-q0y2jq9j.js";
-import {
-  Spinner
-} from "./index-2tv3fdx4.js";
-
-// pkgs/@akanjs/devkit/applicationReleasePackager.ts
-import { cp, mkdir, rm } from "fs/promises";
-import path from "path";
-
-// pkgs/@akanjs/devkit/uploadRelease.ts
-import { Logger, RestClient } from "akanjs/common";
-var spinning = (message) => {
-  const spinner = new Spinner(message, { prefix: message, enableSpin: true }).start();
-  return spinner;
-};
-var uploadRelease = async (appName, {
-  workspaceRoot,
-  environment,
-  buildNum,
-  platformVersion,
-  os,
-  local
-}) => {
-  const logger = new Logger("uploadRelease");
-  const basePath = local ? "http://localhost:8282/backend" : "https://cloud.akanjs.com/backend";
-  const httpClient = new RestClient(basePath);
-  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 = Bun.file(buildPath);
-    const sourceFile = Bun.file(sourcePath);
-    const appBuildFile = Bun.file(appBuildPath);
-    const buildStat = { mtime: new Date(buildFile.lastModified), size: buildFile.size };
-    const sourceStat = { mtime: new Date(sourceFile.lastModified), size: sourceFile.size };
-    const appBuildStat = { mtime: new Date(appBuildFile.lastModified), size: appBuildFile.size };
-    readingFilesSpinner.succeed("Reading files... done");
-    const preparingFormSpinner = spinning("Preparing form data...");
-    const formData = new FormData;
-    formData.append("files", buildFile, `${appName}-release.tar.gz`);
-    formData.append("files", sourceFile, `${appName}-source.tar.gz`);
-    formData.append("files", appBuildFile, `${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 }
-    ]));
-    formData.append("type", "release");
-    preparingFormSpinner.succeed("Preparing form data... done");
-    try {
-      const uploadingFilesSpinner = spinning("Uploading files to server...");
-      const [buildFile, sourceFile, appBuildFile] = await httpClient.post("/file/addFiles", formData);
-      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 httpClient.get(`/devApp/devAppInName/${appName}`);
-      fetchingAppSpinner.succeed(`Fetching dev app information for ${appName}... done`);
-      const pushingReleaseSpinner = spinning(`Pushing release to ${environment} environment...`);
-      const release = await httpClient.post(`/release/pushRelease/${devApp.id}/${environment}/${major}/${minor}/${patch}/${sourceFile.id}/${buildFile.id}/${appBuildFile.id}${os ? `/${os}` : ""}`);
-      pushingReleaseSpinner.succeed(`Pushing release to ${environment} environment... done`);
-      new 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";
-      logger.error(`Upload release failed: ${errorMessage}`);
-      return null;
-    }
-  } catch (e) {
-    const errorMessage = e instanceof Error ? e.message : "Unknown error";
-    readingFilesSpinner.fail(`Reading files failed: ${errorMessage}`);
-    return null;
-  }
-};
-
-// pkgs/@akanjs/devkit/applicationReleasePackager.ts
-class ApplicationReleasePackager {
-  #app;
-  #build;
-  constructor(app, options) {
-    this.#app = app;
-    this.#build = options.build;
-  }
-  async releaseSource({
-    rebuild,
-    buildNum = 0,
-    environment = "debug",
-    local = true
-  } = {}) {
-    const { platformVersion } = await this.#prepareReleaseBuild({ rebuild, buildNum });
-    await this.#writeSourceArchive({ readme: this.#confidentialReadme() });
-    await uploadRelease(this.#app.name, {
-      local,
-      buildNum,
-      environment,
-      platformVersion,
-      workspaceRoot: this.#app.workspace.cwdPath
-    });
-  }
-  async compressProjectFiles({ rebuild, buildNum = 0 } = {}) {
-    await this.#prepareReleaseBuild({ rebuild, buildNum });
-    await this.#writeSourceArchive({ readme: this.#publicReadme() });
-  }
-  async#prepareReleaseBuild({ rebuild, buildNum }) {
-    const akanConfig = await this.#app.getConfig();
-    const platformVersion = akanConfig.mobile.version;
-    const buildRoot = `${this.#app.workspace.workspaceRoot}/releases/builds/${this.#app.name}`;
-    if (await FileSys.dirExists(buildRoot))
-      await rm(buildRoot, { recursive: true, force: true });
-    await mkdir(buildRoot, { recursive: true });
-    if (rebuild || !await FileSys.dirExists(`${this.#app.dist.cwdPath}/backend`))
-      await this.#build();
-    const buildVersion = `${platformVersion}-${buildNum}`;
-    const buildPath = `${buildRoot}/${buildVersion}`;
-    await mkdir(buildPath, { recursive: true });
-    await cp(`${this.#app.dist.cwdPath}/backend`, `${buildPath}/backend`, { recursive: true });
-    await cp(this.#app.dist.cwdPath, buildRoot, { recursive: true });
-    await rm(`${buildRoot}/frontend/.next`, { recursive: true, force: true });
-    const releaseRoot = this.#app.workspace.workspaceRoot;
-    const releaseArchivePath = path.relative(releaseRoot, `${releaseRoot}/releases/builds/${this.#app.name}-release.tar.gz`).split(path.sep).join("/");
-    await this.#app.workspace.spawn("tar", ["-zcf", releaseArchivePath, "-C", buildRoot, "./"], { cwd: releaseRoot });
-    await this.#writeCsrZipIfPresent();
-    return { platformVersion };
-  }
-  async#writeCsrZipIfPresent() {
-    if (!await FileSys.dirExists(`${this.#app.dist.cwdPath}/csr`))
-      return;
-    await cp(`${this.#app.dist.cwdPath}/csr`, "./csr", { recursive: true });
-    await this.#app.workspace.spawn("zip", [
-      "-r",
-      `${this.#app.workspace.workspaceRoot}/releases/builds/${this.#app.name}-appBuild.zip`,
-      "./csr"
-    ]);
-    await rm("./csr", { recursive: true, force: true });
-  }
-  async#writeSourceArchive({ readme }) {
-    const sourceRoot = `${this.#app.workspace.workspaceRoot}/releases/sources/${this.#app.name}`;
-    await this.#resetSourceRoot(sourceRoot);
-    await cp(this.#app.dist.cwdPath, `${sourceRoot}/apps/${this.#app.name}`, { recursive: true });
-    const libDeps = ["social", "shared", "platform", "util"];
-    await Promise.all(libDeps.map((lib) => cp(`${this.#app.workspace.cwdPath}/libs/${lib}`, `${sourceRoot}/libs/${lib}`, { recursive: true })));
-    await Promise.all([".next", "ios", "android", "public/libs"].map(async (path2) => {
-      const targetPath = `${sourceRoot}/apps/${this.#app.name}/${path2}`;
-      if (await FileSys.dirExists(targetPath))
-        await rm(targetPath, { recursive: true, force: true });
-    }));
-    const syncPaths = [".husky", ".gitignore", "package.json"];
-    await Promise.all(syncPaths.map((path2) => cp(`${this.#app.workspace.cwdPath}/${path2}`, `${sourceRoot}/${path2}`, { recursive: true })));
-    await this.#writeSourceTsconfig(sourceRoot, libDeps);
-    await Bun.write(`${sourceRoot}/README.md`, readme);
-    const sourceCwd = this.#app.workspace.cwdPath;
-    const sourceArchivePath = path.relative(sourceCwd, `${sourceCwd}/releases/sources/${this.#app.name}-source.tar.gz`).split(path.sep).join("/");
-    await this.#app.workspace.spawn("tar", ["-zcf", sourceArchivePath, "-C", sourceRoot, "./"], { cwd: sourceCwd });
-  }
-  async#resetSourceRoot(sourceRoot) {
-    if (await FileSys.dirExists(sourceRoot)) {
-      const maxRetry = 3;
-      for (let i = 0;i < maxRetry; i++) {
-        try {
-          await rm(sourceRoot, { recursive: true, force: true });
-        } catch {}
-      }
-    }
-    await mkdir(sourceRoot, { recursive: true });
-  }
-  async#writeSourceTsconfig(sourceRoot, libDeps) {
-    const tsconfig = await this.#app.workspace.readJson("tsconfig.json");
-    const pathEntries = [[`@${this.#app.name}/*`, [`apps/${this.#app.name}/*`]]];
-    for (const lib of libDeps) {
-      pathEntries.push([`@${lib}`, [`libs/${lib}/index.ts`]], [`@${lib}/*`, [`libs/${lib}/*`]]);
-    }
-    tsconfig.compilerOptions.paths = Object.fromEntries(pathEntries);
-    await Bun.write(`${sourceRoot}/tsconfig.json`, JSON.stringify(tsconfig, null, 2));
-  }
-  #confidentialReadme() {
-    return `# ${this.#app.name}
-  \uBCF8 \uD504\uB85C\uC81D\uD2B8\uC758 \uC18C\uC2A4\uCF54\uB4DC \uBC0F \uAD00\uB828\uC790\uB8CC\uB294 \uBAA8\uB450 \uBE44\uBC00\uC815\uBCF4\uB85C \uAD00\uB9AC\uB429\uB2C8\uB2E4.
-
-  ## Get Started
-  Run the code below.
-  \`\`\`
-  bun install -g bun
-  bun i
-
-  cat <<EOF >> .env
-  # ENV For Server => debug | debug.local | develop | develop.local | main | main.local
-  SERVER_ENV=debug.local
-  # Run Mode For Server => federation | batch | all
-  SERVER_MODE=federation
-  # ENV For Client => debug | debug.local | develop | develop.local | main | main.local
-  AKAN_PUBLIC_CLIENT_ENV=debug.local
-  ANALYZE=false
-  EOF
-
-  akn start-backend ${this.#app.name}
-  # or akn start-frontend ${this.#app.name}, etc
-  \`\`\`
-
-  ## Build
-  Run the code below.
-  \`\`\`
-  akn build-backend ${this.#app.name}
-  # or akn build-frontend ${this.#app.name}, etc
-  \`\`\`
-  `;
-  }
-  #publicReadme() {
-    return `# ${this.#app.name}
-  ## Get Started
-  Run the code below.
-  \`\`\`
-  cat <<EOF >> .env
-  # ENV For Server => debug | debug.local | develop | develop.local | main | main.local
-  SERVER_ENV=debug.local
-  # Run Mode For Server => federation | batch | all
-  SERVER_MODE=federation
-  # ENV For Client => debug | debug.local | develop | develop.local | main | main.local
-  AKAN_PUBLIC_CLIENT_ENV=debug.local
-  ANALYZE=false
-  EOF
-
-  akan start ${this.#app.name}
-  \`\`\`
-
-  ## Build
-  Run the code below.
-  \`\`\`
-  akan build ${this.#app.name}
-  # or akn build-frontend ${this.#app.name}, etc
-  \`\`\`
-  `;
-  }
-}
-export {
-  ApplicationReleasePackager
-};

package/capacitorApp-36rbr858.js

@@ -1,12 +0,0 @@
-// @bun
-import {
-  isPlaceholderAppId2,
-  CapacitorApp2
-} from "./index-wt7qrtd4.js";
-import"./index-2tv3fdx4.js";
-import"./index-6wwzs1bc.js";
-import"./index-q0y2jq9j.js";
-export {
-  CapacitorApp2 as CapacitorApp,
-  isPlaceholderAppId2 as isPlaceholderAppId
-};

package/cloud.command-av97ndh6.js

@@ -1,94 +0,0 @@
-// @bun
-import"./index-q0y2jq9j.js";
-import {
-  GlobalConfig
-} from "./index-m0xccmmm.js";
-import {
-  Workspace,
-  command
-} from "./index-0g7r8xz3.js";
-import"./index-2tv3fdx4.js";
-import"./index-6wwzs1bc.js";
-import"./index-te54x9zm.js";
-import"./index-sj5vxr8f.js";
-import"./index-vxtad5bd.js";
-import"./index-hwkygn9s.js";
-import"./index-kcxmv48c.js";
-import"./index-9077wzd2.js";
-import"./index-rtxxan88.js";
-import {
-  CloudScript2
-} from "./index-2xp0kfkt.js";
-import"./index-j9yhg404.js";
-
-// pkgs/@akanjs/cli/cloud/cloud.command.ts
-var localRegistryUrl = () => process.env.AKAN_NPM_REGISTRY ?? "http://127.0.0.1:4873";
-var resolveRegistryUrl = (registry) => registry === "local" ? localRegistryUrl() : undefined;
-
-class CloudCommand extends command("cloud", [CloudScript2], ({ public: target }) => ({
-  login: target({ desc: "Login to Akan Cloud services" }).option("host", String, { desc: "host of the cloud", default: GlobalConfig.akanCloudHost }).with(Workspace).exec(async function(host, workspace) {
-    await this.cloudScript.login(workspace, host);
-  }),
-  logout: target({ desc: "Logout from Akan Cloud services" }).option("host", String, { desc: "host of the cloud", default: GlobalConfig.akanCloudHost }).with(Workspace).exec(async function(host, workspace) {
-    await this.cloudScript.logout(workspace, host);
-  }),
-  setLlm: target({ desc: "Configure LLM (Large Language Model) API key" }).with(Workspace).exec(async function(workspace) {
-    await this.cloudScript.setLlm(workspace);
-  }),
-  resetLlm: target({ desc: "Reset LLM configuration to default" }).with(Workspace).exec(function(workspace) {
-    this.cloudScript.resetLlm(workspace);
-  }),
-  ask: target({
-    devOnly: true,
-    desc: "Ask AI assistant a question about your project"
-  }).option("question", String, { ask: "question to ask" }).with(Workspace).exec(async function(question, workspace) {
-    await this.cloudScript.ask(question, workspace);
-  }),
-  deployAkan: target({
-    devOnly: true,
-    desc: "Deploy Akan.js framework to cloud (internal use)"
-  }).option("test", Boolean, { desc: "test the deployment", default: true }).option("registry", String, {
-    desc: "registry target for publishing Akan packages",
-    ask: "Select a registry target",
-    enum: [
-      { label: "local", value: "local" },
-      { label: "npm", value: "npm" }
-    ]
-  }).with(Workspace).exec(async function(test, registry, workspace) {
-    await this.cloudScript.deployAkan(workspace, {
-      test,
-      registryUrl: resolveRegistryUrl(registry)
-    });
-  }),
-  update: target({ desc: "Update Akan.js framework to the latest version" }).with(Workspace).option("tag", String, {
-    desc: "tag of the update",
-    default: "latest",
-    enum: ["latest", "dev", "canary", "beta", "rc", "alpha"]
-  }).option("registry", String, {
-    desc: "registry target for resolving Akan packages",
-    ask: "Select a registry target",
-    enum: [
-      { label: "npm", value: "npm" },
-      { label: "local", value: "local" }
-    ],
-    default: process.env.USE_AKANJS_PKGS === "true" ? undefined : "npm"
-  }).exec(async function(workspace, tag, registry) {
-    await this.cloudScript.update(workspace, tag, {
-      registryUrl: resolveRegistryUrl(registry)
-    });
-  }),
-  downloadEnv: target({
-    desc: "Download environment variables from cloud or SCP server"
-  }).option("host", String, { desc: "host of the cloud to target", default: GlobalConfig.akanCloudHost }).with(Workspace).exec(async function(host, workspace) {
-    await this.cloudScript.downloadEnv(workspace, undefined, { host });
-  }),
-  uploadEnv: target({
-    desc: "Upload environment variables to cloud or SCP server"
-  }).option("host", String, { desc: "host of the cloud to target", default: GlobalConfig.akanCloudHost }).with(Workspace).exec(async function(host, workspace) {
-    await this.cloudScript.uploadEnv(workspace, { host });
-  })
-})) {
-}
-export {
-  CloudCommand
-};