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

package/{index-4edzf1gr.js → index-wp43xrjv.js}

@@ -1,23 +1,25 @@
 // @bun
 import {
   script
-} from "./index-mak3cd28.js";
+} from "./index-rmcw8yc8.js";
 import {
   AppExecutor,
   LibExecutor,
   ModuleExecutor
-} from "./index-2tv3fdx4.js";
+} from "./index-ga6hygxr.js";
 import {
+  workflowStatus,
   compactDiagnostics,
-  createPrimitiveWriteReport,
   sourceFile,
   moduleComponentName,
   moduleSourcePaths,
   generatedFilesForSync,
   validationCommandsForTarget,
   nextActionsForTarget,
-  lowerlize,
+  createPrimitiveWriteReport,
   normalizeFieldType,
+  ensureNamedImport,
+  ensureBaseImport,
   ensureBaseTypeImport,
   coerceFieldDefault,
   fieldExpression,
@@ -39,13 +41,13 @@ import {
   hasSignalFactoryEntry,
   insertSignalFactoryEntry,
   addFieldUiPolicyForType
-} from "./index-gyd220p2.js";
+} from "./index-yy4s1j72.js";
 import {
   ModuleScript
-} from "./index-8pm30m73.js";
+} from "./index-tgjy8xf3.js";
 
 // pkgs/@akanjs/cli/primitive/primitive.script.ts
-import { capitalize } from "akanjs/common";
+import { capitalize, lowerlize } from "akanjs/common";
 class PrimitiveScript extends script("primitive", [ModuleScript]) {
   async resolveSys(workspace, target) {
     if (!target)
@@ -59,28 +61,11 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
   }
   async createUi(workspace, input) {
     const sys = await this.resolveSys(workspace, input.app);
-    if (!sys || !input.module) {
-      return createPrimitiveWriteReport({
-        command: "create-ui",
-        changedFiles: [],
-        generatedFiles: [],
-        validationCommands: [],
-        diagnostics: compactDiagnostics([
-          !sys && {
-            severity: "error",
-            code: "primitive-target-missing",
-            message: "Target app or library was not found."
-          },
-          !input.module && {
-            severity: "error",
-            code: "primitive-input-missing",
-            message: "Module is required.",
-            input: "module"
-          }
-        ]),
-        nextActions: []
-      });
-    }
+    if (!sys || !input.module)
+      return PrimitiveScript.#refuse("create-ui", compactDiagnostics([
+        !sys && PrimitiveScript.#targetMissing(),
+        !input.module && PrimitiveScript.#inputMissing("module")
+      ]));
     const mod = ModuleExecutor.from(sys, input.module);
     if (input.surface === "view")
       return await this.moduleScript.createView(mod);
@@ -96,30 +81,16 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
     return await this.addFieldToSources(workspace, { ...input, type: `${capitalize(input.field ?? "")}` }, { enumValues: values });
   }
   async addFieldToSources(workspace, input, { enumValues }) {
+    const command = enumValues ? "add-enum-field" : "add-field";
     const sys = await this.resolveSys(workspace, input.app);
     const ambiguousNumberTypes = new Set(["number", "numeric"]);
     const normalizedType = input.type ? normalizeFieldType(input.type) : null;
     const diagnostics = compactDiagnostics([
-      !sys && { severity: "error", code: "primitive-target-missing", message: "Target app or library was not found." },
-      !input.module && {
-        severity: "error",
-        code: "primitive-input-missing",
-        message: "Module is required.",
-        input: "module"
-      },
-      !input.field && {
-        severity: "error",
-        code: "primitive-input-missing",
-        message: "Field is required.",
-        input: "field"
-      },
-      !input.type && {
-        severity: "error",
-        code: "primitive-input-missing",
-        message: "Type is required.",
-        input: "type"
-      },
-      enumValues && enumValues.length === 0 ? { severity: "error", code: "primitive-input-missing", message: "Enum values are required.", input: "values" } : null,
+      !sys && PrimitiveScript.#targetMissing(),
+      !input.module && PrimitiveScript.#inputMissing("module"),
+      !input.field && PrimitiveScript.#inputMissing("field"),
+      !input.type && PrimitiveScript.#inputMissing("type"),
+      enumValues?.length === 0 && PrimitiveScript.#inputMissing("values", "Enum values are required."),
       input.type && ambiguousNumberTypes.has(input.type.toLowerCase()) ? {
         severity: "error",
         code: "primitive-field-type-unsupported",
@@ -133,16 +104,8 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
         input: "type"
       } : null
     ]);
-    if (!sys || !input.module || !input.field || !input.type || diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-      return createPrimitiveWriteReport({
-        command: enumValues ? "add-enum-field" : "add-field",
-        changedFiles: [],
-        generatedFiles: [],
-        validationCommands: [],
-        diagnostics,
-        nextActions: []
-      });
-    }
+    if (!sys || !input.module || !input.field || !input.type || workflowStatus(diagnostics) === "failed")
+      return PrimitiveScript.#refuse(command, diagnostics);
     const moduleClassName = moduleComponentName(input.module);
     const inputClassName = `${moduleClassName}Input`;
     const paths = moduleSourcePaths(input.module);
@@ -150,32 +113,13 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
     const dictionaryPath = paths.dictionary;
     const templatePath = paths.template;
     const changedFiles = [];
-    const generatedFiles = generatedFilesForSync(sys);
     const [hasConstant, hasDictionary] = await Promise.all([sys.exists(constantPath), sys.exists(dictionaryPath)]);
-    if (!hasConstant) {
-      diagnostics.push({
-        severity: "error",
-        code: "primitive-source-missing",
-        message: `Constant source file was not found: ${constantPath}.`
-      });
-    }
-    if (!hasDictionary) {
-      diagnostics.push({
-        severity: "error",
-        code: "primitive-source-missing",
-        message: `Dictionary source file was not found: ${dictionaryPath}.`
-      });
-    }
-    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-      return createPrimitiveWriteReport({
-        command: enumValues ? "add-enum-field" : "add-field",
-        changedFiles,
-        generatedFiles,
-        validationCommands: validationCommandsForTarget(sys.name),
-        diagnostics,
-        nextActions: nextActionsForTarget(sys.name)
-      });
-    }
+    if (!hasConstant)
+      diagnostics.push(PrimitiveScript.#sourceMissing("Constant", constantPath));
+    if (!hasDictionary)
+      diagnostics.push(PrimitiveScript.#sourceMissing("Dictionary", dictionaryPath));
+    if (workflowStatus(diagnostics) === "failed")
+      return PrimitiveScript.#report(command, sys, changedFiles, diagnostics);
     let constantContent = await sys.readFile(constantPath);
     let dictionaryContent = await sys.readFile(dictionaryPath);
     const fieldBuilderName = viaBuilderParameterName(constantContent, inputClassName) ?? "field";
@@ -210,6 +154,8 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
       if (defaultCoercion.diagnostic)
         diagnostics.push(defaultCoercion.diagnostic);
       constantContent = ensureBaseTypeImport(constantContent, input.type);
+      if (input.type === "Date" && defaultCoercion.expression)
+        constantContent = ensureBaseImport(constantContent, "dayjs");
     }
     if (enumValues) {
       const defaultCoercion = coerceFieldDefault("enum", input.defaultValue, { enumValues });
@@ -311,7 +257,7 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
         }
       }
     }
-    if (!diagnostics.some((diagnostic) => diagnostic.severity === "error") && nextConstantContentWithLight && nextDictionaryContent) {
+    if (workflowStatus(diagnostics) === "passed" && nextConstantContentWithLight && nextDictionaryContent) {
       await sys.writeFile(constantPath, nextConstantContentWithLight);
       await sys.writeFile(dictionaryPath, nextDictionaryContent);
       changedFiles.push(sourceFile(sys, constantPath, "modify", "Field source shape was updated."), sourceFile(sys, dictionaryPath, "modify", "Field dictionary labels were updated."));
@@ -320,14 +266,7 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
         changedFiles.push(sourceFile(sys, templatePath, "modify", "Template field surface was updated."));
       }
     }
-    return createPrimitiveWriteReport({
-      command: enumValues ? "add-enum-field" : "add-field",
-      changedFiles,
-      generatedFiles,
-      validationCommands: validationCommandsForTarget(sys.name),
-      diagnostics,
-      nextActions: nextActionsForTarget(sys.name)
-    });
+    return PrimitiveScript.#report(command, sys, changedFiles, diagnostics);
   }
   async addMutation(workspace, input) {
     const moduleClassName = input.module ? moduleComponentName(input.module) : "";
@@ -353,7 +292,7 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
       signal: name ? {
         className: `${moduleClassName}Endpoint`,
         entryLine: [
-          `${name}: mutation(Boolean)`,
+          `${name}: mutation(Boolean, { guards: [None] })`,
           `    .exec(async function () {`,
           `      return await this.${serviceRef}Service.${name}();`,
           `    }),`
@@ -388,7 +327,7 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
       signal: name && queryName ? {
         className: `${moduleClassName}Slice`,
         entryLine: [
-          `${name}: init()`,
+          `${name}: init({ guards: [None] })`,
           `    .exec(function () {`,
           `      return this.${serviceRef}Service.${queryName}();`,
           `    }),`
@@ -401,60 +340,21 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
   async#writeServiceSignalEntry(workspace, spec) {
     const sys = await this.resolveSys(workspace, spec.app);
     const diagnostics = compactDiagnostics([
-      !sys && { severity: "error", code: "primitive-target-missing", message: "Target app or library was not found." },
-      !spec.module && {
-        severity: "error",
-        code: "primitive-input-missing",
-        message: "Module is required.",
-        input: "module"
-      },
-      !spec.entryName && {
-        severity: "error",
-        code: "primitive-input-missing",
-        message: `${capitalize(spec.requiredInput)} name is required.`,
-        input: spec.requiredInput
-      }
+      !sys && PrimitiveScript.#targetMissing(),
+      !spec.module && PrimitiveScript.#inputMissing("module"),
+      !spec.entryName && PrimitiveScript.#inputMissing(spec.requiredInput, `${capitalize(spec.requiredInput)} name is required.`)
     ]);
-    if (!sys || !spec.module || !spec.entryName || !spec.serviceMethod || !spec.signal) {
-      return createPrimitiveWriteReport({
-        command: spec.command,
-        changedFiles: [],
-        generatedFiles: [],
-        validationCommands: [],
-        diagnostics,
-        nextActions: []
-      });
-    }
-    const paths = moduleSourcePaths(spec.module);
-    const servicePath = paths.service;
-    const signalPath = paths.signal;
+    if (!sys || !spec.module || !spec.entryName || !spec.serviceMethod || !spec.signal)
+      return PrimitiveScript.#refuse(spec.command, diagnostics);
+    const { service: servicePath, signal: signalPath } = moduleSourcePaths(spec.module);
     const changedFiles = [];
-    const generatedFiles = generatedFilesForSync(sys);
     const [hasServiceFile, hasSignalFile] = await Promise.all([sys.exists(servicePath), sys.exists(signalPath)]);
-    if (!hasServiceFile) {
-      diagnostics.push({
-        severity: "error",
-        code: "primitive-source-missing",
-        message: `Service source file was not found: ${servicePath}.`
-      });
-    }
-    if (!hasSignalFile) {
-      diagnostics.push({
-        severity: "error",
-        code: "primitive-source-missing",
-        message: `Signal source file was not found: ${signalPath}.`
-      });
-    }
-    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
-      return createPrimitiveWriteReport({
-        command: spec.command,
-        changedFiles,
-        generatedFiles,
-        validationCommands: validationCommandsForTarget(sys.name),
-        diagnostics,
-        nextActions: nextActionsForTarget(sys.name)
-      });
-    }
+    if (!hasServiceFile)
+      diagnostics.push(PrimitiveScript.#sourceMissing("Service", servicePath));
+    if (!hasSignalFile)
+      diagnostics.push(PrimitiveScript.#sourceMissing("Signal", signalPath));
+    if (workflowStatus(diagnostics) === "failed")
+      return PrimitiveScript.#report(spec.command, sys, changedFiles, diagnostics);
     const serviceClassName = `${moduleComponentName(spec.module)}Service`;
     const serviceContent = await sys.readFile(servicePath);
     const signalContent = await sys.readFile(signalPath);
@@ -476,7 +376,8 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
       });
     }
     const nextServiceContent = serviceMethodExists ? serviceContent : insertClassMethod(serviceContent, serviceClassName, spec.serviceMethod.block);
-    const nextSignalContent = insertSignalFactoryEntry(signalContent, spec.signal.className, spec.entryName, spec.signal.entryLine, spec.signal.param);
+    const insertedSignalContent = insertSignalFactoryEntry(signalContent, spec.signal.className, spec.entryName, spec.signal.entryLine, spec.signal.param);
+    const nextSignalContent = insertedSignalContent ? ensureNamedImport(insertedSignalContent, "akanjs/signal", "None") : insertedSignalContent;
     if (!nextServiceContent) {
       diagnostics.push({
         severity: "error",
@@ -515,20 +416,46 @@ class PrimitiveScript extends script("primitive", [ModuleScript]) {
         message: `Edited ${signalPath} did not contain entry "${spec.entryName}" in ${spec.signal.className}.`
       });
     }
-    if (!diagnostics.some((diagnostic) => diagnostic.severity === "error") && nextServiceContent && nextSignalContent) {
+    if (workflowStatus(diagnostics) === "passed" && nextServiceContent && nextSignalContent) {
       await sys.writeFile(servicePath, nextServiceContent);
       await sys.writeFile(signalPath, nextSignalContent);
       changedFiles.push(sourceFile(sys, servicePath, "modify", `Service ${spec.entryKind} was added.`), sourceFile(sys, signalPath, "modify", `Signal ${spec.entryKind} was added.`));
     }
+    return PrimitiveScript.#report(spec.command, sys, changedFiles, diagnostics);
+  }
+  static #refuse(command, diagnostics) {
+    return createPrimitiveWriteReport({
+      command,
+      changedFiles: [],
+      generatedFiles: [],
+      validationCommands: [],
+      diagnostics,
+      nextActions: []
+    });
+  }
+  static #report(command, sys, changedFiles, diagnostics) {
     return createPrimitiveWriteReport({
-      command: spec.command,
+      command,
       changedFiles,
-      generatedFiles,
+      generatedFiles: generatedFilesForSync(sys),
       validationCommands: validationCommandsForTarget(sys.name),
       diagnostics,
       nextActions: nextActionsForTarget(sys.name)
     });
   }
+  static #targetMissing() {
+    return { severity: "error", code: "primitive-target-missing", message: "Target app or library was not found." };
+  }
+  static #inputMissing(input, message = `${capitalize(input)} is required.`) {
+    return { severity: "error", code: "primitive-input-missing", message, input };
+  }
+  static #sourceMissing(kind, path) {
+    return {
+      severity: "error",
+      code: "primitive-source-missing",
+      message: `${kind} source file was not found: ${path}.`
+    };
+  }
 }
 
 export { PrimitiveScript };

package/{index-fz5q3gd7.js → index-ya5qbmyg.js}

@@ -5,33 +5,26 @@ import {
   writeGeneratedSyncState,
   createRepairReport,
   renderRepairReport
-} from "./index-gyd220p2.js";
+} from "./index-yy4s1j72.js";
 import {
   AkanContextAnalyzer
-} from "./index-ktb5njgy.js";
+} from "./index-9629w7ns.js";
 import {
   runner
-} from "./index-mak3cd28.js";
+} from "./index-rmcw8yc8.js";
 
 // pkgs/@akanjs/cli/repair/repair.runner.ts
-var commandForShell = (command) => command.startsWith("akan ") ? `bun run ${command}` : command;
+var spawnShell = async (workspace, command) => await workspace.spawn("bash", ["-lc", command.startsWith("akan ") ? `bun run ${command}` : command], {
+  cwd: workspace.workspaceRoot
+});
 var defaultExecutor = (workspace) => async (command) => {
+  const base = { command: command.command, reason: command.reason };
   try {
-    const stdout = await workspace.spawn("bash", ["-lc", commandForShell(command.command)], {
-      cwd: workspace.workspaceRoot
-    });
-    return {
-      command: command.command,
-      reason: command.reason,
-      status: "passed",
-      exitCode: 0,
-      stdout
-    };
+    return { ...base, status: "passed", exitCode: 0, stdout: await spawnShell(workspace, command.command) };
   } catch (error) {
     const commandError = error;
     return {
-      command: command.command,
-      reason: command.reason,
+      ...base,
       status: "failed",
       exitCode: commandError.code ?? 1,
       stdout: commandError.stdout,
@@ -158,4 +151,4 @@ class RepairRunner extends runner("repair") {
   }
 }
 
-export { RepairRunner };
+export { spawnShell, RepairRunner };