akanjs 0.0.1 → 2.0.0-beta.0

package/cli/cloud/cloud.runner.ts

@@ -0,0 +1,158 @@
+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 latestVersion from "latest-version";
+import open from "open";
+import * as QRcode from "qrcode";
+import { v4 as uuidv4 } from "uuid";
+
+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 = uuidv4();
+    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 open(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 latestVersion("akanjs", { version: tag });
+        const latestPatch = latestPublishedVersion.startsWith(prefix)
+          ? parseInt(latestPublishedVersion.split(".").at(-1) ?? "-1")
+          : -1;
+        const nextVersion = `${prefix}.${latestPatch + 1}`;
+        return { nextVersion, latestPublishedVersion };
+      } catch (e) {
+        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 latestVersion("akanjs", { version: 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

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,31 @@
+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);
+    }),
+})) {}

package/cli/guideline/guideline.prompt.ts

@@ -0,0 +1,212 @@
+import { randomPicks } from "akanjs/common";
+import { type FileContent, FileSys, type GuideScan, getDirname, Prompter, type Workspace } from "akanjs/devkit";
+
+export class GuidelinePrompt extends Prompter {
+  constructor(
+    readonly workspace: Workspace,
+    readonly name: string,
+  ) {
+    super();
+  }
+  async #getScanFilePaths(
+    matchPattern: string,
+    { avoidDirs = ["node_modules", ".next"], filterText }: { avoidDirs?: string[]; filterText?: string } = {},
+  ): Promise<string[]> {
+    const glob = new Bun.Glob(matchPattern);
+    const paths: string[] = [];
+    for await (const path of glob.scan({ cwd: this.workspace.workspaceRoot, absolute: true })) {
+      if (avoidDirs.some((dir) => path.includes(dir))) continue;
+      const fileContent = await FileSys.readText(path);
+      const textFilter = filterText ? new RegExp(filterText) : null;
+      if (filterText && !textFilter?.test(fileContent)) continue;
+      paths.push(path);
+    }
+    return paths;
+  }
+  async requestCreateInstruction() {
+    const guideJson = await Prompter.getGuideJson(this.name);
+    const scanFiles: (GuideScan & FileContent)[] = [];
+    for (const scan of guideJson.scans) {
+      const scanFilePaths = await this.#getScanFilePaths(scan.path, { filterText: scan.filterText });
+      const targetFilePaths = scan.sample ? randomPicks(scanFilePaths, scan.sample) : scanFilePaths;
+      const scanResult = await Promise.all(
+        targetFilePaths.map(async (filePath) => ({ ...scan, ...(await this.workspace.getLocalFile(filePath)) })),
+      );
+      scanFiles.push(...scanResult);
+    }
+    const resultPath = `${getDirname(import.meta.url)}/../guidelines/${this.name}/${guideJson.update.filePath}`;
+    const writePath = `${this.workspace.workspaceRoot}/pkgs/akanjs/cli/guidelines/${this.name}/${guideJson.update.filePath}`;
+    const isResultExists = await this.workspace.exists(writePath);
+    const existingResult = isResultExists ? await this.workspace.readFile(resultPath) : null;
+    const request = `
+I am a developer of akanjs framework, a full-stack framework for building web applications.
+I want to generate a ${guideJson.update.filePath} file for ${guideJson.description}.
+This file is a programming guideline for Akan.js framwork users.
+
+# ${guideJson.title} Workflow
+- 1. Explore target files in ${guideJson.scans.map((scan) => scan.path).join(", ")}.
+- 2. Read already-written ${guideJson.update.filePath} file if exists. There can be some outdated information, so you need to update the file and add new information, make it more accurate and more detailed.
+- 3. Write the updated file content of the ${guideJson.update.filePath}. It should include the contents of ${guideJson.update.contents.join(",")}, and any other helpful information and contents for guiding.  Also, you can rearrange the contents if you think it's more helpful.
+
+## 1. Explore target files in ${guideJson.scans.map((scan) => scan.path).join(", ")}.
+${scanFiles
+  .map(
+    ({ type, description, filePath, content, sample }) => `
+\`\`\`${filePath.endsWith(".tsx") ? "tsx" : "typescript"}
+${content}
+\`\`\`
+`,
+  )
+  .join("\n")}
+
+## 2. Read already-written ${guideJson.update.filePath} file if exists. There can be some outdated information, so you need to update the file and add new information, make it more accurate and more detailed.
+${
+  existingResult
+    ? `\`\`\`markdown
+${existingResult}
+\`\`\``
+    : "- No existing guideline file."
+}
+
+## 3. Write the updated file content of the ${guideJson.update.filePath}. It should include the contents of ${guideJson.update.contents.join(",")}, and any other helpful information and contents for guiding. Also, you can rearrange the contents if you think it's more helpful.
+
+Here's the last rules for writing the file content:
+${guideJson.update.rules.map((rule) => `- ${rule}`).join("\n")}
+
+=> Now, you need to write the file content here. Let's go.
+`;
+    return { guideJson, request, writePath };
+  }
+  async requestUpdateInstruction(updateRequest: string) {
+    const guideJson = await Prompter.getGuideJson(this.name);
+    const resultPath = `${getDirname(import.meta.url)}/../guidelines/${this.name}/${guideJson.update.filePath}`;
+    const writePath = `${this.workspace.workspaceRoot}/pkgs/akanjs/cli/guidelines/${this.name}/${guideJson.update.filePath}`;
+    const isResultExists = await this.workspace.exists(writePath);
+    if (!isResultExists) throw new Error(`${guideJson.update.filePath} file does not exist. Please create it first.`);
+    const existingResult = await this.workspace.readFile(resultPath);
+    const request = `
+I am a developer of akanjs framework, a full-stack framework for building web applications.
+I want to update a ${guideJson.update.filePath} file for ${guideJson.description}.
+This file is a programming guideline for Akan.js framwork users.
+
+# ${guideJson.title} Workflow
+- 1. Read already-written ${guideJson.update.filePath} file.
+- 2. Write the updated file content of the ${guideJson.update.filePath} with the update request.
+
+## 1. Read already-written ${guideJson.update.filePath} file.
+\`\`\`markdown
+${existingResult}
+\`\`\`
+
+## 2. Write the updated file content of the ${guideJson.update.filePath} with the update request.
+Request: ${updateRequest}
+
+=> Now, you need to write the file content here. Let's go.
+`;
+    return { guideJson, request, writePath };
+  }
+  async requestCreateDocumentPage(page: string) {
+    const writePath = `apps/angelo/app${page}`;
+    if (!(await this.workspace.exists(writePath)))
+      await this.workspace.writeFile(
+        writePath,
+        `export default function Page() {
+  return <div>No Content</div>;
+}
+`,
+      );
+    const instruction = await Prompter.getInstruction(this.name);
+    const pageContent = await this.workspace.getLocalFile(writePath);
+    const request = `
+I'm creating a documentation website for the Akan.js framework.
+
+1. Overview of the Akan.js framework
+${await this.getDocumentation("framework")}
+
+2. Documentation page writing method
+${await this.getDocumentation("docPageRule")}
+
+3. CSS rule with TailwindCSS and DaisyUI
+${await this.getDocumentation("cssRule")}
+
+I want to update the Next.js server-side page located at ${writePath}.
+Below is the content of the currently written page.
+\`\`\`tsx
+${pageContent.content}
+\`\`\`
+
+Please update this page with the latest content below. A great design application is needed.
+${instruction}
+
+Please follow these CSS rules when writing:
+- Use tailwindcss
+- Use className from the daisyui library
+
+Please return only the file result in the following format for easy parsing.
+\`\`\`tsx
+...pageContent
+\`\`\`
+`;
+    return { request, writePath };
+  }
+  async requestUpdateDocumentPage(page: string, updateRequest: string) {
+    const writePath = `apps/angelo/app${page}`;
+    if (!(await this.workspace.exists(writePath)))
+      await this.workspace.writeFile(
+        writePath,
+        `export default function Page() {
+  return <div>No Content</div>;
+}
+`,
+      );
+    const instruction = await Prompter.getInstruction(this.name);
+    const pageContent = await this.workspace.getLocalFile(writePath);
+    const request = `
+I'm updating a documentation website for the Akan.js framework.
+
+I want to update the Next.js server-side page located at ${writePath}.
+Below is the content of the currently written page. You should update stale infos and preserve the existing content.
+\`\`\`tsx
+${pageContent.content}
+\`\`\`
+
+The existing instruction is below.
+\`\`\`markdown
+${instruction}
+\`\`\`
+
+Please update this page with the request below.
+${updateRequest}
+
+Please return only the file result in the following format for easy parsing.
+\`\`\`tsx
+...pageContent
+\`\`\`
+`;
+    return { request, writePath };
+  }
+  async requestReapplyInstruction(filePath: string) {
+    const guideJson = await Prompter.getGuideJson(this.name);
+    const writePath = `${this.workspace.workspaceRoot}/pkgs/akanjs/cli/guidelines/${this.name}/${guideJson.update.filePath}`;
+    if (!guideJson.page) throw new Error(`${this.name} does not have a page.`);
+    const pagePath = `apps/angelo/app${guideJson.page}`;
+    const pageFile = await this.workspace.getLocalFile(pagePath);
+
+    const request = `
+I want to apply information in the Next.js page to markdown instruction file.
+
+Here's the newest information in the Next.js page.
+\`\`\`tsx
+${pageFile.content}
+\`\`\`
+
+Here's the existing instruction file.
+\`\`\`markdown
+${await Prompter.getInstruction(this.name)}
+\`\`\`
+
+Please update the instruction file with the information in the Next.js page.
+`;
+    return { request, writePath };
+  }
+}

package/cli/guideline/guideline.runner.ts

@@ -0,0 +1,53 @@
+import { AiSession, Prompter, runner, type Workspace } from "akanjs/devkit";
+
+import { GuidelinePrompt } from "./guideline.prompt";
+
+export class GuidelineRunner extends runner("guideline") {
+  async generateInstruction(workspace: Workspace, guideName: string) {
+    const session = new AiSession("generateInstruction", { workspace, cacheKey: guideName });
+    const prompt = new GuidelinePrompt(workspace, guideName);
+    const { guideJson, request, writePath } = await prompt.requestCreateInstruction();
+    const guidelineContent = await session.editMarkdown(request);
+    await workspace.writeFile(writePath, guidelineContent);
+    return { guideJson, session };
+  }
+  async updateInstruction(workspace: Workspace, guideName: string, { updateRequest }: { updateRequest: string }) {
+    const session = new AiSession("updateInstruction", { workspace, cacheKey: guideName });
+    const prompt = new GuidelinePrompt(workspace, guideName);
+    const { guideJson, request, writePath } = await prompt.requestUpdateInstruction(updateRequest);
+    const guidelineContent = await session.editMarkdown(request);
+    await workspace.writeFile(writePath, guidelineContent);
+    return { guideJson, session };
+  }
+
+  async generateDocument(workspace: Workspace, guideName: string) {
+    const session = new AiSession("deployDocPages", { workspace, cacheKey: guideName });
+    const guideJson = await Prompter.getGuideJson(guideName);
+    const prompt = new GuidelinePrompt(workspace, guideName);
+    if (!guideJson.page) return Promise.resolve({});
+    const { request } = await prompt.requestCreateDocumentPage(guideJson.page);
+    await session.writeTypescripts(request, workspace);
+  }
+
+  async updateDocument(
+    workspace: Workspace,
+    guideName: string,
+    { updateRequest, session }: { updateRequest: string; session: AiSession },
+  ) {
+    const guideJson = await Prompter.getGuideJson(guideName);
+    if (!guideJson.page) throw new Error(`${guideName} does not have a page.`);
+    const prompt = new GuidelinePrompt(workspace, guideName);
+    const { request, writePath } = await prompt.requestUpdateDocumentPage(guideJson.page, updateRequest);
+    const guidelineContent = await session.editMarkdown(request);
+    await workspace.writeFile(writePath, guidelineContent);
+  }
+
+  async reapplyInstruction(workspace: Workspace, guideName: string) {
+    const session = new AiSession("reapplyInstruction", { workspace, cacheKey: guideName });
+    const guideJson = await Prompter.getGuideJson(guideName);
+    const prompt = new GuidelinePrompt(workspace, guideName);
+    const { request, writePath } = await prompt.requestReapplyInstruction(guideJson.update.filePath);
+    const guidelineContent = await session.editMarkdown(request);
+    await workspace.writeFile(writePath, guidelineContent);
+  }
+}

package/cli/guideline/guideline.script.ts

@@ -0,0 +1,33 @@
+import { type AiSession, Prompter, script, type Workspace } from "akanjs/devkit";
+
+import { GuidelineRunner } from "./guideline.runner";
+
+export class GuidelineScript extends script("guideline", [GuidelineRunner]) {
+  async generateInstruction(workspace: Workspace, name: string | null = null) {
+    const guideName = name ?? (await Prompter.selectGuideline());
+    await this.guidelineRunner.generateInstruction(workspace, guideName);
+  }
+  async updateInstruction(workspace: Workspace, name: string | null = null, updateRequest: string) {
+    const guideName = name ?? (await Prompter.selectGuideline());
+    const { guideJson, session } = await this.guidelineRunner.updateInstruction(workspace, guideName, {
+      updateRequest,
+    });
+    if (guideJson.page) await this.updateDocument(workspace, guideName, { updateRequest, session });
+  }
+  async generateDocument(workspace: Workspace, name: string | null = null) {
+    const guideName = name ?? (await Prompter.selectGuideline());
+    await this.guidelineRunner.generateDocument(workspace, guideName);
+  }
+  async updateDocument(
+    workspace: Workspace,
+    name: string | null = null,
+    { updateRequest, session }: { updateRequest: string; session: AiSession },
+  ) {
+    const guideName = name ?? (await Prompter.selectGuideline());
+    await this.guidelineRunner.updateDocument(workspace, guideName, { updateRequest, session });
+  }
+  async reapplyInstruction(workspace: Workspace, name: string | null = null) {
+    const guideName = name ?? (await Prompter.selectGuideline());
+    await this.guidelineRunner.reapplyInstruction(workspace, guideName);
+  }
+}