@akanjs/devkit 1.0.20 → 2.1.0-rc.1

package/commandDecorators/commandDecorators.test.ts

@@ -0,0 +1,212 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { App, getArgMetas, Lib, Module, Pkg, Sys, Workspace } from "./argMeta";
+import { command } from "./commandBuilder";
+import {
+  assertUniqueDependencies,
+  CommandContainer,
+  getDependencyKey,
+  injectDependencies,
+  runner,
+  script,
+} from "./dependencyBuilder";
+import { formatCommandHelp, formatHelp } from "./helpFormatter";
+import { getTargetMetas } from "./targetMeta";
+
+const ansiPattern = new RegExp(`${String.fromCharCode(27)}\\[[0-?]*[ -/]*[@-~]`, "g");
+const stripAnsi = (value: string) => value.replace(ansiPattern, "");
+
+describe("command helper metadata", () => {
+  afterEach(() => {
+    CommandContainer.clear();
+  });
+
+  test("records targets, args, options, and internal executor tokens", () => {
+    class ExampleRunner extends runner("example") {
+      run() {
+        return "ok";
+      }
+    }
+
+    class ExampleScript extends script("example", [ExampleRunner]) {
+      callRunner() {
+        return this.exampleRunner.run();
+      }
+    }
+
+    class ExampleCommand extends command("example", [ExampleScript], ({ public: publicTarget, dev }) => ({
+      createModule: publicTarget({ short: true, desc: "Create a module" })
+        .arg("moduleName", String, { desc: "module name", example: "user" })
+        .option("count", Number, { desc: "count", default: 1 })
+        .option("force", Boolean, { desc: "force", default: false })
+        .with(Workspace, App, Lib, Sys, Pkg, Module)
+        .exec(function (moduleName, count, force, workspace, app, lib, sys, pkg, module) {
+          expect(this.exampleScript.callRunner()).toBe("ok");
+          return { moduleName, count, force, workspace, app, lib, sys, pkg, module };
+        }),
+      devOnlyTask: dev({ devOnly: true, desc: "Hidden task" })
+        .arg("targetName", String)
+        .exec((targetName) => targetName),
+    })) {}
+
+    const targetMetas = getTargetMetas(ExampleCommand);
+    expect(targetMetas.map((target) => target.key)).toEqual(["createModule", "devOnlyTask"]);
+    expect(targetMetas[0]?.targetOption).toEqual({
+      runsOnWorkspaceRoot: true,
+      short: true,
+      desc: "Create a module",
+      type: "public",
+    });
+    expect(targetMetas[1]?.targetOption).toEqual({
+      runsOnWorkspaceRoot: true,
+      devOnly: true,
+      desc: "Hidden task",
+      type: "dev",
+    });
+
+    const [allArgMetas, optionMetas, internalArgMetas] = getArgMetas(ExampleCommand, "createModule");
+    expect(allArgMetas.map((arg) => [arg.type, arg.idx])).toEqual([
+      ["Argument", 0],
+      ["Option", 1],
+      ["Option", 2],
+      ["Workspace", 3],
+      ["App", 4],
+      ["Lib", 5],
+      ["Sys", 6],
+      ["Pkg", 7],
+      ["Module", 8],
+    ]);
+    expect(optionMetas.map((arg) => arg.name)).toEqual(["count", "force"]);
+    const internalArgTypes = internalArgMetas.map((arg) => arg.type as string);
+    expect(internalArgTypes).toEqual(["Argument", "Workspace", "App", "Lib", "Sys", "Pkg", "Module"]);
+
+    const commandInstance = CommandContainer.get(ExampleCommand);
+    const result = targetMetas[0]?.handler.call(
+      commandInstance,
+      "profile",
+      2,
+      true,
+      { name: "workspace" },
+      { name: "app" },
+      { name: "lib" },
+      { name: "sys" },
+      { name: "pkg" },
+      { name: "module" },
+    );
+    expect(result).toMatchObject({ moduleName: "profile", count: 2, force: true });
+  });
+
+  test("formats global and command help from helper metadata", () => {
+    class HelpCommand extends command("help", ({ public: publicTarget, dev }) => ({
+      buildApp: publicTarget({ desc: "Build app" })
+        .with(App)
+        .option("write", Boolean, { desc: "write generated files", default: true })
+        .option("mode", String, {
+          desc: "build mode",
+          enum: [
+            { label: "Fast", value: "fast" },
+            { label: "Full", value: "full" },
+          ],
+        })
+        .exec(() => undefined),
+      generateModule: publicTarget({ desc: "Generate module" })
+        .with(Module)
+        .arg("modelName", String, { desc: "model name" })
+        .exec(() => undefined),
+      hiddenTask: dev({ devOnly: true, desc: "Hidden task" }).exec(() => undefined),
+    })) {}
+
+    const globalHelp = stripAnsi(formatHelp([HelpCommand], "1.2.3"));
+    expect(globalHelp).toContain("Version: 1.2.3");
+    expect(globalHelp).toContain("build-app [app]");
+    expect(globalHelp).toContain("generate-module [sys:module] [modelName]");
+    expect(globalHelp).not.toContain("hidden-task");
+
+    const commandHelp = stripAnsi(formatCommandHelp(HelpCommand, "buildApp"));
+    expect(commandHelp).toContain("akan build-app [app]");
+    expect(commandHelp).toContain("--write");
+    expect(commandHelp).toContain("[default: true]");
+    expect(commandHelp).toContain("Fast, Full");
+  });
+});
+
+describe("command helper dependency injection", () => {
+  afterEach(() => {
+    CommandContainer.clear();
+  });
+
+  test("creates stable dependency keys and singleton injected instances", () => {
+    class StableRunner extends runner("stable") {
+      readonly id = Math.random();
+    }
+
+    class StableScript extends script("stable", [StableRunner]) {}
+
+    expect(StableRunner.refName).toBe("stable");
+    expect(StableRunner.dependencyKind).toBe("runner");
+    expect(StableRunner.dependencyKey).toBe("stableRunner");
+    expect(StableScript.dependencyKind).toBe("script");
+    expect(StableScript.dependencyKey).toBe("stableScript");
+    expect(getDependencyKey(StableScript)).toBe("stableScript");
+
+    const first = CommandContainer.get(StableScript);
+    const second = CommandContainer.get(StableScript);
+    expect(first).toBe(second);
+    expect(first.stableRunner).toBe(CommandContainer.get(StableRunner));
+    expect(Object.keys(first)).not.toContain("stableRunner");
+
+    expect(() => {
+      first.stableRunner = new StableRunner();
+    }).toThrow();
+  });
+
+  test("rejects duplicate dependencies by class or generated key", () => {
+    class OneRunner extends runner("duplicate") {}
+    class AnotherRunner extends runner("duplicate") {}
+
+    expect(() => assertUniqueDependencies([OneRunner, OneRunner])).toThrow("Duplicate command dependency class");
+    expect(() => assertUniqueDependencies([OneRunner, AnotherRunner])).toThrow(
+      'Duplicate command dependency key "duplicateRunner"',
+    );
+    expect(() => script("broken", [OneRunner, AnotherRunner])).toThrow(
+      'Duplicate command dependency key "duplicateRunner"',
+    );
+  });
+
+  test("injectDependencies detects circular command dependencies", () => {
+    class CircularA {
+      static readonly refName = "circularA";
+      static readonly dependencyKind = "script";
+      static readonly dependencyKey = "circularAScript";
+
+      constructor() {
+        CommandContainer.get(CircularB);
+      }
+    }
+
+    class CircularB {
+      static readonly refName = "circularB";
+      static readonly dependencyKind = "script";
+      static readonly dependencyKey = "circularBScript";
+
+      constructor() {
+        CommandContainer.get(CircularA);
+      }
+    }
+
+    expect(() => CommandContainer.get(CircularA)).toThrow("Circular command dependency");
+  });
+
+  test("injects explicit dependency lists into arbitrary objects", () => {
+    class DirectRunner extends runner("direct") {
+      value = "runner";
+    }
+
+    const target = {};
+    const injected = injectDependencies(target, [DirectRunner]);
+    expect(injected.directRunner.value).toBe("runner");
+
+    const descriptor = Object.getOwnPropertyDescriptor(injected, "directRunner");
+    expect(descriptor?.enumerable).toBe(false);
+    expect(descriptor?.writable).toBe(false);
+  });
+});

package/commandDecorators/commandMeta.ts

@@ -0,0 +1,7 @@
+import type { Cls } from "./types";
+
+export const Commands = () => {
+  return (target: Cls) => {
+    // not implemented yet
+  };
+};

package/commandDecorators/dependencyBuilder.ts

@@ -0,0 +1,100 @@
+import type { DependencyCls, DependencyKey, DependencyKind } from "./types";
+
+type UnionToIntersection<Union> = (Union extends unknown ? (value: Union) => void : never) extends (
+  value: infer Intersection,
+) => void
+  ? Intersection
+  : never;
+
+type DependencyToField<Dep> = Dep extends DependencyCls<infer Instance, infer Key> ? { [K in Key]: Instance } : never;
+
+export type DependencyInstanceMap<Deps extends readonly DependencyCls[]> = [Deps[number]] extends [never]
+  ? Record<PropertyKey, never>
+  : UnionToIntersection<DependencyToField<Deps[number]>>;
+
+const capitalize = (value: string) => value.slice(0, 1).toUpperCase() + value.slice(1);
+
+const createDependencyKey = <RefName extends string, Kind extends DependencyKind>(
+  refName: RefName,
+  kind: Kind,
+): DependencyKey<RefName, Kind> => `${refName}${capitalize(kind)}` as DependencyKey<RefName, Kind>;
+
+export class CommandContainer {
+  static #instances = new Map<DependencyCls, unknown>();
+  static #resolving = new Set<DependencyCls>();
+
+  static get<T>(dep: DependencyCls<T>): T {
+    const instance = CommandContainer.#instances.get(dep);
+    if (instance) return instance as T;
+    if (CommandContainer.#resolving.has(dep)) throw new Error(`Circular command dependency: ${dep.name}`);
+    CommandContainer.#resolving.add(dep);
+    try {
+      const nextInstance = new dep();
+      CommandContainer.#instances.set(dep, nextInstance);
+      return nextInstance;
+    } finally {
+      CommandContainer.#resolving.delete(dep);
+    }
+  }
+
+  static clear() {
+    CommandContainer.#instances.clear();
+    CommandContainer.#resolving.clear();
+  }
+}
+
+export const getDependencyKey = (dep: DependencyCls) => dep.dependencyKey;
+
+export const assertUniqueDependencies = (deps: readonly DependencyCls[]) => {
+  const keys = new Map<string, DependencyCls>();
+  const classes = new Set<DependencyCls>();
+  for (const dep of deps) {
+    if (classes.has(dep)) throw new Error(`Duplicate command dependency class: ${dep.name}`);
+    classes.add(dep);
+    const key = getDependencyKey(dep);
+    const existing = keys.get(key);
+    if (existing) throw new Error(`Duplicate command dependency key "${key}": ${existing.name}, ${dep.name}`);
+    keys.set(key, dep);
+  }
+};
+
+export const injectDependencies = <Deps extends readonly DependencyCls[]>(target: object, deps: Deps) => {
+  assertUniqueDependencies(deps);
+  for (const dep of deps) {
+    Object.defineProperty(target, getDependencyKey(dep), {
+      configurable: true,
+      enumerable: false,
+      value: CommandContainer.get(dep),
+      writable: false,
+    });
+  }
+  return target as typeof target & DependencyInstanceMap<Deps>;
+};
+
+export const runner = <RefName extends string>(refName: RefName) => {
+  class RunnerBase {
+    static readonly refName = refName;
+    static readonly dependencyKind = "runner";
+    static readonly dependencyKey = createDependencyKey(refName, "runner");
+  }
+
+  return RunnerBase as unknown as DependencyCls<InstanceType<typeof RunnerBase>, DependencyKey<RefName, "runner">>;
+};
+
+export const script = <RefName extends string, Deps extends readonly DependencyCls[]>(
+  refName: RefName,
+  deps: Deps = [] as unknown as Deps,
+) => {
+  assertUniqueDependencies(deps);
+  class ScriptBase {
+    static readonly refName = refName;
+    static readonly dependencyKind = "script";
+    static readonly dependencyKey = createDependencyKey(refName, "script");
+
+    constructor() {
+      injectDependencies(this, deps);
+    }
+  }
+
+  return ScriptBase as unknown as DependencyCls<DependencyInstanceMap<Deps>, DependencyKey<RefName, "script">>;
+};

package/{esm/src/commandDecorators/helpFormatter.js → commandDecorators/helpFormatter.ts}

@@ -1,75 +1,103 @@
 import chalk from "chalk";
-import { getArgMetas } from "./argMeta";
-import { getTargetMetas } from "./targetMeta";
-const camelToKebabCase = (str) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
-const groupCommands = (commands) => {
-  const groups = /* @__PURE__ */ new Map();
+
+import { type EnumChoice, getArgMetas } from "./argMeta";
+import { type CommandCls, getTargetMetas } from "./targetMeta";
+
+const camelToKebabCase = (str: string) => str.replace(/([A-Z])/g, "-$1").toLowerCase();
+const formatChoice = (choice: EnumChoice) => (typeof choice === "object" ? choice.label : choice.toString());
+
+const groupCommands = (commands: CommandCls[]) => {
+  const groups = new Map<string, { name: string; commands: { key: string; args: string[]; desc?: string }[] }>();
+
   for (const command of commands) {
     const className = command.name.replace("Command", "");
     const groupName = className;
+
     if (!groups.has(groupName)) {
       groups.set(groupName, { name: groupName, commands: [] });
     }
+
     const targetMetas = getTargetMetas(command);
     for (const targetMeta of targetMetas) {
-      if (targetMeta.targetOption.devOnly)
-        continue;
+      // Skip devOnly commands in help
+      if (targetMeta.targetOption.devOnly) continue;
+
       const [allArgMetas] = getArgMetas(command, targetMeta.key);
-      const args = allArgMetas.filter((arg) => arg.type !== "Option").map((arg) => {
-        if (arg.type === "Workspace")
-          return "";
-        if (arg.type === "Module")
-          return "[sys:module]";
-        if (arg.type === "Argument") {
-          return `[${arg.name}]`;
-        }
-        return `[${arg.type.toLowerCase()}]`;
-      }).filter(Boolean);
+      const args = allArgMetas
+        .filter((arg) => arg.type !== "Option")
+        .map((arg) => {
+          if (arg.type === "Workspace") return "";
+          if (arg.type === "Module") return "[sys:module]";
+          if (arg.type === "Argument") {
+            return `[${arg.name}]`;
+          }
+          return `[${arg.type.toLowerCase()}]`;
+        })
+        .filter(Boolean);
+
       const group = groups.get(groupName);
       if (group) {
         group.commands.push({
           key: camelToKebabCase(targetMeta.key),
           args,
-          desc: targetMeta.targetOption.desc
+          desc: targetMeta.targetOption.desc,
         });
       }
     }
   }
+
   return groups;
 };
-const formatHelp = (commands, version) => {
+
+export const formatHelp = (commands: CommandCls[], version: string) => {
   const groups = groupCommands(commands);
-  const lines = [];
+  const lines: string[] = [];
+
+  // Header
   lines.push("");
-  lines.push(chalk.bold.cyan("  \u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557"));
+  lines.push(chalk.bold.cyan("  ╔═══════════════════════════════════════════════════╗"));
   lines.push(
-    chalk.bold.cyan("  \u2551") + chalk.bold.white("              Akan.js Framework CLI            ") + chalk.bold.cyan("    \u2551")
+    chalk.bold.cyan("  ║") +
+      chalk.bold.white("              Akan.js Framework CLI            ") +
+      chalk.bold.cyan("    ║"),
   );
-  lines.push(chalk.bold.cyan("  \u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D"));
+  lines.push(chalk.bold.cyan("  ╚═══════════════════════════════════════════════════╝"));
   lines.push("");
   lines.push(chalk.gray(`  Version: ${version}`));
   lines.push("");
+
+  // Usage
   lines.push(chalk.bold.yellow("  USAGE"));
   lines.push("");
   lines.push(chalk.gray("    $ ") + chalk.white("akan") + chalk.gray(" <command> [options]"));
   lines.push("");
+
+  // Commands by category
   lines.push(chalk.bold.yellow("  COMMANDS"));
   lines.push("");
+
   for (const [groupName, group] of groups) {
-    if (group.commands.length === 0)
-      continue;
+    // Skip empty groups (all commands are devOnly)
+    if (group.commands.length === 0) continue;
+
     lines.push(chalk.bold.magenta(`    ${groupName}`));
     lines.push("");
+
     for (const cmd of group.commands) {
       const cmdName = chalk.green(cmd.key);
       const cmdArgs = cmd.args.length > 0 ? chalk.gray(` ${cmd.args.join(" ")}`) : "";
+
+      // Format description: wrap if too long
       if (cmd.desc) {
         const maxLineLength = 70;
         const cmdPrefix = `      ${cmdName}${cmdArgs}`;
         const indent = "        ";
+
         if (cmdPrefix.length + cmd.desc.length + 3 < maxLineLength) {
+          // Single line
           lines.push(`${cmdPrefix}  ${chalk.gray(cmd.desc)}`);
         } else {
+          // Multi-line
           lines.push(cmdPrefix);
           lines.push(`${indent}${chalk.gray(cmd.desc)}`);
         }
@@ -79,12 +107,16 @@ const formatHelp = (commands, version) => {
     }
     lines.push("");
   }
+
+  // Global Options
   lines.push(chalk.bold.yellow("  OPTIONS"));
   lines.push("");
   lines.push(`      ${chalk.green("-v, --verbose")}      ${chalk.gray("Enable verbose output")}`);
   lines.push(`      ${chalk.green("-h, --help")}         ${chalk.gray("Display this help message")}`);
   lines.push(`      ${chalk.green("-V, --version")}      ${chalk.gray("Output version number")}`);
   lines.push("");
+
+  // Examples
   lines.push(chalk.bold.yellow("  EXAMPLES"));
   lines.push("");
   lines.push(chalk.gray("    # Create a new workspace"));
@@ -96,48 +128,63 @@ const formatHelp = (commands, version) => {
   lines.push(chalk.gray("    # Create a new module"));
   lines.push(chalk.white("    $ akan create-module userProfile"));
   lines.push("");
+
+  // Footer
   lines.push(chalk.gray("  Documentation: ") + chalk.cyan("https://akanjs.com/docs"));
   lines.push(chalk.gray("  Report issues: ") + chalk.cyan("https://github.com/akan-team/akanjs/issues"));
   lines.push("");
+
   return lines.join("\n");
 };
-const formatCommandHelp = (command, key) => {
+
+export const formatCommandHelp = (command: CommandCls, key: string) => {
   const [allArgMetas, argMetas] = getArgMetas(command, key);
   const kebabKey = camelToKebabCase(key);
-  const lines = [];
+  const lines: string[] = [];
+
   const targetMetas = getTargetMetas(command);
   const targetMeta = targetMetas.find((t) => t.key === key);
   const commandDesc = targetMeta?.targetOption.desc;
+
   lines.push("");
   lines.push(chalk.bold.cyan(`  Command: ${kebabKey}`));
   if (commandDesc) {
     lines.push(chalk.gray(`  ${commandDesc}`));
   }
   lines.push("");
-  const args = allArgMetas.filter((arg) => arg.type !== "Option").map((arg) => {
-    if (arg.type === "Workspace")
-      return "";
-    if (arg.type === "Module")
-      return "[sys:module]";
-    if (arg.type === "Argument") {
-      return `[${camelToKebabCase(arg.name)}]`;
-    }
-    return `[${arg.type.toLowerCase()}]`;
-  }).filter(Boolean).join(" ");
+
+  // Usage
+  const args = allArgMetas
+    .filter((arg) => arg.type !== "Option")
+    .map((arg) => {
+      if (arg.type === "Workspace") return "";
+      if (arg.type === "Module") return "[sys:module]";
+      if (arg.type === "Argument") {
+        return `[${camelToKebabCase(arg.name)}]`;
+      }
+      return `[${arg.type.toLowerCase()}]`;
+    })
+    .filter(Boolean)
+    .join(" ");
+
   lines.push(chalk.bold.yellow("  USAGE"));
   lines.push("");
   lines.push(chalk.gray("    $ ") + chalk.white(`akan ${kebabKey}`) + (args ? chalk.gray(` ${args}`) : ""));
   lines.push("");
+
+  // Arguments
   const nonOptionArgs = allArgMetas.filter((arg) => arg.type !== "Option");
   if (nonOptionArgs.length > 0) {
     lines.push(chalk.bold.yellow("  ARGUMENTS"));
     lines.push("");
+
     for (const arg of nonOptionArgs) {
-      if (arg.type === "Workspace")
-        continue;
-      let argName;
-      let argDesc;
+      if (arg.type === "Workspace") continue;
+
+      let argName: string;
+      let argDesc: string;
       let example = "";
+
       if (arg.type === "Argument") {
         argName = camelToKebabCase(arg.name);
         argDesc = arg.argsOption.desc ?? "";
@@ -149,29 +196,35 @@ const formatCommandHelp = (command, key) => {
         argName = arg.type.toLowerCase();
         argDesc = `${arg.type} name in this workspace`;
       }
+
       lines.push(`      ${chalk.green(argName)}      ${chalk.gray(argDesc)}${example}`);
     }
+
     lines.push("");
   }
+
+  // Options
   const optionArgs = argMetas.filter((a) => a.type === "Option");
   if (optionArgs.length > 0) {
     lines.push(chalk.bold.yellow("  OPTIONS"));
     lines.push("");
+
     for (const arg of optionArgs) {
       const opt = arg.argsOption;
       const flag = opt.flag ? `-${opt.flag}, ` : "";
       const kebabName = camelToKebabCase(arg.name);
       const optName = `${flag}--${kebabName}`;
       const optDesc = opt.desc ?? "";
-      const defaultVal = opt.default !== void 0 ? chalk.gray(` [default: ${String(opt.default)}]`) : "";
-      const choices = opt.enum ? chalk.gray(` (${opt.enum.join(", ")})`) : "";
+      const defaultVal = opt.default !== undefined ? chalk.gray(` [default: ${String(opt.default)}]`) : "";
+      const choices = opt.enum
+        ? chalk.gray(
+            typeof opt.enum === "function" ? " ([dynamic choices])" : ` (${opt.enum.map(formatChoice).join(", ")})`,
+          )
+        : "";
       lines.push(`      ${chalk.green(optName)}      ${chalk.gray(optDesc)}${defaultVal}${choices}`);
     }
     lines.push("");
   }
+
   return lines.join("\n");
 };
-export {
-  formatCommandHelp,
-  formatHelp
-};

package/{esm/src/commandDecorators/index.js → commandDecorators/index.ts}

@@ -1,6 +1,8 @@
 export * from "./argMeta";
+export * from "./command";
+export * from "./commandBuilder";
 export * from "./commandMeta";
+export * from "./dependencyBuilder";
+export * from "./helpFormatter";
 export * from "./targetMeta";
 export * from "./types";
-export * from "./helpFormatter";
-export * from "./command";

package/commandDecorators/targetMeta.ts

@@ -0,0 +1,31 @@
+import type { ArgMeta, InternalArgMeta } from "./argMeta";
+import type { DependencyCls } from "./types";
+
+export const COMMAND_META: unique symbol = Symbol("akan.command.meta");
+
+export interface TargetMeta {
+  key: string;
+  targetOption: TargetOption;
+  args: (ArgMeta | InternalArgMeta)[];
+  handler: (this: unknown, ...args: unknown[]) => unknown | Promise<unknown>;
+}
+
+export interface CommandStatics {
+  [COMMAND_META]: Map<string, TargetMeta>;
+}
+
+export type CommandCls<Instance = unknown, Key extends string = string> = DependencyCls<Instance, Key> & CommandStatics;
+
+export const getTargetMetas = (command: CommandCls): TargetMeta[] => {
+  const targetMetaMap = command[COMMAND_META];
+  if (!targetMetaMap) throw new Error(`TargetMeta is not defined for ${command.name}`);
+  return [...targetMetaMap.values()];
+};
+
+export interface TargetOption {
+  type: "public" | "cloud" | "dev";
+  short?: string | true;
+  devOnly?: boolean;
+  desc?: string;
+  runsOnWorkspaceRoot?: boolean;
+}

package/commandDecorators/types.ts

@@ -0,0 +1,10 @@
+export type Cls<T = unknown> = new (...args: unknown[]) => T;
+
+export type DependencyKind = "command" | "script" | "runner";
+export type DependencyKey<RefName extends string, Kind extends DependencyKind> = `${RefName}${Capitalize<Kind>}`;
+
+export type DependencyCls<T = unknown, Key extends string = string> = (new () => T) & {
+  readonly dependencyKey: Key;
+  readonly dependencyKind: DependencyKind;
+  readonly refName: string;
+};

package/constants.ts

@@ -0,0 +1,25 @@
+import type { SupportedLlmModel } from "./aiEditor";
+
+export const basePath = `${Bun.env.HOME ?? Bun.env.USERPROFILE}/.akan`;
+export const configPath = `${basePath}/config.json`;
+export const akanCloudHost =
+  process.env.AKAN_PUBLIC_OPERATION_MODE === "local" ? "http://localhost" : "https://cloud.akanjs.com";
+export const akanCloudUrl = `${akanCloudHost}${process.env.AKAN_PUBLIC_OPERATION_MODE === "local" ? ":8282" : ""}/메ㅑ`;
+
+export interface HostConfig {
+  auth?: {
+    token: string;
+    self: { id: string; nickname: string };
+  };
+}
+export const defaultHostConfig: HostConfig = {};
+export interface AkanGlobalConfig {
+  cloudHost: {
+    [key: string]: HostConfig;
+  };
+  llm: {
+    model: SupportedLlmModel;
+    apiKey: string;
+  } | null;
+}
+export const defaultAkanGlobalConfig: AkanGlobalConfig = { cloudHost: {}, llm: null };