@akanjs/cli 3.0.0-alpha.9 → 3.0.0-alpha.90

package/{index-kdh76j26.js → index-cezy7yb3.js}

@@ -1,21 +1,18 @@
 // @bun
 import {
-  AppExecutor,
+  FileSys
+} from "./index-q0y2jq9j.js";
+import {
   Executor,
+  WorkspaceExecutor,
+  AppExecutor,
   LibExecutor,
-  ModuleExecutor,
   PkgExecutor,
-  WorkspaceExecutor
-} from "./index-z8ptfkzv.js";
-import {
-  getDirname
-} from "./index-1577bej2.js";
-import {
-  FileSys
-} from "./index-67546d0j.js";
+  ModuleExecutor
+} from "./index-q8sn827n.js";
 import {
-  __require
-} from "./index-r24hmh0q.js";
+  getDirname2
+} from "./index-6wwzs1bc.js";
 
 // pkgs/@akanjs/devkit/commandDecorators/targetMeta.ts
 var COMMAND_META = Symbol("akan.command.meta");
@@ -54,6 +51,7 @@ var normalizePrimitiveArgType = (type) => {
   throw new Error(`Invalid primitive argument type: ${type}`);
 };
 var App = createInternalArgToken("App");
+var Apps = createInternalArgToken("Apps");
 var Lib = createInternalArgToken("Lib");
 var Sys = createInternalArgToken("Sys");
 var Exec = createInternalArgToken("Exec");
@@ -62,11 +60,29 @@ var Module = createInternalArgToken("Module");
 var Workspace = createInternalArgToken("Workspace");
 
 // pkgs/@akanjs/devkit/commandDecorators/command.ts
-import path from "path";
+import path2 from "path";
 import { Logger } from "akanjs/common";
 import chalk2 from "chalk";
 import { program } from "commander";
 
+// pkgs/@akanjs/devkit/appSelectionMemory.ts
+import path from "path";
+class AppSelectionMemory {
+  static pathIn(workspaceRoot) {
+    return path.join(workspaceRoot, "local", ".akan", "lastStart.json");
+  }
+  static async read(workspaceRoot) {
+    const stored = await Bun.file(AppSelectionMemory.pathIn(workspaceRoot)).json().catch(() => null);
+    const apps = stored?.apps;
+    return Array.isArray(apps) ? apps.filter((name) => typeof name === "string") : [];
+  }
+  static async write(workspaceRoot, apps) {
+    await FileSys.writeJson(AppSelectionMemory.pathIn(workspaceRoot), { apps }).catch(() => {
+      return;
+    });
+  }
+}
+
 // pkgs/@akanjs/devkit/commandDecorators/dependencyBuilder.ts
 var capitalize = (value) => value.slice(0, 1).toUpperCase() + value.slice(1);
 var createDependencyKey = (refName, kind) => `${refName}${capitalize(kind)}`;
@@ -264,6 +280,8 @@ var formatCommandHelp = (command, key) => {
       return "";
     if (arg.type === "Module")
       return "[sys:module]";
+    if (arg.type === "Apps")
+      return "[apps...]";
     if (arg.type === "Argument") {
       return `[${camelToKebabCase2(arg.name)}]`;
     }
@@ -290,6 +308,9 @@ var formatCommandHelp = (command, key) => {
       } else if (arg.type === "Module") {
         argName = "sys:module";
         argDesc = "Module in format: app-name:module-name or lib-name:module-name";
+      } else if (arg.type === "Apps") {
+        argName = "apps...";
+        argDesc = "App names, space- or comma-separated, or all. Omit to pick them interactively";
       } else {
         argName = arg.type.toLowerCase();
         argDesc = `${arg.type} name in this workspace`;
@@ -383,6 +404,17 @@ var prompts = async () => await import("@inquirer/prompts");
 var select = (config, context) => prompts().then((m) => m.select(config, context));
 var confirm = (config, context) => prompts().then((m) => m.confirm(config, context));
 var input = (config, context) => prompts().then((m) => m.input(config, context));
+var checkbox = (config, context) => prompts().then((m) => m.checkbox(config, context));
+var assertEnumChoice = (argMeta, value) => {
+  const enumChoices = argMeta.argsOption.enum;
+  if (!enumChoices || typeof enumChoices === "function")
+    return;
+  const choices = normalizeEnumChoices(enumChoices);
+  if (choices.some((choice) => String(choice.value) === String(value)))
+    return;
+  const label = argMeta.type === "Option" ? `option '--${camelToKebabCase3(argMeta.name)}'` : `argument '${argMeta.name}'`;
+  throw new Error(`${label} argument '${String(value)}' is invalid. Allowed choices are ${choices.map((choice) => choice.name).join(", ")}.`);
+};
 var resolveEnumChoices = async (argMeta, context) => {
   const enumChoices = argMeta.argsOption.enum;
   if (!enumChoices)
@@ -396,9 +428,10 @@ var getOptionValue = async (argMeta, opt, context) => {
     name,
     argsOption: { enum: enumChoices, default: defaultValue, type, desc, nullable, example, ask }
   } = argMeta;
-  if (opt[argMeta.name] !== undefined)
+  if (opt[argMeta.name] !== undefined) {
+    assertEnumChoice(argMeta, opt[argMeta.name]);
     return convertArgValue(opt[argMeta.name], type ?? "string");
-  else if (defaultValue !== undefined)
+  } else if (defaultValue !== undefined)
     return defaultValue;
   if (enumChoices) {
     const choices = normalizeEnumChoices(await resolveEnumChoices(argMeta, context) ?? []);
@@ -424,9 +457,10 @@ var getArgumentValue = async (argMeta, value) => {
     name,
     argsOption: { default: defaultValue, type, desc, nullable, example, ask }
   } = argMeta;
-  if (value !== undefined)
+  if (value !== undefined) {
+    assertEnumChoice(argMeta, value);
     return convertArgValue(value, type ?? "string");
-  else if (defaultValue !== undefined)
+  } else if (defaultValue !== undefined)
     return defaultValue;
   else if (nullable)
     return null;
@@ -465,6 +499,31 @@ var assertCurrentDirectoryIsWorkspaceRoot = async () => {
   ].join(`
 `));
 };
+var parseAppNameList = (value) => (Array.isArray(value) ? value : value === undefined ? [] : [value]).flatMap((entry) => entry.split(",")).map((entry) => entry.trim()).filter(Boolean);
+var getAppsArgumentValue = async (value, workspace) => {
+  const appNames = await workspace.getApps();
+  if (appNames.length === 0)
+    throw new Error("No apps found in this workspace (apps/<appName>/akan.config.ts)");
+  const requested = parseAppNameList(value);
+  if (requested.includes("all"))
+    return appNames.map((name) => AppExecutor.from(workspace, name));
+  if (requested.length) {
+    const unknown = requested.filter((name) => !appNames.includes(name));
+    if (unknown.length)
+      throw new Error(`Unknown app${unknown.length > 1 ? "s" : ""}: ${unknown.join(", ")}. Available: ${appNames.join(", ")}, all`);
+    return [...new Set(requested)].map((name) => AppExecutor.from(workspace, name));
+  }
+  if (appNames.length === 1 && appNames[0])
+    return [AppExecutor.from(workspace, appNames[0])];
+  const remembered = new Set(await AppSelectionMemory.read(workspace.workspaceRoot));
+  const picked = await checkbox({
+    message: "Select the apps to run (space to toggle, enter to confirm)",
+    choices: appNames.map((name) => ({ name, value: name, checked: remembered.has(name) })),
+    required: true
+  });
+  await AppSelectionMemory.write(workspace.workspaceRoot, picked);
+  return picked.map((name) => AppExecutor.from(workspace, name));
+};
 var getInternalArgumentValue = async (argMeta, value, workspace) => {
   if (argMeta.type === "Workspace")
     return workspace;
@@ -528,36 +587,36 @@ var getInternalArgumentValue = async (argMeta, value, workspace) => {
     return PkgExecutor.from(workspace, pkgName);
   } else if (sysType === "module") {
     if (value) {
-      const [sysName, moduleName2] = value.split(":");
-      if (!sysName || !moduleName2)
+      const [sysName, moduleName] = value.split(":");
+      if (!sysName || !moduleName)
         throw new Error(`Invalid module name: ${value}`);
       if (appNames.includes(sysName)) {
         const app = AppExecutor.from(workspace, sysName);
-        const modules2 = await app.getModules();
-        if (modules2.includes(moduleName2))
-          return ModuleExecutor.from(app, moduleName2);
+        const modules = await app.getModules();
+        if (modules.includes(moduleName))
+          return ModuleExecutor.from(app, moduleName);
         else
-          throw new Error(`Invalid module name: ${moduleName2}`);
+          throw new Error(`Invalid module name: ${moduleName}`);
       } else if (libNames.includes(sysName)) {
         const lib = LibExecutor.from(workspace, sysName);
-        const modules2 = await lib.getModules();
-        if (modules2.includes(moduleName2))
-          return ModuleExecutor.from(lib, moduleName2);
+        const modules = await lib.getModules();
+        if (modules.includes(moduleName))
+          return ModuleExecutor.from(lib, moduleName);
       } else
         throw new Error(`Invalid system name: ${sysName}`);
     }
     const { type, name } = await select({
       message: `select the App or Lib name`,
       choices: [
-        ...appNames.map((name2) => ({ name: name2, value: { type: "app", name: name2 } })),
-        ...libNames.map((name2) => ({ name: name2, value: { type: "lib", name: name2 } }))
+        ...appNames.map((name) => ({ name, value: { type: "app", name } })),
+        ...libNames.map((name) => ({ name, value: { type: "lib", name } }))
       ]
     });
     const executor = type === "app" ? AppExecutor.from(workspace, name) : LibExecutor.from(workspace, name);
     const modules = await executor.getModules();
     const moduleName = await select({
       message: `Select the module name`,
-      choices: modules.map((name2) => ({ name: `${executor.name}:${name2}`, value: name2 }))
+      choices: modules.map((name) => ({ name: `${executor.name}:${name}`, value: name }))
     });
     return ModuleExecutor.from(executor, moduleName);
   } else
@@ -568,8 +627,8 @@ var runCommands = async (...commands) => {
     printCliError(error);
     process.exit(1);
   });
-  const __dirname2 = getDirname(import.meta.url);
-  const packageJsonCandidates = [`${path.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
+  const __dirname2 = getDirname2(import.meta.url);
+  const packageJsonCandidates = [`${path2.dirname(Bun.main)}/package.json`, `${__dirname2}/../package.json`];
   let cliPackageJson = null;
   for (const packageJsonPath of packageJsonCandidates) {
     if (!await FileSys.fileExists(packageJsonPath))
@@ -616,6 +675,8 @@ It may cause unexpected behavior. Run \`akan update\` to update latest akanjs.`)
             continue;
           else if (argMeta.type === "Module") {
             programCommand = programCommand.argument(`[sys-name:module-name]`, `${argMeta.type} in this workspace (apps|libs)/<sys-name>/lib/<module-name>`);
+          } else if (argMeta.type === "Apps") {
+            programCommand = programCommand.argument(`[apps...]`, `apps in this workspace apps/<appName>, or all (space- or comma-separated; omit to pick interactively)`);
           } else {
             const sysType = argMeta.type.toLowerCase();
             programCommand = programCommand.argument(`[${sysType}]`, `${sysType} in this workspace ${sysType}s/<${sysType}Name>`);
@@ -640,10 +701,17 @@ It may cause unexpected behavior. Run \`akan update\` to update latest akanjs.`)
               commandArgs[argMeta.idx] = await getOptionValue(argMeta, opt, commandContext);
             else if (argMeta.type === "Argument")
               commandArgs[argMeta.idx] = await getArgumentValue(argMeta, cmdArgs[argMeta.idx]);
+            else if (argMeta.type === "Apps")
+              commandArgs[argMeta.idx] = await getAppsArgumentValue(cmdArgs[argMeta.idx], workspace);
             else
               commandArgs[argMeta.idx] = await getInternalArgumentValue(argMeta, cmdArgs[argMeta.idx], workspace);
             if (commandArgs[argMeta.idx] instanceof AppExecutor)
               process.env.AKAN_PUBLIC_APP_NAME = commandArgs[argMeta.idx].name;
+            else if (Array.isArray(commandArgs[argMeta.idx])) {
+              const apps = commandArgs[argMeta.idx];
+              if (apps.length === 1 && apps[0])
+                process.env.AKAN_PUBLIC_APP_NAME = apps[0].name;
+            }
             assignCommandContext(commandContext, argMeta, commandArgs[argMeta.idx]);
             if (opt.verbose)
               Executor.setVerbose(true);
@@ -763,4 +831,4 @@ function command(refName, depsOrBuilder, builder) {
   }
   return CommandBase;
 }
-export { getTargetMetas, getTargetCommandNames, App, Lib, Sys, Exec, Pkg, Module, Workspace, CommandContainer, runner, script, runCommands, command };
+export { getTargetMetas, getTargetCommandNames, App, Apps, Lib, Sys, Exec, Pkg, Module, Workspace, CommandContainer, runner, script, runCommands, command };