@akanjs/cli 3.0.0-beta.2 → 3.0.0-beta.20

package/{index-q0y2jq9j.js → index-5b6tavv3.js}

@@ -1,9 +1,12 @@
 // @bun
 // pkgs/@akanjs/devkit/fileSys.ts
 import { lstat, rename, rm, stat } from "fs/promises";
+import nodePath from "path";
+import { fileURLToPath } from "url";
 import { Logger } from "akanjs/common";
+var getDirname2 = (url) => nodePath.dirname(fileURLToPath(url));
 
-class FileSys {
+class FileSys2 {
   static logger = new Logger("FileSys");
   static async fileExists(path) {
     return await Bun.file(path).exists();
@@ -24,7 +27,7 @@ class FileSys {
     try {
       return await Bun.file(path).json();
     } catch (error) {
-      FileSys.logger.error(`Failed to read JSON file: ${path}`);
+      FileSys2.logger.error(`Failed to read JSON file: ${path}`);
       throw error;
     }
   }
@@ -52,4 +55,4 @@ class FileSys {
   }
 }
 
-export { FileSys };
+export { getDirname2, FileSys2 };

package/{index-47pj3aee.js → index-5e0n4hqx.js}

@@ -1,5 +1,6 @@
 // @bun
 // pkgs/@akanjs/devkit/mobile/mobileTarget.ts
+var trimSlashes = (value) => value.replace(/^\/+|\/+$/g, "");
 var getMobileTargets = async (app) => {
   const config = await app.getConfig();
   return Object.entries(config.mobile.targets).map(([name, target]) => ({ name, config: target }));
@@ -9,12 +10,11 @@ var getMobileTargetChoices = async (app) => {
   const targetNames = Object.keys(config.mobile.targets);
   if (targetNames.length > 0)
     return targetNames;
-  const basePaths = [...config.basePaths];
-  return basePaths;
+  return [...config.basePaths];
 };
 var resolveMobileTargetByBasePath = (targets, basePath) => {
-  const normalizedBasePath = basePath.replace(/^\/+|\/+$/g, "");
-  const byBasePath = targets.find((target) => target.config.basePath?.replace(/^\/+|\/+$/g, "") === normalizedBasePath);
+  const normalizedBasePath = trimSlashes(basePath);
+  const byBasePath = targets.find(({ config }) => config.basePath !== undefined && trimSlashes(config.basePath) === normalizedBasePath);
   if (byBasePath)
     return byBasePath;
   const [template] = targets;
@@ -22,11 +22,7 @@ var resolveMobileTargetByBasePath = (targets, basePath) => {
     return;
   return {
     name: normalizedBasePath,
-    config: {
-      ...template.config,
-      name: normalizedBasePath,
-      basePath: normalizedBasePath
-    }
+    config: { ...template.config, name: normalizedBasePath, basePath: normalizedBasePath }
   };
 };
 var resolveMobileTargets = async (app, selection) => {
@@ -58,13 +54,13 @@ var resolveMobileTargets = async (app, selection) => {
   if (target)
     return [target];
   const basePathTarget = resolveMobileTargetByBasePath(targets, selection);
-  if (basePathTarget && config.basePaths.has(selection.replace(/^\/+|\/+$/g, "")))
+  if (basePathTarget && config.basePaths.has(trimSlashes(selection)))
     return [basePathTarget];
   const choices = await getMobileTargetChoices(app);
   throw new Error(`Mobile target '${selection}' was not found. Available: ${choices.join(", ")}`);
 };
 var resolveMobilePath = (target, pathname) => {
-  const basePath = target.basePath?.replace(/^\/+|\/+$/g, "");
+  const basePath = trimSlashes(target.basePath ?? "");
   const normalizedPath = `/${pathname.replace(/^\/+/, "")}`;
   if (!basePath)
     return normalizedPath;
@@ -72,5 +68,8 @@ var resolveMobilePath = (target, pathname) => {
     return normalizedPath;
   return `/${basePath}${normalizedPath === "/" ? "" : normalizedPath}`;
 };
-var targetHtmlFilename = (target) => target.basePath?.replace(/^\/+|\/+$/g, "") ? `${target.basePath.replace(/^\/+|\/+$/g, "")}.html` : "index.html";
+var targetHtmlFilename = (target) => {
+  const basePath = trimSlashes(target.basePath ?? "");
+  return basePath ? `${basePath}.html` : "index.html";
+};
 export { getMobileTargets, getMobileTargetChoices, resolveMobileTargets, resolveMobilePath, targetHtmlFilename };

package/{index-259dsnz3.js → index-5pc1qrbv.js}

@@ -2,23 +2,21 @@
 import {
   runner,
   script
-} from "./index-mak3cd28.js";
+} from "./index-w2zdcw3k.js";
 import {
   LibExecutor
-} from "./index-2tv3fdx4.js";
+} from "./index-9d9bgcx4.js";
 import {
   LibSource,
   formatLibStatuses
-} from "./index-3d9y066c.js";
+} from "./index-bjwxs904.js";
 
 // pkgs/@akanjs/cli/library/library.script.ts
 import { Logger } from "akanjs/common";
 
 // pkgs/@akanjs/devkit/semver.ts
 var stripRangeOperator = (version) => version.replace(/^[\s^~>=<v]+/, "").trim();
-var parseVersion = (version) => {
-  return version.replace(/^[^\d]*/, "").split(/[.-]/).map((part) => Number.parseInt(part, 10)).map((part) => Number.isFinite(part) ? part : 0);
-};
+var parseVersion = (version) => version.replace(/^[^\d]*/, "").split(/[.-]/).map((part) => Number.parseInt(part, 10)).map((part) => Number.isFinite(part) ? part : 0);
 var compareNumeric = (a, b) => {
   const left = parseVersion(a);
   const right = parseVersion(b);
@@ -44,8 +42,7 @@ class LibraryRunner extends runner("library") {
   async createLibrary(libName, workspace) {
     await workspace.mkdir(`libs/${libName}`);
     await workspace.applyTemplate({ basePath: `libs/${libName}`, template: "libRoot", dict: { libName } });
-    const lib = LibExecutor.from(workspace, libName);
-    return lib;
+    return LibExecutor.from(workspace, libName);
   }
   async removeLibrary(lib) {
     await lib.workspace.removeDir(`libs/${lib.name}`);

package/index-7md2g9vw.js

@@ -0,0 +1,6 @@
+// @bun
+// pkgs/@akanjs/devkit/stripAnsi.ts
+var ansi = new RegExp(`${String.fromCharCode(27)}(?:[@-Z\\\\-_]|\\[[\\s\\S]*?[@-~])`, "g");
+var stripAnsi = (text) => text.replace(ansi, "");
+
+export { stripAnsi };

package/index-8mna0947.js

@@ -0,0 +1,187 @@
+// @bun
+import {
+  runner,
+  script
+} from "./index-w2zdcw3k.js";
+import {
+  ModuleExecutor
+} from "./index-9d9bgcx4.js";
+import {
+  sourceFile,
+  moduleSourcePaths,
+  generatedFilesForSync,
+  createPassedPrimitiveReport,
+  bilingualLabelForField,
+  bilingualDescriptionForField
+} from "./index-myhc3c1j.js";
+import {
+  PageScript
+} from "./index-dzf3r49a.js";
+import {
+  pluralizeName
+} from "./index-nz8prx9g.js";
+
+// pkgs/@akanjs/cli/module/module.script.ts
+import { capitalize as capitalize2 } from "akanjs/common";
+
+// pkgs/@akanjs/cli/module/module.runner.ts
+import { capitalize } from "akanjs/common";
+var purposeByModule = {
+  budget: "Budget represents planned or actual money allocated inside the app.",
+  project: "Project represents a project workspace or business initiative managed by the app.",
+  task: "Task represents work items that move through the app workflow."
+};
+var moduleAbstractContent = (moduleName, sharedGuards) => {
+  const title = capitalize(moduleName);
+  const noun = bilingualLabelForField(moduleName).en.toLowerCase();
+  const purpose = purposeByModule[moduleName] ?? `${title} represents ${noun} records managed by the app.`;
+  const writeRule = sharedGuards ? `Anyone may read a ${noun}; only an admin creates, updates or removes one.` : `Anyone may read a ${noun}; nobody creates, updates or removes one until the slice names a guard.`;
+  return `# ${moduleName} Abstract
+${purpose}
+
+## Rules
+- ${writeRule}
+- Removal is soft: a removed ${noun} keeps its row with \`removedAt\` set.
+`;
+};
+var moduleFileKeys = [
+  "abstract",
+  "constant",
+  "dictionary",
+  "service",
+  "store",
+  "signal",
+  "unit",
+  "view",
+  "template",
+  "zone",
+  "util"
+];
+
+class ModuleRunner extends runner("module") {
+  async createService(module) {
+    const serviceName = module.name.replace(/^_+/, "");
+    await module.applyTemplate({
+      basePath: `.`,
+      template: "service",
+      dict: { model: serviceName, sysName: module.sys.name }
+    });
+    return await this.#readFiles(module, {
+      abstract: `${serviceName}.abstract.md`,
+      dictionary: `${serviceName}.dictionary.ts`,
+      service: `${serviceName}.service.ts`,
+      signal: `${serviceName}.signal.ts`,
+      store: `${serviceName}.store.ts`
+    });
+  }
+  async#readFiles(module, filenames) {
+    const files = await Promise.all(Object.entries(filenames).map(async ([key, filename]) => [
+      key,
+      { filename, content: await module.readFile(filename) }
+    ]));
+    return Object.fromEntries(files);
+  }
+  async removeModule(module) {
+    await module.sys.removeDir(`lib/${module.name}`);
+  }
+  async#hasSharedGuards(module) {
+    const { sys } = module;
+    if (sys.type === "lib" && sys.name === "shared")
+      return true;
+    if (!await sys.exists("lib/srv.ts"))
+      return false;
+    return (await sys.readFile("lib/srv.ts")).includes('"@libs/shared/lib/srv"');
+  }
+  async createComponentTemplate(module, type) {
+    await module.sys.applyTemplate({
+      basePath: `./lib/${module.name}`,
+      template: `module/__Model__.${capitalize(type)}.tsx`,
+      dict: { model: module.name, sysName: module.sys.name, sysType: module.sys.type }
+    });
+    return {
+      component: {
+        filename: `${capitalize(module.name)}.${capitalize(type)}.tsx`,
+        content: await module.sys.readFile(`lib/${module.name}/${capitalize(module.name)}.${capitalize(type)}.tsx`)
+      }
+    };
+  }
+  async createModuleTemplate(module) {
+    const names = pluralizeName(module.name);
+    const modelLabel = bilingualLabelForField(module.name);
+    const modelDescription = bilingualDescriptionForField(module.name);
+    const paths = moduleSourcePaths(module.name);
+    const filenames = Object.fromEntries(moduleFileKeys.map((key) => [key, paths[key].replace(`lib/${module.name}/`, "")]));
+    const sharedGuards = await this.#hasSharedGuards(module);
+    await module.applyTemplate({
+      basePath: `.`,
+      template: "module",
+      options: { sharedGuards },
+      dict: {
+        model: module.name,
+        models: names,
+        sysName: module.sys.name,
+        sysType: module.sys.type,
+        modelLabelEn: modelLabel.en,
+        modelLabelKo: modelLabel.ko,
+        modelDescEn: modelDescription.en,
+        modelDescKo: modelDescription.ko
+      }
+    });
+    await module.writeFile(filenames.abstract, moduleAbstractContent(module.name, sharedGuards));
+    return await this.#readFiles(module, filenames);
+  }
+}
+
+// pkgs/@akanjs/cli/module/module.script.ts
+var moduleChangedFiles = (sys, moduleName, files) => Object.values(files).map((file) => sourceFile(sys, `lib/${moduleName}/${file.filename}`, "create", "Module source file was created."));
+
+class ModuleScript extends script("module", [ModuleRunner, PageScript]) {
+  async createModuleTemplate(sys, name, { page = false } = {}) {
+    const mod = ModuleExecutor.from(sys, name);
+    const files = await this.moduleRunner.createModuleTemplate(mod);
+    if (page && sys.type === "app")
+      await this.pageScript.createCrudPage(mod, { app: sys, basePath: null, single: false });
+    await sys.scan();
+    return createPassedPrimitiveReport({
+      command: "create-module",
+      changedFiles: moduleChangedFiles(sys, name, files),
+      generatedFiles: generatedFilesForSync(sys, "Generated files were refreshed after module creation."),
+      target: sys.name
+    });
+  }
+  async removeModule(mod) {
+    await this.moduleRunner.removeModule(mod);
+  }
+  async createService(sys, name) {
+    const service = ModuleExecutor.from(sys, `_${name}`);
+    const files = await this.moduleRunner.createService(service);
+    await sys.scan();
+    return createPassedPrimitiveReport({
+      command: "create-service",
+      changedFiles: moduleChangedFiles(sys, `_${name}`, files),
+      generatedFiles: generatedFilesForSync(sys, "Generated files were refreshed after service creation."),
+      target: sys.name
+    });
+  }
+  async createTemplate(mod) {
+    return await this.#createComponent(mod, "template");
+  }
+  async createUnit(mod) {
+    return await this.#createComponent(mod, "unit");
+  }
+  async createView(mod) {
+    return await this.#createComponent(mod, "view");
+  }
+  async#createComponent(mod, type) {
+    const { component } = await this.moduleRunner.createComponentTemplate(mod, type);
+    return createPassedPrimitiveReport({
+      command: `create-${type}`,
+      changedFiles: [
+        sourceFile(mod.sys, `lib/${mod.name}/${component.filename}`, "create", `${capitalize2(type)} UI source was created.`)
+      ],
+      target: mod.sys.name
+    });
+  }
+}
+
+export { ModuleScript };

package/{index-zry5nz81.js → index-8sf7wmdr.js}

@@ -1,44 +1,33 @@
 // @bun
 import {
   GlobalConfig,
-  CloudApi,
-  AiSession
-} from "./index-kn1h7p1x.js";
-import {
-  PkgExecutor
-} from "./index-2tv3fdx4.js";
+  CloudApi
+} from "./index-22d57v4c.js";
 import {
   script
-} from "./index-mak3cd28.js";
+} from "./index-w2zdcw3k.js";
+import {
+  PkgExecutor
+} from "./index-9d9bgcx4.js";
 import {
   ApplicationScript
-} from "./index-v0qh106m.js";
+} from "./index-ww4z397j.js";
 import {
   PackageScript
-} from "./index-ws5e0j51.js";
+} from "./index-as7xmyz8.js";
 import {
   CloudRunner
-} from "./index-2hq52jq3.js";
+} from "./index-axzjaqve.js";
 
 // pkgs/@akanjs/cli/cloud/cloud.script.ts
 import { Logger } from "akanjs/common";
-class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, PackageScript]) {
+class CloudScript2 extends script("cloud", [CloudRunner, ApplicationScript, PackageScript]) {
   async login(workspace, host = GlobalConfig.akanCloudHost) {
     await this.cloudRunner.login(host, workspace);
   }
   async logout(workspace, host = GlobalConfig.akanCloudHost) {
     await this.cloudRunner.logout(host);
   }
-  async setLlm(workspace) {
-    await this.cloudRunner.setLlm();
-  }
-  resetLlm(workspace) {
-    this.cloudRunner.resetLlm();
-  }
-  async ask(question, workspace) {
-    const session = new AiSession("general", { workspace, isContinued: true });
-    await session.ask(question);
-  }
   async downloadEnv(workspace, workspaceId = workspace.getWorkspaceId({ allowEmpty: true }), { host = GlobalConfig.akanCloudHost } = {}) {
     if (workspaceId) {
       await this.login(workspace, host);
@@ -48,29 +37,61 @@ class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, Packa
     }
     await this.cloudRunner.downloadEnvByScp(workspace);
   }
-  async uploadEnv(workspace, { host = GlobalConfig.akanCloudHost } = {}) {
-    const workspaceId = workspace.getWorkspaceId({ allowEmpty: true });
-    const { path } = await this.cloudRunner.gatherEnvFiles(workspace);
+  async uploadEnv(workspace, {
+    host = GlobalConfig.akanCloudHost,
+    workspaceId = workspace.getWorkspaceId({ allowEmpty: true }),
+    scope,
+    archivePath
+  } = {}) {
+    if (scope && !workspaceId)
+      throw new Error("A scoped env upload needs a cloud workspace id \u2014 the scp target is workspace-wide.");
+    const { files, path } = await this.cloudRunner.gatherEnvFiles(workspace, { scope, archivePath });
     if (workspaceId) {
       await this.login(workspace, host);
       const cloudApi = await CloudApi.fromHost(workspace, host);
       await this.cloudRunner.uploadEnv(cloudApi, workspaceId, path);
-      return;
+      return { workspaceId, files };
     }
     await this.cloudRunner.uploadEnvByScp(workspace, path);
+    return { workspaceId: null, files };
   }
-  async deployAkan(workspace, { test = true, registryUrl } = {}) {
+  async deployAkan(workspace, {
+    test = true,
+    registryUrl,
+    platforms = []
+  } = {}) {
     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)
-        await this.applicationScript.test(pkg);
+    if (test) {
+      const platformRun = platforms.length ? await this.cloudRunner.startPlatformTests(workspace, platforms, akanPkgs) : null;
+      let localFailure = null;
+      try {
+        for (const pkg of pkgs)
+          await this.applicationScript.test(pkg);
+      } catch (error) {
+        localFailure = error;
+      }
+      if (platformRun)
+        await this.cloudRunner.settlePlatformTests(platformRun, {
+          interactive: !localFailure,
+          recordStreaks: !localFailure,
+          checkDrift: true
+        });
+      if (localFailure)
+        throw localFailure;
+    }
     for (const pkg of pkgs)
       await this.packageScript.buildPackage(pkg);
     await this.packageScript.verifyAkanPublishPackages(workspace);
     await this.cloudRunner.deployAkan(workspace, akanPkgs, { registryUrl });
   }
+  async testPlatforms(workspace, { platforms, pkgs }) {
+    if (!platforms.length)
+      throw new Error("No platform to test on \u2014 pass --platforms linux,windows");
+    const run = await this.cloudRunner.startPlatformTests(workspace, platforms, pkgs ?? await this.cloudRunner.getAkanPkgs(workspace));
+    await this.cloudRunner.settlePlatformTests(run, { interactive: false, recordStreaks: false, checkDrift: false });
+  }
   async update(workspace, tag = "latest", { registryUrl } = {}) {
     const spinner = workspace.spinning("Updating Akan.js packages and CLI...");
     await this.cloudRunner.update(workspace, tag, { registryUrl });
@@ -80,4 +101,4 @@ class CloudScript extends script("cloud", [CloudRunner, ApplicationScript, Packa
   }
 }
 
-export { CloudScript };
+export { CloudScript2 };