akanjs 2.0.7 → 2.1.0-rc.0

package/cli/application/application.script.ts

@@ -1,244 +0,0 @@
-import { Logger } from "akanjs/common";
-import {
-  type App,
-  ApplicationBuildReporter,
-  type DatabaseMode,
-  type Exec,
-  type Lib,
-  LibExecutor,
-  type MobileEnv,
-  PkgExecutor,
-  type ReleaseSourceOptions,
-  type Sys,
-  script,
-  type TypecheckOptions,
-  type Workspace,
-} from "akanjs/devkit";
-import { LibraryScript } from "../library/library.script";
-import { ApplicationRunner } from "./application.runner";
-
-type MobileOperation = "local" | "release";
-type MobileCommandOptions = {
-  target?: string;
-  env?: MobileEnv;
-  write?: boolean;
-  regenerate?: boolean;
-};
-type MobileReleaseOptions = MobileCommandOptions & {
-  allowLocalRelease?: boolean;
-};
-
-export class ApplicationScript extends script("application", [ApplicationRunner, LibraryScript]) {
-  async createApplication(
-    appName: string,
-    workspace: Workspace,
-    { start = false, libs = [] }: { start?: boolean; libs?: string[] } = {},
-  ) {
-    const spinner = workspace.spinning("Creating application...");
-    const app = await this.applicationRunner.createApplication(appName, workspace, libs);
-    spinner.succeed(`Application created in apps/${app.name}`);
-    await app.scanSync();
-    if (start) await this.start(app, { open: true });
-  }
-  async removeApplication(app: App) {
-    const spinner = app.spinning("Removing application...");
-    await this.applicationRunner.removeApplication(app);
-    spinner.succeed(`Application ${app.name} (apps/${app.name}) removed`);
-  }
-  async sync(sys: Sys) {
-    if (sys.type === "app") await (sys as App).scanSync();
-    else await this.libraryScript.syncLibrary(sys as Lib);
-  }
-
-  async script(app: App, filename: string | null) {
-    const scriptFilename = filename ?? (await this.applicationRunner.getScriptFilename(app));
-    await app.scanSync();
-    await this.applicationRunner.runScript(app, scriptFilename);
-  }
-
-  async build(
-    app: App,
-    { write = true, fast = false, quiet = false }: { write?: boolean; fast?: boolean; quiet?: boolean } = {},
-  ) {
-    await app.scanSync({ write });
-    if (!quiet) Logger.rawLog(`Creating an optimized production build for ${app.name}...`);
-    try {
-      const result = await this.applicationRunner.build(app, {
-        fast,
-        spinner: !quiet,
-      });
-      Logger.rawLog(`${app.name} built in dist/apps/${app.name}`);
-      if (!quiet) ApplicationBuildReporter.printSummary(result);
-    } catch (error) {
-      Logger.rawLog(`${app.name} build failed in dist/apps/${app.name}`, undefined, "error");
-      Logger.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
-      throw error;
-    }
-  }
-
-  async typecheck(
-    app: App,
-    { write = true, clean = false, incremental = true }: TypecheckOptions & { write?: boolean } = {},
-  ) {
-    await app.scanSync({ write });
-    const spinner = app.spinning(`Typechecking ${app.name}...`);
-    try {
-      await this.applicationRunner.typecheck(app, { clean, incremental });
-      spinner.succeed(`${app.name} typechecked`);
-    } catch (error) {
-      spinner.fail(`${app.name} typecheck failed`);
-      Logger.rawLog(ApplicationBuildReporter.formatError(error), undefined, "error");
-      throw error;
-    }
-  }
-
-  async test(exec: Exec, { write = true }: { write?: boolean } = {}) {
-    const spinner = exec.spinning(`Preparing ${exec.name}...`);
-    try {
-      if (exec instanceof PkgExecutor) await exec.scan({ refresh: true });
-      else if (exec instanceof LibExecutor) await this.libraryScript.syncLibrary(exec);
-      else await (exec as App).scanSync({ write });
-      spinner.succeed(`${exec.name} prepared`);
-    } catch (error) {
-      spinner.fail(`${exec.name} prepare failed`);
-      throw error;
-    }
-    await this.applicationRunner.test(exec);
-  }
-
-  async start(
-    app: App,
-    {
-      open = false,
-      dbup = true,
-      withInk = false,
-      write = true,
-    }: { open?: boolean; dbup?: boolean; withInk?: boolean; write?: boolean } = {},
-  ) {
-    await app.scanSync({ write });
-    const akanConfig = await app.getConfig();
-    const databaseMode = (process.env.AKAN_DATABASE_MODE ?? akanConfig.defaultDatabaseMode ?? "single") as DatabaseMode;
-    if (app.getEnv() === "local" && dbup && databaseMode !== "single") {
-      const wasDbAlreadyUp = await this.dbup(app.workspace, databaseMode);
-      if (!wasDbAlreadyUp)
-        process.on("SIGINT", async () => {
-          await this.dbdown(app.workspace);
-          process.exit(0);
-        });
-    }
-    const spinner = app.spinning("Preparing backend...");
-    const akanAppHost = await this.applicationRunner.start(app, {
-      open,
-      onStart: () => {
-        spinner.succeed(`${app.name} prepared, ready to start`);
-      },
-      withInk,
-    });
-    return akanAppHost;
-  }
-
-  async buildIos(app: App, { write = true, target, env = "debug", regenerate = false }: MobileCommandOptions = {}) {
-    await app.scanSync({ write });
-    await this.applicationRunner.buildIos(app, { target, env, regenerate });
-  }
-  async startIos(
-    app: App,
-    {
-      open = false,
-      operation = "local",
-      env = "local",
-      write = true,
-      target,
-      regenerate = false,
-    }: {
-      operation?: MobileOperation;
-      env?: MobileEnv;
-      open?: boolean;
-      write?: boolean;
-      target?: string;
-      regenerate?: boolean;
-    } = {},
-  ) {
-    await app.scanSync({ write });
-    await this.applicationRunner.startIos(app, { open, operation, env, target, regenerate });
-  }
-  async releaseIos(
-    app: App,
-    { write = true, target, env = "main", regenerate = false, allowLocalRelease = false }: MobileReleaseOptions = {},
-  ) {
-    await app.scanSync({ write });
-    if (env === "local" && !allowLocalRelease)
-      throw new Error(
-        "releaseIos --env local is blocked. Pass allowLocalRelease only for explicit local release testing.",
-      );
-    await this.applicationRunner.releaseIos(app, { target, env, regenerate });
-  }
-  async buildAndroid(app: App, { write = true, target, env = "debug", regenerate = false }: MobileCommandOptions = {}) {
-    await app.scanSync({ write });
-    await this.applicationRunner.buildAndroid(app, { target, env, regenerate });
-  }
-  async startAndroid(
-    app: App,
-    {
-      open = false,
-      operation = "local",
-      env = "local",
-      write = true,
-      target,
-      regenerate = false,
-    }: {
-      open?: boolean;
-      env?: MobileEnv;
-      operation?: MobileOperation;
-      write?: boolean;
-      target?: string;
-      regenerate?: boolean;
-    } = {},
-  ) {
-    await app.scanSync({ write });
-    await this.applicationRunner.startAndroid(app, { open, operation, env, target, regenerate });
-  }
-  
-  async releaseAndroid(
-    app: App,
-    assembleType: "apk" | "aab",
-    { write = true, target, env = "main", regenerate = false, allowLocalRelease = false }: MobileReleaseOptions = {},
-  ) {
-    await app.scanSync({ write });
-    if (env === "local" && !allowLocalRelease)
-      throw new Error(
-        "releaseAndroid --env local is blocked. Pass allowLocalRelease only for explicit local release testing.",
-      );
-    await this.applicationRunner.releaseAndroid(app, assembleType, { target, env, regenerate });
-  }
-
-  async configureApp(app: App) {
-    await this.applicationRunner.configureApp(app);
-  }
-  async releaseSource(app: App, options: ReleaseSourceOptions) {
-    await this.applicationRunner.releaseSource(app, options);
-  }
-  async codepush(app: App, os: "ios" | "android") {
-    await this.applicationRunner.codepush(app, os);
-  }
-  async dbup(workspace: Workspace, mode: DatabaseMode = "multiple"): Promise<boolean> {
-    const spinner = workspace.spinning(`Starting local database (${mode})...`);
-    const wasAlreadyUp = await this.applicationRunner.dbup(workspace, mode);
-    spinner.succeed(wasAlreadyUp ? `Local database (${mode}) was already up` : `Local database (${mode}) is up`);
-    return wasAlreadyUp;
-  }
-  async dbdown(workspace: Workspace) {
-    const spinner = workspace.spinning("Stopping local database...");
-    await this.applicationRunner.dbdown(workspace);
-    spinner.succeed("Local database (/local/docker-compose.yaml) is down");
-  }
-  async testSys(sys: Sys) {
-    if (sys.type === "app") await this.testApplication(sys as App);
-    else await this.libraryScript.testLibrary(sys as Lib);
-  }
-  async testApplication(app: App) {
-    const spinner = app.spinning("Testing application...");
-    await this.applicationRunner.testApplication(app);
-    spinner.succeed(`Application ${app.name} (apps/${app.name}) test is successful`);
-  }
-}

package/cli/build.ts

@@ -1,27 +0,0 @@
-import { $ } from "bun";
-
-const CLI_DIR = import.meta.dir;
-const PACKAGE_DIR = `${CLI_DIR}/..`;
-const WORKSPACE_ROOT = process.env.WORKSPACE_ROOT ?? process.cwd();
-const OUT_DIR = process.env.DIST_DIR ?? `${WORKSPACE_ROOT}/dist/pkgs/akanjs`;
-
-const build = async () => {
-  try {
-    const packageJson = await Bun.file(`${PACKAGE_DIR}/package.json`).json();
-    await $`rm -rf ${OUT_DIR}/cli`;
-    await Bun.build({
-      entrypoints: [`${CLI_DIR}/index.ts`],
-      splitting: false,
-      target: "bun",
-      outdir: `${OUT_DIR}/cli`,
-      external: Object.keys({ ...packageJson.dependencies, ...packageJson.peerDependencies }),
-      plugins: [],
-    });
-    await $`cp -R ${CLI_DIR}/templates ${OUT_DIR}/cli/templates`;
-  } catch (error) {
-    console.error(error);
-    process.exit(1);
-  }
-};
-
-build();

package/cli/cloud/cloud.command.ts

@@ -1,48 +0,0 @@
-import { command, Workspace } from "akanjs/devkit";
-
-import { CloudScript } from "./cloud.script";
-
-export class CloudCommand extends command("cloud", [CloudScript], ({ public: target }) => ({
-  login: target({ desc: "Login to Akan Cloud services" })
-    .with(Workspace)
-    .exec(async function (workspace) {
-      await this.cloudScript.login(workspace);
-    }),
-  logout: target({ desc: "Logout from Akan Cloud services" })
-    .with(Workspace)
-    .exec(async function (workspace) {
-      await this.cloudScript.logout(workspace);
-    }),
-  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({ 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 })
-    .with(Workspace)
-    .exec(async function (test, workspace) {
-      await this.cloudScript.deployAkan(workspace, { test });
-    }),
-  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"],
-    })
-    .exec(async function (workspace, tag) {
-      await this.cloudScript.update(workspace, tag);
-    }),
-})) {}

package/cli/cloud/cloud.runner.ts

@@ -1,157 +0,0 @@
-import { confirm } from "@inquirer/prompts";
-import { Logger, sleep } from "akanjs/common";
-import {
-  AiSession,
-  akanCloudHost,
-  akanCloudUrl,
-  getHostConfig,
-  getSelf,
-  runner,
-  setHostConfig,
-  type Workspace,
-} from "akanjs/devkit";
-import chalk from "chalk";
-import * as QRcode from "qrcode";
-import { getLatestPackageVersion } from "../npmRegistry";
-import { openBrowser } from "../openBrowser";
-
-export class CloudRunner extends runner("cloud") {
-  async login() {
-    const config = await getHostConfig();
-    const self = config.auth ? await getSelf(config.auth.token) : null;
-    if (self) {
-      Logger.rawLog(chalk.green(`\n✓ Already logged in akan cloud as ${self.nickname}\n`));
-      return true;
-    }
-    const remoteId = crypto.randomUUID();
-    const signinUrl = `${akanCloudUrl}/signin?remoteId=${remoteId}`;
-
-    Logger.rawLog(chalk.bold(`\n${chalk.green("➤")} Authentication Required`));
-    Logger.rawLog(chalk.dim("Please visit or click the following URL:"));
-    Logger.rawLog(`${chalk.cyan.underline(signinUrl)}\n`);
-
-    try {
-      const qrcode = await new Promise<string>((resolve, reject) => {
-        QRcode.toString(signinUrl, { type: "terminal", small: true }, (err, data) => {
-          if (err) reject(err);
-          resolve(data);
-        });
-      });
-      Logger.rawLog(qrcode);
-      await openBrowser(signinUrl);
-      Logger.rawLog(chalk.dim("Opening browser..."));
-    } catch {
-      Logger.rawLog(chalk.yellow("Could not open browser. Please visit the URL manually."));
-    }
-
-    Logger.rawLog(chalk.dim("Waiting for authentication..."));
-    const MAX_RETRY = 300;
-    for (let i = 0; i < MAX_RETRY; i++) {
-      const res = await fetch(`${akanCloudUrl}/user/getRemoteAuthToken/${remoteId}`);
-      const { jwt } = (await res.json()) as { jwt: string | null };
-      const self = jwt ? await getSelf(jwt) : null;
-      if (jwt && self) {
-        setHostConfig(akanCloudHost, { auth: { token: jwt, self } });
-        Logger.rawLog(chalk.green(`\r✓ Authentication successful!`));
-        Logger.rawLog(chalk.green.bold(`\n✨ Welcome aboard, ${self.nickname}!`));
-        Logger.rawLog(chalk.dim("You're now ready to use Akan CLI!\n"));
-        return true;
-      }
-      await sleep(2000);
-    }
-    throw new Error(chalk.red("✖ Authentication timed out after 10 minutes. Please try again."));
-  }
-  async logout() {
-    const config = await getHostConfig();
-    if (config.auth) {
-      setHostConfig(akanCloudHost, {});
-      Logger.rawLog(chalk.magenta.bold(`\n👋 Goodbye, ${config.auth.self.nickname}!`));
-      Logger.rawLog(chalk.dim("───────────────────────────────────────────────\n"));
-      Logger.rawLog(chalk.cyan("You have been successfully logged out."));
-      Logger.rawLog(chalk.dim("Thank you for using Akan CLI. Come back soon! 🌟\n"));
-    } else {
-      Logger.rawLog(chalk.yellow.bold("\n⚠️  No active session found"));
-      Logger.rawLog(chalk.dim("You were not logged in to begin with\n"));
-    }
-  }
-  async setLlm() {
-    await AiSession.init({ useExisting: true });
-  }
-  resetLlm() {
-    AiSession.setLlmConfig(null);
-    Logger.rawLog(chalk.green("☑️ LLM model config is cleared. Please run `akan set-llm` to set a new LLM model."));
-  }
-  async getAkanPkgs(workspace: Workspace) {
-    const pkgs = await workspace.getPkgs();
-    return pkgs.filter((pkg) => pkg === "akanjs" || pkg === "create-akan-workspace");
-  }
-  async deployAkan(workspace: Workspace, akanPkgs: string[]) {
-    const akanPackageJson = (await workspace.readJson("pkgs/akanjs/package.json")) as { version: string };
-    const [majorVersion, minorVersion, patchVersion, devPatchVersion] = akanPackageJson.version.split(".");
-    const isOfficialRelease = !devPatchVersion;
-    const targetVersionPrefix = isOfficialRelease
-      ? `${majorVersion}.${minorVersion}`
-      : `${majorVersion}.${minorVersion}.${patchVersion}`;
-    const tag = isOfficialRelease ? "latest" : (patchVersion.split("-").at(1) ?? "dev");
-    const getNextVersion = async (prefix: string, tag: string) => {
-      try {
-        const latestPublishedVersion = await getLatestPackageVersion("akanjs", tag);
-        const latestPatch = latestPublishedVersion.startsWith(prefix)
-          ? parseInt(latestPublishedVersion.split(".").at(-1) ?? "-1")
-          : -1;
-        const nextVersion = `${prefix}.${latestPatch + 1}`;
-        return { nextVersion, latestPublishedVersion };
-      } catch {
-        return { nextVersion: `${prefix}.0`, latestPublishedVersion: null };
-      }
-    };
-    const { nextVersion, latestPublishedVersion } = await getNextVersion(targetVersionPrefix, tag);
-    Logger.info(`Latest published version of akanjs: ${latestPublishedVersion ?? "none"}`);
-    Logger.info(`Next version of akanjs: ${nextVersion}`);
-    for (const library of akanPkgs) {
-      const packageJson = (await workspace.readJson(`pkgs/${library}/package.json`)) as { version: string };
-      const newPackageJsonStr = JSON.stringify({ ...packageJson, version: nextVersion }, null, 2);
-      await workspace.writeFile(`pkgs/${library}/package.json`, newPackageJsonStr);
-      const distPackageJson = (await workspace.readJson(`dist/pkgs/${library}/package.json`)) as {
-        version: string;
-        dependencies?: Record<string, string>;
-      };
-      const newDistPackageJson = { ...distPackageJson, version: nextVersion };
-      await workspace.writeJson(`dist/pkgs/${library}/package.json`, newDistPackageJson);
-    }
-    const isDeployConfirmed = await confirm({
-      message: "Are you sure you want to deploy the libraries?",
-    });
-    if (!isDeployConfirmed) {
-      Logger.error("Deployment cancelled");
-      return;
-    }
-
-    await Promise.all(
-      akanPkgs.map(async (library) => {
-        Logger.info(`Publishing ${library}@${nextVersion} to npm...`);
-        await workspace.exec(`npm publish --tag ${tag}`, { cwd: `dist/pkgs/${library}` });
-        Logger.info(`${library}@${nextVersion} is published to npm`);
-      }),
-    );
-    Logger.info("All libraries are published to npm");
-  }
-  async update(workspace: Workspace, tag: string = "latest") {
-    if (!(await workspace.exists("package.json")))
-      await workspace.spawn("npm", ["update", "-g", "akanjs", "--latest", `--tag=${tag}`]);
-    else
-      await Promise.all([
-        workspace.spawn("npm", ["update", "-g", "akanjs", "--latest", `--tag=${tag}`]),
-        this.#updateAkanPkgs(workspace, tag),
-      ]);
-  }
-  async #updateAkanPkgs(workspace: Workspace, tag: string = "latest") {
-    const latestPublishedVersion = await getLatestPackageVersion("akanjs", tag);
-    const rootPackageJson = await workspace.getPackageJson();
-    if (!rootPackageJson.dependencies) throw new Error("No dependencies found in package.json");
-    if (rootPackageJson.dependencies.akanjs) rootPackageJson.dependencies.akanjs = latestPublishedVersion;
-    if (rootPackageJson.devDependencies?.akanjs) rootPackageJson.devDependencies.akanjs = latestPublishedVersion;
-    workspace.setPackageJson(rootPackageJson);
-    await workspace.spawn("bun", ["install"]);
-  }
-}

package/cli/cloud/cloud.script.ts

@@ -1,40 +0,0 @@
-import { Logger } from "akanjs/common";
-import { AiSession, PkgExecutor, script, type Workspace } from "akanjs/devkit";
-import { ApplicationScript } from "../application/application.script";
-import { PackageScript } from "../package/package.script";
-import { CloudRunner } from "./cloud.runner";
-
-export class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, PackageScript]) {
-  async login(workspace: Workspace) {
-    await this.cloudRunner.login();
-  }
-  async logout(workspace: Workspace) {
-    await this.cloudRunner.logout();
-  }
-  async setLlm(workspace: Workspace) {
-    await this.cloudRunner.setLlm();
-  }
-  resetLlm(workspace: Workspace) {
-    this.cloudRunner.resetLlm();
-  }
-  async ask(question: string, workspace: Workspace) {
-    const session = new AiSession("general", { workspace, isContinued: true });
-    await session.ask(question);
-  }
-  async deployAkan(workspace: Workspace, { test = true }: { test?: boolean } = {}) {
-    const akanPkgs = await this.cloudRunner.getAkanPkgs(workspace);
-    await this.packageScript.updateWorskpaceRootPackageJson(workspace);
-    const pkgs = akanPkgs.map((pkgName) => PkgExecutor.from(workspace, pkgName));
-    if (test) for (const pkg of pkgs) if (pkg.name !== "@akanjs/test") await this.applicationScript.test(pkg);
-    for (const pkg of pkgs) await this.packageScript.buildPackage(pkg);
-
-    await this.cloudRunner.deployAkan(workspace, akanPkgs);
-  }
-  async update(workspace: Workspace, tag: string = "latest") {
-    const spinner = workspace.spinning("Updating Akan.js packages and CLI...");
-    await this.cloudRunner.update(workspace, tag);
-    spinner.succeed("Akan.js packages and CLI updated, global version is below");
-    Logger.raw("> Akan version: ");
-    await workspace.spawn("akan", ["--version"], { stdio: "inherit" });
-  }
-}

package/cli/guideline/guideline.command.ts

@@ -1,31 +0,0 @@
-import { command, Workspace } from "akanjs/devkit";
-
-import { GuidelineScript } from "./guideline.script";
-
-export class GuidelineCommand extends command("guideline", [GuidelineScript], ({ public: target }) => ({
-  generateInstruction: target({ devOnly: true, desc: "Generate AI development guideline/instruction for your project" })
-    .arg("name", String, { ask: "name of the instruction", nullable: true })
-    .with(Workspace)
-    .exec(async function (name, workspace) {
-      await this.guidelineScript.generateInstruction(workspace, name);
-    }),
-  updateInstruction: target({ devOnly: true, desc: "Update existing AI guideline/instruction" })
-    .arg("name", String, { ask: "name of the instruction", nullable: true })
-    .option("request", String, { ask: "What do you want to update?" })
-    .with(Workspace)
-    .exec(async function (name, request, workspace) {
-      await this.guidelineScript.updateInstruction(workspace, name, request);
-    }),
-  generateDocument: target({ devOnly: true, desc: "Generate documentation from guideline/instruction" })
-    .arg("name", String, { ask: "name of the instruction", nullable: true })
-    .with(Workspace)
-    .exec(async function (name, workspace) {
-      await this.guidelineScript.generateDocument(workspace, name);
-    }),
-  reapplyInstruction: target({ devOnly: true, desc: "Re-apply guideline/instruction to codebase" })
-    .arg("name", String, { ask: "name of the instruction", nullable: true })
-    .with(Workspace)
-    .exec(async function (name, workspace) {
-      await this.guidelineScript.reapplyInstruction(workspace, name);
-    }),
-})) {}