@akanjs/cli 2.4.0-rc.9 → 2.4.1-rc.0

package/workspace.command-vrws0rgx.js

@@ -0,0 +1,435 @@
+// @bun
+import {
+  ContextScript
+} from "./index-qhtr07v8.js";
+import"./index-45aj5ry0.js";
+import {
+  CloudScript
+} from "./index-b0brjbp3.js";
+import"./index-y3hdhy4p.js";
+import"./index-73pr2cmy.js";
+import"./index-85msc0wg.js";
+import"./index-1xdrsbry.js";
+import {
+  AgentScript
+} from "./index-hwzpw9c1.js";
+import"./index-8rc0bm04.js";
+import {
+  getLatestPackageVersion,
+  getNpmRegistryUrl
+} from "./index-w7fyqjrw.js";
+import {
+  ApplicationScript
+} from "./index-9sp6fsc5.js";
+import"./index-76rn3g2c.js";
+import {
+  LibraryScript
+} from "./index-pmm9e2jf.js";
+import {
+  PackageScript
+} from "./index-wq8jwx8z.js";
+import"./index-8pkbzj26.js";
+import"./index-swf4bmbg.js";
+import"./index-ss469dec.js";
+import"./index-qaq13qk3.js";
+import"./index-h6ca6qg0.js";
+import {
+  GlobalConfig
+} from "./index-5vvwc0cz.js";
+import {
+  Exec,
+  Workspace,
+  command,
+  runner,
+  script
+} from "./index-hdqztm58.js";
+import"./index-fgc8r6dj.js";
+import {
+  AppExecutor,
+  LibExecutor,
+  PkgExecutor,
+  WorkspaceExecutor
+} from "./index-a6sbyy0b.js";
+import"./index-x53a5nya.js";
+import {
+  FileSys
+} from "./index-61keag0s.js";
+import"./index-6pz1j0zj.js";
+import"./index-r24hmh0q.js";
+
+// pkgs/@akanjs/cli/workspace/workspace.script.ts
+import path2 from "path";
+import { Logger } from "akanjs/common";
+
+// pkgs/@akanjs/cli/workspace/workspace.runner.ts
+import path from "path";
+var defaultWorkspacePeerDependencies = new Set([
+  "@react-spring/web",
+  "@use-gesture/react",
+  "chance",
+  "croner",
+  "daisyui",
+  "react",
+  "react-dom",
+  "react-icons",
+  "react-refresh",
+  "react-server-dom-webpack",
+  "react-spring",
+  "scheduler",
+  "tailwind-scrollbar",
+  "tailwindcss",
+  "typescript"
+]);
+
+class WorkspaceRunner extends runner("workspace") {
+  async generateAgentRules(workspace, { overwrite = false, cursorRules = true } = {}) {
+    const [appNames] = await workspace.getExecs();
+    const dict = {
+      repoName: workspace.repoName,
+      appName: appNames[0] ?? "app"
+    };
+    const created = await workspace.applyTemplate({
+      basePath: ".",
+      template: "workspaceRoot/AGENTS.md.template",
+      dict,
+      overwrite
+    });
+    created.push(...await workspace.applyTemplate({
+      basePath: ".",
+      template: "workspaceRoot/CLAUDE.md.template",
+      dict,
+      overwrite
+    }));
+    if (!cursorRules)
+      return created;
+    return [
+      ...created,
+      ...await workspace.applyTemplate({
+        basePath: ".cursor/rules",
+        template: "workspaceRoot/.cursor/rules/akan.mdc.template",
+        dict,
+        overwrite
+      })
+    ];
+  }
+  async createWorkspace(repoName, appName, {
+    dirname = ".",
+    init = true,
+    akanVersion,
+    registryUrl,
+    owner = ""
+  }) {
+    const cwdPath = process.cwd();
+    const workspaceRoot = path.join(cwdPath, dirname, repoName);
+    const normalizedRegistryUrl = registryUrl ? getNpmRegistryUrl(registryUrl) : undefined;
+    const workspace = WorkspaceExecutor.fromRoot({ workspaceRoot, repoName });
+    const templateSpinner = workspace.spinning(`Creating workspace template files in ${dirname}/${repoName}...`);
+    const [latestBiomeVersion, latestTypesBunVersion] = await Promise.all([
+      getLatestPackageVersion("@biomejs/biome", "latest", normalizedRegistryUrl),
+      getLatestPackageVersion("@types/bun", "latest", normalizedRegistryUrl)
+    ]);
+    await workspace.applyTemplate({
+      basePath: ".",
+      template: "workspaceRoot",
+      dict: { repoName, appName, serveDomain: "localhost", owner }
+    });
+    if (normalizedRegistryUrl)
+      await workspace.writeFile(".npmrc", `registry=${normalizedRegistryUrl}/
+`);
+    templateSpinner.succeed(`Workspace files created in ${dirname}/${repoName}`);
+    const [rootPackageJson, peerDependencies] = await Promise.all([
+      workspace.getPackageJson(),
+      this.#getAkanPeerDependencies()
+    ]);
+    const { typescript, ...dependencies } = peerDependencies;
+    const packageJson = {
+      ...rootPackageJson,
+      dependencies: {
+        ...rootPackageJson.dependencies,
+        ...dependencies,
+        akanjs: akanVersion
+      },
+      devDependencies: {
+        ...rootPackageJson.devDependencies,
+        "@biomejs/biome": latestBiomeVersion,
+        "@types/bun": latestTypesBunVersion,
+        "@akanjs/devkit": akanVersion,
+        ...typescript ? { typescript } : {}
+      }
+    };
+    await workspace.setPackageJson(packageJson);
+    if (init) {
+      const installSpinner = workspace.spinning("Installing dependencies with bun...");
+      await workspace.spawn("bun", ["install"]);
+      installSpinner.succeed("Dependencies installed with bun");
+    }
+    return workspace;
+  }
+  async#getAkanPeerDependencies() {
+    const [packageJson, cliPackageJson] = await Promise.all([this.#getAkanPackageJson(), this.#getCliPackageJson()]);
+    const dependencyVersions = {
+      ...packageJson.dependencies,
+      ...packageJson.peerDependencies,
+      ...cliPackageJson.dependencies
+    };
+    return Object.fromEntries(Object.entries(dependencyVersions).filter(([dependency]) => defaultWorkspacePeerDependencies.has(dependency)));
+  }
+  async#getCliPackageJson() {
+    const packageJsonCandidates = [
+      path.join(import.meta.dir, "../package.json"),
+      path.join(import.meta.dir, "package.json"),
+      path.join(path.dirname(Bun.main), "package.json")
+    ];
+    try {
+      packageJsonCandidates.unshift(Bun.resolveSync("@akanjs/cli/package.json", import.meta.dir));
+    } catch {}
+    for (const packageJsonPath of packageJsonCandidates) {
+      if (!await Bun.file(packageJsonPath).exists())
+        continue;
+      const packageJson = await FileSys.readJson(packageJsonPath);
+      if (packageJson.name === "@akanjs/cli")
+        return packageJson;
+    }
+    return { name: "@akanjs/cli", version: "0.0.0", description: "@akanjs/cli" };
+  }
+  async#getAkanPackageJson() {
+    const packageJsonCandidates = [
+      path.join(import.meta.dir, "../../../akanjs/package.json"),
+      path.join(process.cwd(), "pkgs/akanjs/package.json"),
+      path.join(path.dirname(Bun.main), "node_modules/akanjs/package.json")
+    ];
+    try {
+      packageJsonCandidates.unshift(Bun.resolveSync("akanjs/package.json", import.meta.dir));
+    } catch {}
+    for (const packageJsonPath of packageJsonCandidates) {
+      if (!await Bun.file(packageJsonPath).exists())
+        continue;
+      const packageJson = await FileSys.readJson(packageJsonPath);
+      if (packageJson.name === "akanjs")
+        return packageJson;
+    }
+    let current = import.meta.dir;
+    for (let depth = 0;depth < 6; depth++) {
+      const packageJsonPath = path.join(current, "package.json");
+      if (await Bun.file(packageJsonPath).exists()) {
+        const packageJson = await FileSys.readJson(packageJsonPath);
+        if (packageJson.name === "akanjs")
+          return packageJson;
+      }
+      const parent = path.dirname(current);
+      if (parent === current)
+        break;
+      current = parent;
+    }
+    throw new Error(`[workspace] failed to locate akanjs package.json from ${import.meta.dir}`);
+  }
+  async lint(exec, workspace, { fix = true } = {}) {
+    await workspace.spawn("./node_modules/.bin/biome", [
+      "check",
+      ...fix ? ["--write"] : [],
+      "--no-errors-on-unmatched",
+      exec.cwdPath
+    ]);
+  }
+  async writeTopLevelEnv(workspace, devProjectId) {
+    await workspace.writeFile(".env", `AKAN_WORKSPACE_ID=${devProjectId}
+
+# organization configuration, no need to change
+AKAN_PUBLIC_REPO_NAME=${workspace.repoName}
+
+# serve domain, it changes the domain of the server.
+AKAN_PUBLIC_SERVE_DOMAIN=try.akanjs.com
+
+# development branch, debug, develop, main, etc. mainly it changes databases.
+AKAN_PUBLIC_ENV=local
+
+# local, cloud, edge it changes the connection point of the clients.
+AKAN_PUBLIC_OPERATION_MODE=local
+
+# log level, debug, info, warn, error
+AKAN_PUBLIC_LOG_LEVEL=debug
+`);
+  }
+}
+
+// pkgs/@akanjs/cli/workspace/workspace.script.ts
+class WorkspaceScript extends script("workspace", [
+  WorkspaceRunner,
+  ApplicationScript,
+  LibraryScript,
+  PackageScript,
+  CloudScript,
+  ContextScript,
+  AgentScript
+]) {
+  async createWorkspace(repoName, appName, {
+    dirname = ".",
+    installLibs = false,
+    init = true,
+    registryUrl,
+    owner,
+    mcpInstall = true,
+    agentInstall = true
+  }) {
+    const akanVersion = await this.packageScript.version(null, { log: false });
+    const workspace = await this.workspaceRunner.createWorkspace(repoName, appName, {
+      dirname,
+      init,
+      akanVersion,
+      ...registryUrl ? { registryUrl } : {},
+      ...owner ? { owner } : {}
+    });
+    if (installLibs) {
+      await this.libraryScript.installLibrary(workspace, "util");
+      await this.libraryScript.installLibrary(workspace, "shared");
+    }
+    await this.applicationScript.createApplication(appName, workspace, { libs: installLibs ? ["util", "shared"] : [] });
+    await workspace.applyTemplate({
+      basePath: `apps/${appName}`,
+      template: "appSample",
+      dict: { appName },
+      options: { libs: installLibs ? ["util", "shared"] : [] }
+    });
+    if (agentInstall)
+      await this.agentScript.agent(workspace, "install", "all", { force: true });
+    if (mcpInstall)
+      await this.contextScript.mcpInstall(workspace, "all", { force: true });
+    const gitSpinner = workspace.spinning("Initializing git repository and commit...");
+    try {
+      await workspace.commit("Initial commit", { init: true });
+      gitSpinner.succeed("Git repository initialized and committed");
+    } catch (_) {
+      gitSpinner.fail("Git repository initialization failed. It's not fatal, you can commit manually");
+    }
+    const workspacePath = path2.join(dirname, repoName);
+    Logger.rawLog(`
+\uD83C\uDF89 Welcome aboard! Workspace created in ${dirname}/${repoName}`);
+    Logger.rawLog(`\uD83D\uDE80 Run \`cd ${workspacePath} && akan start ${appName}\` to start the development server.`);
+    Logger.rawLog(`
+\uD83D\uDC4B Happy coding!`);
+  }
+  async generateAgentRules(workspace, { overwrite = false, cursorRules = true } = {}) {
+    const spinner = workspace.spinning("Generating agent rules...");
+    const files = await this.workspaceRunner.generateAgentRules(workspace, { overwrite, cursorRules });
+    spinner.succeed(`Agent rules ready (${files.length} file${files.length === 1 ? "" : "s"})`);
+  }
+  async lint(exec, workspace, { fix = true } = {}) {
+    if (exec instanceof AppExecutor)
+      await this.applicationScript.sync(exec);
+    else if (exec instanceof LibExecutor)
+      await this.libraryScript.syncLibrary(exec);
+    const spinner = workspace.spinning(`Linting${fix ? " with fix" : ""}...`);
+    try {
+      await this.workspaceRunner.lint(exec, workspace, { fix });
+      spinner.succeed("Lint completed with no errors");
+    } catch (error) {
+      spinner.fail("Lint failed with errors");
+      throw error;
+    }
+  }
+  async lintAll(workspace, { fix = true } = {}) {
+    const [appNames, libNames, pkgNames] = await workspace.getExecs();
+    await Promise.all(appNames.map((appName) => this.applicationScript.sync(AppExecutor.from(workspace, appName))));
+    await Promise.all(libNames.map((libName) => this.libraryScript.syncLibrary(LibExecutor.from(workspace, libName))));
+    await Promise.all([
+      ...appNames.map((appName) => this.workspaceRunner.lint(AppExecutor.from(workspace, appName), workspace, { fix })),
+      ...libNames.map((libName) => this.workspaceRunner.lint(LibExecutor.from(workspace, libName), workspace, { fix })),
+      ...pkgNames.filter((pkgName) => pkgName !== "contract").map((pkgName) => this.workspaceRunner.lint(PkgExecutor.from(workspace, pkgName), workspace, { fix }))
+    ]);
+  }
+  async syncAll(workspace) {
+    const [appNames, libNames] = await workspace.getExecs();
+    for (const libName of libNames)
+      await this.libraryScript.syncLibrary(LibExecutor.from(workspace, libName));
+    for (const appName of appNames)
+      await this.applicationScript.sync(AppExecutor.from(workspace, appName));
+  }
+  async init(devProjectId, workspace, { host } = {}) {
+    const [bunfigExists, packageJsonExists, tsconfigExists] = await Promise.all([
+      workspace.exists("bunfig.toml"),
+      workspace.exists("package.json"),
+      workspace.exists("tsconfig.json")
+    ]);
+    const isRoot = bunfigExists && packageJsonExists && tsconfigExists;
+    if (!isRoot)
+      throw new Error("Current directory is not a root workspace");
+    const spinner = workspace.spinning("Initializing workspace...");
+    try {
+      await this.workspaceRunner.writeTopLevelEnv(workspace, devProjectId);
+      await this.cloudScript.downloadEnv(workspace, devProjectId, { host });
+      spinner.succeed("Workspace initialized");
+    } catch (error) {
+      spinner.fail("Workspace initialization failed");
+      throw error;
+    }
+  }
+}
+
+// pkgs/@akanjs/cli/workspace/workspace.command.ts
+class WorkspaceCommand extends command("workspace", [WorkspaceScript], ({ public: target }) => ({
+  createWorkspace: target({ desc: "Create a new Akan.js workspace", runsOnWorkspaceRoot: false }).arg("workspaceName", String, { desc: "what is the name of your organization?" }).option("app", String, {
+    desc: "what is the codename of your first application? (e.g. myapp)"
+  }).option("dir", String, {
+    desc: "directory of workspace",
+    default: process.env.USE_AKANJS_PKGS === "true" ? "local" : "."
+  }).option("libs", Boolean, {
+    desc: "Do you want to install shared and util libraries? (admin, user file, etc.)",
+    enum: [
+      { label: "No, I want to start with empty workspace (Recommended)", value: false },
+      {
+        label: "Yes, I want to accelerate development by installing shared and util libraries (for akanjs experts)",
+        value: true
+      }
+    ],
+    default: false
+  }).option("init", Boolean, {
+    desc: "Do you want to initialize the workspace? (Recommended)",
+    default: true
+  }).option("registry", String, {
+    desc: "npm registry URL for installing Akan packages",
+    default: process.env.AKAN_NPM_REGISTRY ?? "https://registry.npmjs.org"
+  }).option("owner", String, {
+    desc: "owner of the workspace",
+    default: process.env.GITHUB_OWNER,
+    nullable: true
+  }).option("mcpInstall", Boolean, {
+    desc: "Install the Akan MCP server config for Cursor, Claude Code, and Codex? (Recommended)",
+    default: true
+  }).option("agentInstall", Boolean, {
+    flag: "A",
+    desc: "Install Akan agent rules (AGENTS.md, CLAUDE.md, Cursor)? (Recommended)",
+    default: true
+  }).exec(async function(workspaceName, app, dir, libs, init, registry, owner, mcpInstall, agentInstall) {
+    const appName = app || "app";
+    await this.workspaceScript.createWorkspace(workspaceName.toLowerCase().replace(/ /g, "-"), appName.toLowerCase().replace(/ /g, "-"), {
+      dirname: dir,
+      installLibs: libs,
+      init,
+      owner,
+      mcpInstall,
+      agentInstall,
+      ...registry ? { registryUrl: registry } : {}
+    });
+  }),
+  generateAgentRules: target({
+    desc: "Generate AGENTS.md, CLAUDE.md, and optional Cursor rules for Akan coding agents"
+  }).option("overwrite", Boolean, { desc: "Overwrite existing agent rule files", default: false }).option("cursorRules", Boolean, { desc: "Generate .cursor/rules/akan.mdc", default: true }).with(Workspace).exec(async function(overwrite, cursorRules, workspace) {
+    await this.workspaceScript.generateAgentRules(workspace, { overwrite, cursorRules });
+  }),
+  lint: target({ desc: "Lint and fix code in a specific app/lib/pkg" }).with(Exec).option("fix", Boolean, { default: true }).with(Workspace).exec(async function(exec, fix, workspace) {
+    await this.workspaceScript.lint(exec, workspace, { fix });
+  }),
+  lintAll: target({ desc: "Lint and fix code in all apps and libraries" }).option("fix", Boolean, { default: true }).with(Workspace).exec(async function(fix, workspace) {
+    await this.workspaceScript.lintAll(workspace, { fix });
+  }),
+  syncAll: target({ desc: "Sync dependencies and configuration for all apps and libraries" }).with(Workspace).exec(async function(workspace) {
+    await this.workspaceScript.syncAll(workspace);
+  }),
+  init: target({ desc: "Initialize the workspace", runsOnWorkspaceRoot: false }).arg("devProjectId", String, { desc: "the ID of the workspace" }).option("host", String, { desc: "host of the cloud to target", default: GlobalConfig.akanCloudHost }).with(Workspace).exec(async function(devProjectId, host, workspace) {
+    await this.workspaceScript.init(devProjectId, workspace, { host });
+  })
+})) {
+}
+export {
+  WorkspaceCommand
+};

package/README.ko.md

@@ -1,72 +0,0 @@
-# @akanjs/cli
-
-[문서](https://akanjs.com/docs) | [npm](https://www.npmjs.com/package/@akanjs/cli) | [런타임](https://www.npmjs.com/package/akanjs)
-
-Akan.js 워크스페이스를 위한 command-line tooling입니다.
-
-`@akanjs/cli`는 Akan 애플리케이션, 라이브러리, 프레임워크 패키지를 생성, 빌드, 테스트, 린트,
-릴리즈, 유지보수하는 데 사용하는 `akan` 실행 파일을 제공합니다. Bun-first CLI 패키지이며 Akan
-개발 tooling을 내부에 번들링하므로, 애플리케이션 런타임은 더 작은 `akanjs` 패키지에만 의존할 수
-있습니다.
-
-## 설치
-
-새 워크스페이스를 바로 만들 수 있습니다.
-
-```bash
-bunx create-akan-workspace@latest
-```
-
-또는 CLI를 전역으로 설치할 수 있습니다.
-
-```bash
-bun install -g @akanjs/cli@latest
-akan --help
-```
-
-## 자주 쓰는 명령
-
-```bash
-akan create-workspace <workspace-name>
-akan start <app-name>
-akan build <app-name>
-akan test <app-or-lib-or-pkg>
-akan lint <app-or-lib-or-pkg>
-akan create-application <app-name>
-akan create-library <lib-name>
-akan create-module <module-name>
-akan create-scalar <scalar-name>
-```
-
-패키지 유지보수 명령도 같은 실행 파일에서 제공합니다.
-
-```bash
-akan build-package akanjs
-akan build-package @akanjs/cli
-akan build-package @akanjs/devkit
-akan build-package create-akan-workspace
-akan verify-akan-publish-packages
-akan smoke-registry --test=true --tag=rc
-```
-
-Akan framework 패키지는 반드시 `dist/pkgs/*` 산출물 기준으로 publish합니다. `verify-akan-publish-packages`는
-빌드된 패키지에 `npm pack --dry-run --json`을 실행하고, `deploy-akan` 또는 local registry smoke 전에 필요한
-metadata를 검증합니다.
-저장소 릴리즈에서는 root `akan` bootstrap script가 CLI dist를 덮어쓰지 않도록
-`bun run release:build-packages && bun run release:verify-packages`를 우선 사용합니다.
-
-## 패키지 경계
-
-- 애플리케이션과 런타임 코드는 `akanjs`를 사용합니다.
-- 사용자-facing 실행 패키지는 `@akanjs/cli`입니다.
-- `@akanjs/devkit`은 published CLI 사용을 위해 CLI 안에 번들링됩니다. 일반 CLI 사용자가 별도의
-  runtime dependency로 설치할 필요는 없습니다.
-
-## 요구사항
-
-- [Bun](https://bun.sh) `>=1.3.13`
-- TypeScript 기반 Akan 워크스페이스
-
-## 라이선스
-
-MIT

package/README.md

@@ -1,85 +0,0 @@
-# @akanjs/cli
-
-[Docs](https://akanjs.com/docs) | [npm](https://www.npmjs.com/package/@akanjs/cli) | [Runtime](https://www.npmjs.com/package/akanjs)
-
-Command-line tooling for Akan.js workspaces.
-
-`@akanjs/cli` provides the `akan` executable used to create, build, test, lint, release, and maintain Akan
-applications, libraries, and framework packages. It is a Bun-first CLI package and bundles Akan development
-tooling internally so application runtimes can depend on the smaller `akanjs` package.
-
-## Install
-
-Create a new workspace:
-
-```bash
-bunx create-akan-workspace@latest
-```
-
-Or install the CLI globally:
-
-```bash
-bun install -g @akanjs/cli@latest
-akan --help
-```
-
-## Common Commands
-
-```bash
-akan create-workspace <workspace-name>
-akan start <app-name>
-akan build <app-name>
-akan test <app-or-lib-or-pkg>
-akan lint <app-or-lib-or-pkg>
-akan create-application <app-name>
-akan create-library <lib-name>
-akan create-module <module-name>
-akan create-scalar <scalar-name>
-```
-
-## Agent And MCP Commands
-
-```bash
-akan context --format markdown
-akan context --format json --module <module-name>
-akan doctor --format json
-akan guideline list
-akan guideline show framework
-akan agent install cursor
-akan mcp
-```
-
-These commands expose Akan workspace structure, module abstracts, diagnostics, and guideline instructions for
-coding agents. The MCP server is read-only and is intended to provide context rather than edit files directly.
-
-Package maintenance commands are also exposed through the same executable:
-
-```bash
-akan build-package akanjs
-akan build-package @akanjs/cli
-akan build-package @akanjs/devkit
-akan build-package create-akan-workspace
-akan verify-akan-publish-packages
-akan smoke-registry --test=true --tag=rc
-```
-
-Publish Akan framework packages from `dist/pkgs/*` only. `verify-akan-publish-packages` runs `npm pack --dry-run --json`
-against the built packages and checks metadata that must be correct before `deploy-akan` or local registry smoke.
-For repository releases, prefer `bun run release:build-packages && bun run release:verify-packages` so the CLI package
-artifact is built last and is not overwritten by the root `akan` bootstrap script.
-
-## Package Boundary
-
-- Use `akanjs` from application and runtime code.
-- Use `@akanjs/cli` as the user-facing executable package.
-- `@akanjs/devkit` is bundled into the CLI for published CLI usage; it is not required as a separate
-  runtime dependency for ordinary CLI users.
-
-## Requirements
-
-- [Bun](https://bun.sh) `>=1.3.13`
-- A TypeScript Akan workspace
-
-## License
-
-MIT