@akanjs/cli 2.4.0 → 2.4.1-rc.0

package/agent.command-h4afc69n.js

@@ -0,0 +1,26 @@
+// @bun
+import {
+  AgentScript
+} from "./index-hwzpw9c1.js";
+import"./index-8rc0bm04.js";
+import"./index-qaq13qk3.js";
+import"./index-h6ca6qg0.js";
+import {
+  Workspace,
+  command
+} from "./index-hdqztm58.js";
+import"./index-a6sbyy0b.js";
+import"./index-61keag0s.js";
+import"./index-6pz1j0zj.js";
+import"./index-r24hmh0q.js";
+
+// pkgs/@akanjs/cli/agent/agent.command.ts
+class AgentCommand extends command("agent", [AgentScript], ({ public: target }) => ({
+  agent: target({ desc: "Install Akan agent rules for editors and coding agents" }).arg("action", String, { desc: "install" }).arg("target", String, { desc: "cursor, agents-md, claude, or all", nullable: true }).option("force", Boolean, { desc: "overwrite existing rule files", default: false }).with(Workspace).exec(async function(action, targetName, force, workspace) {
+    await this.agentScript.agent(workspace, action, targetName, { force });
+  })
+})) {
+}
+export {
+  AgentCommand
+};

package/application.command-4ctkfdan.js

@@ -0,0 +1,165 @@
+// @bun
+import {
+  ApplicationScript
+} from "./index-9sp6fsc5.js";
+import {
+  getMobileTargetChoices
+} from "./index-76rn3g2c.js";
+import"./index-pmm9e2jf.js";
+import {
+  App,
+  Exec,
+  Sys,
+  Workspace,
+  command
+} from "./index-hdqztm58.js";
+import"./index-fgc8r6dj.js";
+import"./index-a6sbyy0b.js";
+import"./index-61keag0s.js";
+import"./index-6pz1j0zj.js";
+import"./index-r24hmh0q.js";
+
+// pkgs/@akanjs/cli/application/application.command.ts
+import { select } from "@inquirer/prompts";
+var asMobileEnv = (env) => env;
+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);
+  }),
+  sync: target({ desc: "Sync dependencies and configuration for an app or library" }).with(Sys).exec(async function(sys) {
+    await this.applicationScript.sync(sys);
+  }),
+  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);
+  }),
+  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, target2, env, write, regenerate) {
+    await this.applicationScript.buildIos(app, { target: target2, env: asMobileEnv(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, target2, env, write, regenerate) {
+    await this.applicationScript.buildAndroid(app, { target: target2, env: asMobileEnv(env), write, regenerate });
+  }),
+  start: target({ short: true, desc: "Start development server (frontend SSR + backend)" }).with(App).option("open", Boolean, { desc: "open web browser?", default: false }).option("write", Boolean, { desc: "write code generation", default: true }).exec(async function(app, open, write) {
+    await this.applicationScript.start(app, { 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, target2, env, open, release, write, regenerate, noAllowProvisioningUpdates, device) {
+    await this.applicationScript.startIos(app, {
+      target: target2,
+      env: asMobileEnv(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, target2, env, release, open, write, regenerate) {
+    await this.applicationScript.startAndroid(app, {
+      target: target2,
+      env: asMobileEnv(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, target2, env, write, regenerate, allowLocalRelease) {
+    await this.applicationScript.releaseIos(app, {
+      target: target2,
+      env: asMobileEnv(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, target2, env, write, regenerate, allowLocalRelease) {
+    await this.applicationScript.releaseAndroid(app, assembleType, {
+      target: target2,
+      env: asMobileEnv(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/applicationBuildRunner-esa1kj7v.js

@@ -0,0 +1,284 @@
+// @bun
+import {
+  AllRoutesBuilder,
+  CsrArtifactBuilder,
+  SsrBaseArtifactBuilder,
+  precompressArtifacts
+} from "./index-xmc2w32q.js";
+import {
+  Spinner
+} from "./index-6pz1j0zj.js";
+import"./index-r24hmh0q.js";
+
+// pkgs/@akanjs/devkit/applicationBuildRunner.ts
+import { mkdir, rm } from "fs/promises";
+import path from "path";
+var BUILD_PHASE_EMOJIS = {
+  prepare: "\uD83E\uDDF9",
+  typecheck: "\uD83D\uDD0E",
+  backend: "\uD83D\uDCE6",
+  ssr: "\uD83E\uDDED",
+  csr: "\uD83C\uDFA8",
+  compress: "\uD83D\uDDDC\uFE0F",
+  metadata: "\uD83D\uDCDD"
+};
+var SSR_RENDER_EXTERNALS = [
+  "react",
+  "react/jsx-runtime",
+  "react/jsx-dev-runtime",
+  "react-dom",
+  "react-dom/server.browser",
+  "react-server-dom-webpack",
+  "react-server-dom-webpack/server.node",
+  "react-server-dom-webpack/client.node",
+  "react-server-dom-webpack/client.browser"
+];
+var AKAN_OPTIONAL_BACKEND_EXTERNALS = [
+  "@libsql/client",
+  "bullmq",
+  "croner",
+  "ioredis",
+  "postgres",
+  "protobufjs"
+];
+
+class ApplicationBuildRunner {
+  #app;
+  #fast;
+  #reporter;
+  #startedAt = Date.now();
+  #phases = [];
+  constructor(app, { fast = false, reporter } = {}) {
+    this.#app = app;
+    this.#fast = fast;
+    this.#reporter = reporter;
+  }
+  async build({ spinner = false } = {}) {
+    const phaseOptions = { spinner };
+    await this.#runPhase("prepare", "Preparing output directory", () => this.#app.prepareCommand("build"), undefined, {
+      spinner
+    });
+    if (!this.#fast)
+      await this.#runPhase("typecheck", "Typechecking", () => this.typecheck(), undefined, phaseOptions);
+    await this.#runPhase("backend", "Compiling backend", () => this.#buildBackend(), (result) => `${result.entrypoints} entrypoints, ${result.outputs} outputs`, phaseOptions);
+    await this.#runPhase("ssr", "Building SSR route artifacts", () => this.#buildSsr(), (result) => result ? `${result.allRoutes.manifest.routeIds.length} routes, ${result.allRoutes.manifest.knownEntries.length} entries` : "skipped", phaseOptions);
+    await this.#runPhase("csr", "Building CSR assets", () => this.#buildCsr(), (result) => result?.outputDir ?? "skipped", phaseOptions);
+    await this.#runPhase("compress", "Compressing static assets", () => precompressArtifacts(this.#app), (result) => result.files > 0 ? `${result.files} files, ${ApplicationBuildRunner.formatBytes(result.inputBytes)} -> ${ApplicationBuildRunner.formatBytes(result.outputBytes)}` : "no files", phaseOptions);
+    await this.#runPhase("metadata", "Writing production metadata", () => this.#buildAppMeta(), undefined, {
+      spinner
+    });
+    return {
+      phases: this.#phases,
+      durationMs: Date.now() - this.#startedAt,
+      outputDir: this.#app.dist.cwdPath,
+      artifactDir: path.join(this.#app.dist.cwdPath, ".akan/artifact")
+    };
+  }
+  async typecheck(options = {}) {
+    const { clean = false, incremental = true } = options;
+    await this.#app.getPageKeys({ refresh: true });
+    const { typecheckDir, tsconfigPath } = await this.#writeTypecheckTsconfig({ incremental });
+    if (clean)
+      await rm(path.join(typecheckDir, "tsconfig.tsbuildinfo"), { force: true });
+    await this.#checkProjectInChildProcess(tsconfigPath);
+  }
+  async#runPhase(id, label, task, summarize, options = {}) {
+    this.#reporter?.phaseStart?.({ id, label });
+    const phaseStartedAt = Date.now();
+    const spinner = options.spinner ? new Spinner(label, { prefix: `${BUILD_PHASE_EMOJIS[id]} ${id}` }).start() : undefined;
+    try {
+      const result = await task();
+      const phase = { id, label, durationMs: Date.now() - phaseStartedAt, summary: summarize?.(result) };
+      this.#phases.push(phase);
+      const summary = phase.summary ? `: ${phase.summary}` : "";
+      spinner?.succeed(`${label}${summary}`);
+      this.#reporter?.phaseDone?.(phase);
+      return result;
+    } catch (error) {
+      spinner?.fail(`${label} failed`);
+      this.#reporter?.phaseFail?.({ id, label }, error);
+      throw error;
+    }
+  }
+  async#buildAppMeta() {
+    const akanConfig = await this.#app.getConfig();
+    await Promise.all([
+      this.#app.dist.writeJson("package.json", akanConfig.getProductionPackageJson()),
+      this.#app.dist.writeFile(`${this.#app.dist.cwdPath}/Dockerfile`, akanConfig.docker.content)
+    ]);
+  }
+  async#buildBackend() {
+    const akanConfig = await this.#app.getConfig();
+    const backendExternals = [
+      ...new Set([...akanConfig.externalLibs, ...SSR_RENDER_EXTERNALS, ...AKAN_OPTIONAL_BACKEND_EXTERNALS])
+    ];
+    const backendEntryPoints = [`${this.#app.cwdPath}/main.ts`, `${this.#app.cwdPath}/server.ts`];
+    for (const entrypoint of backendEntryPoints) {
+      if (!await Bun.file(entrypoint).exists())
+        throw new Error(`Backend entrypoint not found: ${entrypoint}`);
+    }
+    const backendResult = await this.#buildOrThrow("backend", {
+      entrypoints: backendEntryPoints,
+      outdir: this.#app.dist.cwdPath,
+      target: "bun",
+      minify: true,
+      naming: { entry: "[name].[ext]", chunk: "chunk-[hash].[ext]" },
+      define: { "process.env.NODE_ENV": JSON.stringify("production") },
+      plugins: backendExternals.length > 0 ? [this.#createExternalSpecifiersPlugin(backendExternals)] : []
+    });
+    const rscWorkerResult = await this.#buildOrThrow("rsc-worker", {
+      entrypoints: [this.#resolveRscWorkerBuildEntry()],
+      outdir: this.#app.dist.cwdPath,
+      target: "bun",
+      minify: true,
+      naming: { entry: "[name].[ext]", chunk: "chunk-[hash].[ext]" },
+      conditions: ["react-server"],
+      define: { "process.env.NODE_ENV": JSON.stringify("production") },
+      plugins: backendExternals.length > 0 ? [this.#createExternalSpecifiersPlugin(backendExternals)] : []
+    });
+    const consoleRuntimeResult = await this.#buildOrThrow("console-runtime", {
+      entrypoints: [this.#resolveConsoleRuntimeBuildEntry()],
+      outdir: this.#app.dist.cwdPath,
+      target: "bun",
+      minify: true,
+      naming: { entry: "console-runtime.[ext]", chunk: "chunk-[hash].[ext]" },
+      define: { "process.env.NODE_ENV": JSON.stringify("production") }
+    });
+    await this.#writeConsoleShim();
+    return {
+      entrypoints: backendEntryPoints.length + 2,
+      outputs: backendResult.outputs.length + rscWorkerResult.outputs.length + consoleRuntimeResult.outputs.length + 1
+    };
+  }
+  async#writeConsoleShim() {
+    await Bun.write(path.join(this.#app.dist.cwdPath, "console.js"), `import { cnst, db, dict, option, server, sig, srv } from "./server.js";
+import { assertAkanConsoleAllowed, startAkanConsole } from "./console-runtime.js";
+
+const run = async () => {
+  assertAkanConsoleAllowed(server.env);
+  await server.start({ listen: false, web: false });
+  try {
+    await startAkanConsole(server, { globals: { cnst, db, dict, option, sig, srv } });
+  } finally {
+    await server.stop();
+  }
+};
+
+void run().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});
+`);
+  }
+  #resolveRscWorkerBuildEntry() {
+    try {
+      return Bun.resolveSync("akanjs/server/rsc-worker", import.meta.dir);
+    } catch {
+      return path.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/rscWorker.tsx");
+    }
+  }
+  #resolveConsoleRuntimeBuildEntry() {
+    try {
+      return path.join(path.dirname(Bun.resolveSync("akanjs/server", import.meta.dir)), "console.ts");
+    } catch {
+      return path.join(this.#app.workspace.workspaceRoot, "pkgs/akanjs/server/console.ts");
+    }
+  }
+  async#buildCsr() {
+    return await new CsrArtifactBuilder(this.#app, "build").build();
+  }
+  async#buildSsr() {
+    const pageKeys = await this.#app.getPageKeys();
+    if (pageKeys.length === 0) {
+      this.#app.log(`[cli] no route files under ${this.#app.cwdPath}/page \u2014 skipping SSR build`);
+      return null;
+    }
+    const base = await new SsrBaseArtifactBuilder(this.#app, "build").build();
+    const allRoutes = await new AllRoutesBuilder(this.#app, base.artifact, "build").build();
+    return { base, allRoutes };
+  }
+  async#writeTypecheckTsconfig({ incremental = true } = {}) {
+    const typecheckDir = path.join(this.#app.cwdPath, ".akan", "typecheck");
+    await mkdir(typecheckDir, { recursive: true });
+    const tsconfig = {
+      extends: "../../tsconfig.json",
+      compilerOptions: {
+        noEmit: true,
+        incremental,
+        tsBuildInfoFile: "./tsconfig.tsbuildinfo"
+      },
+      include: [
+        "../../main.ts",
+        "../../server.ts",
+        "../../client.ts",
+        "../../page/**/*.ts",
+        "../../page/**/*.tsx",
+        "../../../../pkgs/akanjs/*/types/**/*.d.ts"
+      ],
+      references: []
+    };
+    const tsconfigPath = path.join(typecheckDir, "tsconfig.json");
+    await Bun.write(tsconfigPath, `${JSON.stringify(tsconfig, null, 2)}
+`);
+    return { typecheckDir, tsconfigPath };
+  }
+  async#checkProjectInChildProcess(tsconfigPath) {
+    const entry = await this.#resolveTypecheckWorkerEntry();
+    const proc = Bun.spawn([process.execPath, entry], {
+      cwd: this.#app.workspace.workspaceRoot,
+      env: this.#app.getCommandEnv({
+        AKAN_COMMAND_TYPE: "typecheck",
+        AKAN_TYPECHECK_TSCONFIG: tsconfigPath
+      }),
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited
+    ]);
+    if (exitCode !== 0)
+      throw new Error((stderr || stdout).trim() || `Typecheck failed with exit code ${exitCode}`);
+  }
+  async#resolveTypecheckWorkerEntry() {
+    const candidates = [
+      path.join(this.#app.workspace.workspaceRoot, "pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path.join(this.#app.workspace.workspaceRoot, "node_modules/@akanjs/devkit/typecheck/typecheck.proc.ts"),
+      path.join(import.meta.dir, "typecheck.proc.js"),
+      path.join(import.meta.dir, "typecheck.proc.ts")
+    ];
+    for (const candidate of candidates)
+      if (await Bun.file(candidate).exists())
+        return candidate;
+    throw new Error(`[cli] typecheck worker entry not found; looked in: ${candidates.join(", ")}`);
+  }
+  async#buildOrThrow(label, config) {
+    const result = await Bun.build(config);
+    if (!result.success)
+      throw new AggregateError(result.logs, `[${label}] Bun.build failed`);
+    return result;
+  }
+  #createExternalSpecifiersPlugin(specifiers) {
+    const uniqueSpecifiers = [...new Set(specifiers)];
+    const escaped = uniqueSpecifiers.map((specifier) => specifier.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+    const filter = new RegExp(`^(${escaped.join("|")})(?:/.*)?$`);
+    return {
+      name: "akan-backend-externalize-specifiers",
+      setup(build) {
+        build.onResolve({ filter }, (args) => ({ path: args.path, external: true }));
+      }
+    };
+  }
+  static formatBytes(bytes) {
+    if (bytes < 1024)
+      return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+      return `${(bytes / 1024).toFixed(1)}KB`;
+    return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+  }
+}
+export {
+  ApplicationBuildRunner,
+  AKAN_OPTIONAL_BACKEND_EXTERNALS
+};