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

package/repair.command-677675vw.js

@@ -0,0 +1,67 @@
+// @bun
+import {
+  RepairRunner
+} from "./index-85msc0wg.js";
+import"./index-8rc0bm04.js";
+import"./index-h6ca6qg0.js";
+import {
+  Workspace,
+  command,
+  script
+} from "./index-hdqztm58.js";
+import"./index-a6sbyy0b.js";
+import"./index-61keag0s.js";
+import"./index-6pz1j0zj.js";
+import"./index-r24hmh0q.js";
+
+// pkgs/@akanjs/cli/repair/repair.script.ts
+import { Logger } from "akanjs/common";
+class RepairScript extends script("repair", [RepairRunner]) {
+  async repair(kind, {
+    workspace,
+    app = null,
+    module = null,
+    target = null,
+    format = "markdown"
+  }) {
+    Logger.rawLog(await this.repairRunner.repair(kind, {
+      workspace,
+      app,
+      module,
+      target,
+      format
+    }));
+  }
+}
+
+// pkgs/@akanjs/cli/repair/repair.command.ts
+class RepairCommand extends command("repair", [RepairScript], ({ public: target }) => ({
+  repair: target({ desc: "Run a narrow Akan repair command and return a structured report" }).arg("kind", String, {
+    desc: "generated, format, imports, dictionary, or module-shape",
+    enum: ["generated", "format", "imports", "dictionary", "module-shape"]
+  }).with(Workspace).option("format", String, {
+    desc: "output format",
+    flag: "o",
+    default: "markdown",
+    enum: ["markdown", "json"]
+  }).option("app", String, {
+    desc: "target app or library for generated/dictionary/module-shape repair",
+    nullable: true
+  }).option("module", String, { desc: "target module for dictionary/module-shape repair", nullable: true }).option("target", String, {
+    flag: "t",
+    desc: "target app, library, or package for format/imports repair",
+    nullable: true
+  }).exec(async function(kind, workspace, format, app, module, targetName) {
+    await this.repairScript.repair(kind, {
+      workspace,
+      format,
+      app,
+      module,
+      target: targetName
+    });
+  })
+})) {
+}
+export {
+  RepairCommand
+};

package/routeSourceValidator-wbhmbwpj.js

@@ -0,0 +1,132 @@
+// @bun
+import"./index-r24hmh0q.js";
+
+// pkgs/@akanjs/devkit/routeSourceValidator.ts
+import ts from "typescript";
+
+class RouteSourceValidator {
+  static #pageExports = new Set([
+    "default",
+    "pageConfig",
+    "head",
+    "metadata",
+    "generateHead",
+    "generateMetadata",
+    "Loading"
+  ]);
+  static #rootLayoutExports = new Set([
+    "default",
+    "pageConfig",
+    "head",
+    "metadata",
+    "generateHead",
+    "generateMetadata",
+    "fonts",
+    "manifest",
+    "theme",
+    "reconnect",
+    "layoutStyle",
+    "gaTrackingId",
+    "Loading",
+    "NotFound",
+    "Error"
+  ]);
+  static #layoutExports = new Set([
+    "default",
+    "pageConfig",
+    "head",
+    "metadata",
+    "generateHead",
+    "generateMetadata",
+    "Loading",
+    "NotFound",
+    "Error"
+  ]);
+  static validateRouteSourceExports(source, filePath, kind, options = {}) {
+    const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    const allowed = kind === "page" ? RouteSourceValidator.#pageExports : options.rootLayout ? RouteSourceValidator.#rootLayoutExports : RouteSourceValidator.#layoutExports;
+    const exported = new Set;
+    const assertExport = (name) => {
+      if (!allowed.has(name)) {
+        throw new Error(`[route-convention] unsupported export "${name}" in ${filePath}`);
+      }
+      exported.add(name);
+    };
+    for (const statement of sourceFile.statements) {
+      if (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement))
+        continue;
+      if (ts.isExportDeclaration(statement)) {
+        if (statement.isTypeOnly)
+          continue;
+        const clause = statement.exportClause;
+        if (!clause)
+          throw new Error(`[route-convention] export * is not allowed in route modules: ${filePath}`);
+        if (ts.isNamedExports(clause)) {
+          for (const element of clause.elements) {
+            if (element.isTypeOnly)
+              continue;
+            assertExport(element.name.text);
+          }
+        }
+        continue;
+      }
+      const modifiers = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : undefined;
+      const isExported = modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+      if (!isExported)
+        continue;
+      const isDefault = modifiers?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword) ?? false;
+      if (isDefault) {
+        assertExport("default");
+        continue;
+      }
+      if (ts.isVariableStatement(statement)) {
+        for (const declaration of statement.declarationList.declarations) {
+          if (ts.isIdentifier(declaration.name))
+            assertExport(declaration.name.text);
+        }
+        continue;
+      }
+      const name = statement.name;
+      if (name && ts.isIdentifier(name)) {
+        assertExport(name.text);
+      }
+    }
+    if (exported.has("head") && exported.has("generateHead")) {
+      throw new Error(`[route-convention] head and generateHead cannot both be exported in ${filePath}`);
+    }
+    if (!options.rootLayout && (exported.has("head") || exported.has("generateHead")) && (exported.has("metadata") || exported.has("generateMetadata"))) {
+      throw new Error(`[route-convention] head/generateHead and metadata/generateMetadata cannot both be exported in ${filePath}`);
+    }
+    if (exported.has("metadata") && exported.has("generateMetadata")) {
+      throw new Error(`[route-convention] metadata and generateMetadata cannot both be exported in ${filePath}`);
+    }
+  }
+  static validateOverridesSourceExports(source, filePath) {
+    const sourceFile = ts.createSourceFile(filePath, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX);
+    const fail = (message) => {
+      throw new Error(`[route-convention] ${message}: ${filePath}`);
+    };
+    let defaultOverride = null;
+    for (const statement of sourceFile.statements) {
+      if (ts.isExpressionStatement(statement) && ts.isStringLiteral(statement.expression))
+        continue;
+      if (ts.isImportDeclaration(statement))
+        continue;
+      if (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement))
+        continue;
+      if (ts.isExportAssignment(statement) && !statement.isExportEquals) {
+        defaultOverride = statement;
+        continue;
+      }
+      fail(`_overrides.tsx may only contain imports and a single "export default override({ ... })"`);
+    }
+    if (!defaultOverride)
+      return fail(`_overrides.tsx must "export default override({ ... })"`);
+    const expression = defaultOverride.expression;
+    if (!ts.isCallExpression(expression) || !ts.isIdentifier(expression.expression) || expression.expression.text !== "override")
+      fail(`_overrides.tsx default export must be a call to "override", e.g. "export default override({ Modal: BrandModal })"`);
+  }
+}
+export {
+  RouteSourceValidator
+};

package/scalar.command-kabkd6wd.js

@@ -0,0 +1,35 @@
+// @bun
+import {
+  ScalarScript
+} from "./index-y3hdhy4p.js";
+import"./index-ss469dec.js";
+import"./index-qaq13qk3.js";
+import {
+  renderPrimitiveReport
+} from "./index-h6ca6qg0.js";
+import"./index-5vvwc0cz.js";
+import {
+  Sys,
+  command
+} from "./index-hdqztm58.js";
+import"./index-a6sbyy0b.js";
+import"./index-61keag0s.js";
+import"./index-6pz1j0zj.js";
+import"./index-r24hmh0q.js";
+
+// pkgs/@akanjs/cli/scalar/scalar.command.ts
+import { Logger, lowerlize } from "akanjs/common";
+class ScalarCommand extends command("scalar", [ScalarScript], ({ public: target }) => ({
+  createScalar: target({ desc: "Create a new scalar type (simple data model without DB)" }).arg("scalarName", String, { desc: "name of scalar" }).with(Sys).option("ai", Boolean, { default: false, desc: "use ai to create scalar" }).option("format", String, { flag: "o", desc: "output format", default: "markdown", enum: ["markdown", "json"] }).exec(async function(scalarName, sys, ai, format) {
+    const name = lowerlize(scalarName.replace(/ /g, ""));
+    const report = ai ? await this.scalarScript.createScalarWithAi(sys, name) : await this.scalarScript.createScalar(sys, name);
+    Logger.rawLog(renderPrimitiveReport(report, format));
+  }),
+  removeScalar: target({ desc: "Remove a scalar type from an app or library" }).arg("scalarName", String, { desc: "name of scalar" }).with(Sys).exec(async function(scalarName, sys) {
+    await this.scalarScript.removeScalar(sys, scalarName);
+  })
+})) {
+}
+export {
+  ScalarCommand
+};

package/templates/app/page/_layout.tsx

@@ -9,9 +9,27 @@ export default function getContent(scanInfo: AppInfo | LibInfo | null, dict: Dic
     filename: "_layout.tsx",
     content: `
 import "./styles.css";
-import type { LayoutProps } from "akanjs/client";
+import type { Font, LayoutProps } from "akanjs/client";
 ${isUsingShared ? "import { Auth } from '@shared/ui';" : ""}
 
+export const fonts: Font[] = [
+  {
+    name: "pretendard",
+    default: true,
+    paths: [
+      { src: "/fonts/Pretendard-Thin.woff2", weight: 100 },
+      { src: "/fonts/Pretendard-ExtraLight.woff2", weight: 200 },
+      { src: "/fonts/Pretendard-Light.woff2", weight: 300 },
+      { src: "/fonts/Pretendard-Regular.woff2", weight: 400 },
+      { src: "/fonts/Pretendard-Medium.woff2", weight: 500 },
+      { src: "/fonts/Pretendard-SemiBold.woff2", weight: 600 },
+      { src: "/fonts/Pretendard-Bold.woff2", weight: 700 },
+      { src: "/fonts/Pretendard-ExtraBold.woff2", weight: 800 },
+      { src: "/fonts/Pretendard-Black.woff2", weight: 900 },
+    ],
+  },
+];
+
 export const head = (
   <>
     <title>${dict.appName}</title>

package/templates/facetIndex/index.ts

@@ -1,4 +1,4 @@
-import type { SysExecutor } from "@akanjs/devkit";
+import type { SysExecutor } from "@akanjs/devkit/executors";
 import type { AppInfo, LibInfo } from "akanjs";
 
 interface Dict {

package/typeChecker-kravn7ns.js

@@ -0,0 +1,8 @@
+// @bun
+import {
+  TypeChecker
+} from "./index-wnp7hwq7.js";
+import"./index-r24hmh0q.js";
+export {
+  TypeChecker
+};

package/typecheck.proc.js

@@ -1,201 +1,11 @@
 // @bun
-var __require = import.meta.require;
+import {
+  TypeChecker
+} from "./index-wnp7hwq7.js";
+import"./index-r24hmh0q.js";
 
 // pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts
 import { Logger } from "akanjs/common";
-
-// pkgs/@akanjs/devkit/typeChecker.ts
-import { readFileSync } from "fs";
-import * as path from "path";
-import chalk from "chalk";
-import * as ts from "typescript";
-
-class TypeChecker {
-  configPath;
-  configFile;
-  config;
-  constructor(executor) {
-    const configPath = this.#findConfigFile(executor.cwdPath);
-    if (!configPath)
-      throw new Error("No tsconfig.json found in the project");
-    this.configPath = configPath;
-    this.configFile = ts.readConfigFile(this.configPath, (fileName) => ts.sys.readFile(fileName));
-    const parsedConfig = ts.parseJsonConfigFileContent(this.configFile.config, ts.sys, path.dirname(this.configPath), undefined, this.configPath);
-    if (parsedConfig.errors.length > 0) {
-      const errorMessages = parsedConfig.errors.map((error) => ts.flattenDiagnosticMessageText(error.messageText, `
-`)).join(`
-`);
-      throw new Error(`Error parsing tsconfig.json:
-${errorMessages}`);
-    }
-    this.config = parsedConfig;
-  }
-  #findConfigFile(searchPath) {
-    return ts.findConfigFile(searchPath, (fileName) => ts.sys.fileExists(fileName), "tsconfig.json");
-  }
-  check(filePath) {
-    const program = ts.createProgram([filePath], this.config.options);
-    const diagnostics = [
-      ...program.getSemanticDiagnostics(),
-      ...program.getSyntacticDiagnostics(),
-      ...this.config.options.declaration ? program.getDeclarationDiagnostics() : []
-    ];
-    const errors = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
-    const warnings = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Warning);
-    const fileDiagnostics = diagnostics.filter((diagnostic) => diagnostic.file?.fileName === filePath);
-    const fileErrors = fileDiagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
-    const fileWarnings = fileDiagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Warning);
-    return { diagnostics, errors, warnings, fileDiagnostics, fileErrors, fileWarnings };
-  }
-  formatDiagnostics(diagnostics) {
-    if (diagnostics.length === 0)
-      return chalk.bold("\u2705 No type errors found");
-    const output = [];
-    let errorCount = 0;
-    let warningCount = 0;
-    let suggestionCount = 0;
-    const diagnosticsByFile = new Map;
-    diagnostics.forEach((diagnostic) => {
-      if (diagnostic.category === ts.DiagnosticCategory.Error)
-        errorCount++;
-      else if (diagnostic.category === ts.DiagnosticCategory.Warning)
-        warningCount++;
-      else if (diagnostic.category === ts.DiagnosticCategory.Suggestion)
-        suggestionCount++;
-      if (diagnostic.file) {
-        const fileName = diagnostic.file.fileName;
-        if (!diagnosticsByFile.has(fileName))
-          diagnosticsByFile.set(fileName, []);
-        const fileDiagnostics = diagnosticsByFile.get(fileName);
-        if (fileDiagnostics)
-          fileDiagnostics.push(diagnostic);
-      } else {
-        if (!diagnosticsByFile.has(""))
-          diagnosticsByFile.set("", []);
-        const fileDiagnostics = diagnosticsByFile.get("");
-        if (fileDiagnostics)
-          fileDiagnostics.push(diagnostic);
-      }
-    });
-    diagnosticsByFile.forEach((fileDiagnostics, fileName) => {
-      if (fileName)
-        output.push(`
-${chalk.cyan(fileName)}`);
-      fileDiagnostics.forEach((diagnostic) => {
-        const categoryText = diagnostic.category === ts.DiagnosticCategory.Error ? "error" : diagnostic.category === ts.DiagnosticCategory.Warning ? "warning" : "suggestion";
-        const categoryColor = diagnostic.category === ts.DiagnosticCategory.Error ? chalk.red : diagnostic.category === ts.DiagnosticCategory.Warning ? chalk.yellow : chalk.blue;
-        const icon = diagnostic.category === ts.DiagnosticCategory.Error ? "\u274C" : diagnostic.category === ts.DiagnosticCategory.Warning ? "\u26A0\uFE0F" : "\uD83D\uDCA1";
-        const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, `
-`);
-        const tsCode = chalk.dim(`(TS${diagnostic.code})`);
-        if (diagnostic.file && diagnostic.start !== undefined) {
-          const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-          output.push(`
-  ${icon} ${categoryColor(categoryText)}: ${message} ${tsCode}`);
-          output.push(`     ${chalk.gray("at")} ${fileName}:${chalk.bold(`${line + 1}:${character + 1}`)}`);
-          const sourceLines = diagnostic.file.text.split(`
-`);
-          if (line < sourceLines.length) {
-            const sourceLine = sourceLines[line];
-            const lineNumber = (line + 1).toString().padStart(5, " ");
-            output.push(`
-${chalk.dim(`${lineNumber} |`)} ${sourceLine}`);
-            const underlinePrefix = " ".repeat(character);
-            const length = diagnostic.length ?? 1;
-            const underline = "~".repeat(Math.max(1, length));
-            output.push(`${chalk.dim(`${" ".repeat(lineNumber.length)} |`)} ${underlinePrefix}${categoryColor(underline)}`);
-          }
-        } else
-          output.push(`
-  ${icon} ${categoryColor(categoryText)}: ${message} ${tsCode}`);
-      });
-    });
-    const summary = [];
-    if (errorCount > 0)
-      summary.push(chalk.red(`${errorCount} error(s)`));
-    if (warningCount > 0)
-      summary.push(chalk.yellow(`${warningCount} warning(s)`));
-    if (suggestionCount > 0)
-      summary.push(chalk.blue(`${suggestionCount} suggestion(s)`));
-    return `
-${summary.join(", ")} found${output.join(`
-`)}`;
-  }
-  getDetailedDiagnostics(filePath) {
-    const { diagnostics } = this.check(filePath);
-    const sourceFile = ts.createSourceFile(filePath, readFileSync(filePath, "utf8"), ts.ScriptTarget.Latest, true);
-    const details = diagnostics.map((diagnostic) => {
-      if (diagnostic.file && diagnostic.start !== undefined) {
-        const { line, character } = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start);
-        const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, `
-`);
-        const lines = sourceFile.text.split(`
-`);
-        const codeSnippet = line < lines.length ? lines[line] : undefined;
-        return { line: line + 1, column: character + 1, message, code: diagnostic.code, codeSnippet };
-      }
-      return {
-        line: 0,
-        column: 0,
-        message: ts.flattenDiagnosticMessageText(diagnostic.messageText, `
-`),
-        code: diagnostic.code
-      };
-    });
-    return { diagnostics, details };
-  }
-  hasNoTypeErrors(filePath) {
-    try {
-      const { diagnostics } = this.check(filePath);
-      return diagnostics.length === 0;
-    } catch (error) {
-      return false;
-    }
-  }
-  static checkProject(configPath) {
-    const parsedConfig = TypeChecker.parseConfig(configPath);
-    const host = ts.createIncrementalCompilerHost(parsedConfig.options);
-    const builderProgram = ts.createIncrementalProgram({
-      rootNames: parsedConfig.fileNames,
-      options: parsedConfig.options,
-      projectReferences: parsedConfig.projectReferences,
-      configFileParsingDiagnostics: parsedConfig.errors,
-      host
-    });
-    const program = builderProgram.getProgram();
-    const diagnostics = [...ts.getPreEmitDiagnostics(program), ...builderProgram.emit().diagnostics];
-    const errors = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Error);
-    const warnings = diagnostics.filter((diagnostic) => diagnostic.category === ts.DiagnosticCategory.Warning);
-    return {
-      configPath,
-      diagnostics,
-      errors,
-      warnings,
-      message: TypeChecker.formatDiagnosticMessages(diagnostics)
-    };
-  }
-  static parseConfig(configPath) {
-    const configFile = ts.readConfigFile(configPath, (fileName) => ts.sys.readFile(fileName));
-    const configDiagnostics = configFile.error ? [configFile.error] : [];
-    if (!configFile.config) {
-      const message = TypeChecker.formatDiagnosticMessages(configDiagnostics);
-      throw new Error(message || `Error reading tsconfig.json: ${configPath}`);
-    }
-    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(configPath), undefined, configPath);
-    if (parsedConfig.errors.length > 0)
-      throw new Error(TypeChecker.formatDiagnosticMessages(parsedConfig.errors));
-    return parsedConfig;
-  }
-  static formatDiagnosticMessages(diagnostics) {
-    return ts.formatDiagnosticsWithColorAndContext(diagnostics, {
-      getCanonicalFileName: (fileName) => fileName,
-      getCurrentDirectory: () => process.cwd(),
-      getNewLine: () => ts.sys.newLine
-    });
-  }
-}
-
-// pkgs/@akanjs/devkit/typecheck/typecheck.proc.ts
 try {
   const filePath = process.env.AKAN_TYPECHECK_FILE;
   if (filePath) {

package/workflow.command-64r6cw0w.js

@@ -0,0 +1,108 @@
+// @bun
+import {
+  WorkflowRunner
+} from "./index-45aj5ry0.js";
+import {
+  ScalarScript
+} from "./index-y3hdhy4p.js";
+import {
+  PrimitiveScript
+} from "./index-73pr2cmy.js";
+import"./index-8rc0bm04.js";
+import {
+  ModuleScript
+} from "./index-8pkbzj26.js";
+import"./index-swf4bmbg.js";
+import"./index-ss469dec.js";
+import"./index-qaq13qk3.js";
+import {
+  createWorkflowStepRegistry
+} from "./index-h6ca6qg0.js";
+import"./index-5vvwc0cz.js";
+import {
+  Workspace,
+  command,
+  script
+} from "./index-hdqztm58.js";
+import"./index-a6sbyy0b.js";
+import"./index-61keag0s.js";
+import"./index-6pz1j0zj.js";
+import"./index-r24hmh0q.js";
+
+// pkgs/@akanjs/cli/workflow/workflow.script.ts
+import { Logger } from "akanjs/common";
+class WorkflowScript extends script("workflow", [WorkflowRunner, ModuleScript, ScalarScript, PrimitiveScript]) {
+  async workflow(action, workflow, inputs, {
+    format = "markdown",
+    out = null,
+    dryRun = false,
+    workspace
+  } = {}) {
+    if (action === "list") {
+      Logger.rawLog(this.workflowRunner.list({ format }));
+      return;
+    }
+    if (!workflow)
+      throw new Error(`Workflow name is required for "${action}".`);
+    if (action === "explain") {
+      Logger.rawLog(this.workflowRunner.explain(workflow, { format }));
+      return;
+    }
+    if (action === "plan") {
+      Logger.rawLog(await this.workflowRunner.plan(workflow, inputs, { format, out }));
+      return;
+    }
+    if (action === "apply") {
+      if (!workspace)
+        throw new Error("Workspace is required for workflow apply.");
+      Logger.rawLog(await this.workflowRunner.apply(workflow, {
+        dryRun,
+        format,
+        workspace,
+        registry: createWorkflowStepRegistry({
+          workspace,
+          createModule: (sys, module) => this.moduleScript.createModuleTemplate(sys, module),
+          createScalar: (sys, scalar) => this.scalarScript.createScalar(sys, scalar),
+          createUi: (input) => this.primitiveScript.createUi(workspace, input),
+          addField: (input) => this.primitiveScript.addField(workspace, input),
+          addEnumField: (input) => this.primitiveScript.addEnumField(workspace, input),
+          addMutation: (input) => this.primitiveScript.addMutation(workspace, input),
+          addSlice: (input) => this.primitiveScript.addSlice(workspace, input)
+        })
+      }));
+      return;
+    }
+    if (action === "validate") {
+      if (!workspace)
+        throw new Error("Workspace is required for workflow validate.");
+      Logger.rawLog(await this.workflowRunner.validate(workflow, { format, workspace }));
+      return;
+    }
+    if (action === "report") {
+      if (!workspace)
+        throw new Error("Workspace is required for workflow report.");
+      Logger.rawLog(await this.workflowRunner.report(workflow, { format, workspace }));
+      return;
+    }
+    throw new Error(`Unknown workflow action: ${action}. Use list, explain, plan, apply, validate, or report.`);
+  }
+}
+
+// pkgs/@akanjs/cli/workflow/workflow.command.ts
+class WorkflowCommand extends command("workflow", [WorkflowScript], ({ public: target }) => ({
+  workflow: target({ desc: "List, explain, plan, apply, validate, or report Akan workflows" }).arg("action", String, {
+    desc: "list, explain, plan, apply, validate, or report",
+    enum: ["list", "explain", "plan", "apply", "validate", "report"]
+  }).arg("workflow", String, { desc: "workflow name, plan path, or run id", nullable: true }).with(Workspace).option("format", String, {
+    desc: "output format",
+    flag: "o",
+    default: "markdown",
+    enum: ["markdown", "json"]
+  }).option("out", String, { flag: "w", desc: "write workflow plan JSON to this path", nullable: true }).option("dryRun", Boolean, { flag: "r", desc: "show predicted apply report without writing files", default: false }).option("app", String, { desc: "target app or library name", nullable: true }).option("module", String, { desc: "target module name", nullable: true }).option("field", String, { desc: "field name", nullable: true }).option("type", String, { desc: "field type or scalar name", nullable: true }).option("values", String, { flag: "l", desc: "comma-separated values", nullable: true }).option("default", String, { desc: "default value", nullable: true }).option("scalar", String, { flag: "c", desc: "scalar name", nullable: true }).option("surface", String, { flag: "u", desc: "UI surface name", nullable: true }).option("mutation", String, { flag: "n", desc: "mutation name", nullable: true }).option("slice", String, { flag: "i", desc: "slice name", nullable: true }).exec(async function(action, workflow, workspace, format, out, dryRun, app, module, field, typeName, values, defaultValue, scalar, surface, mutation, slice) {
+    await this.workflowScript.workflow(action, workflow, { app, module, field, type: typeName, values, default: defaultValue, scalar, surface, mutation, slice }, { format, out, dryRun, workspace });
+  })
+})) {
+}
+export {
+  WorkflowCommand
+};