@akanjs/cli 2.3.9-rc.0 → 2.3.9-rc.2

package/incrementalBuilder.proc.js

@@ -2809,7 +2809,7 @@ class Executor {
     this.logger.verbose(`Remove directory ${readPath}`);
     return this;
   }
-  async writeFile(filePath, content, { overwrite = true } = {}) {
+  async writeFile(filePath, content, { overwrite = true, silent = false } = {}) {
     const writePath = this.getPath(filePath);
     const dir = path7.dirname(writePath);
     if (!await FileSys.dirExists(dir))
@@ -2827,7 +2827,8 @@ class Executor {
       }
     } else {
       await FileSys.writeText(writePath, contentStr);
-      this.logger.rawLog(chalk4.green(`File Create: ${filePath}`));
+      if (!silent)
+        this.logger.rawLog(chalk4.green(`File Create: ${filePath}`));
     }
     return { filePath: writePath, content: contentStr };
   }
@@ -3491,14 +3492,15 @@ class AppExecutor extends SysExecutor {
   getCommandEnv(env = {}) {
     const basePort = 8282;
     const portOffset = WorkspaceExecutor.getBaseDevEnv().portOffset;
-    const PORT = basePort ? (basePort + portOffset).toString() : undefined;
+    const PORT = (basePort + portOffset).toString();
     const AKAN_PUBLIC_SERVER_PORT = portOffset ? (8282 + portOffset).toString() : undefined;
     return {
       ...process.env,
       AKAN_PUBLIC_APP_NAME: this.name,
       AKAN_WORKSPACE_ROOT: this.workspace.workspaceRoot,
       NODE_NO_WARNINGS: "1",
-      ...PORT ? { PORT, AKAN_PUBLIC_CLIENT_PORT: PORT } : {},
+      PORT,
+      AKAN_PUBLIC_CLIENT_PORT: PORT,
       ...AKAN_PUBLIC_SERVER_PORT ? { AKAN_PUBLIC_SERVER_PORT } : {},
       ...env
     };
@@ -4777,17 +4779,91 @@ class AkanAppHost {
 import { readdir } from "fs/promises";
 import path10 from "path";
 import { capitalize as capitalize2 } from "akanjs/common";
+var resourceList = [
+  { uri: "akan://docs/framework", name: "Akan framework guide", mimeType: "text/markdown" },
+  { uri: "akan://guidelines/framework", name: "Framework guideline", mimeType: "text/markdown" },
+  { uri: "akan://guidelines/modelSignal", name: "Model signal guideline", mimeType: "text/markdown" },
+  { uri: "akan://workspace/summary", name: "Workspace summary", mimeType: "application/json" },
+  { uri: "akan://workspace/apps", name: "Workspace apps", mimeType: "application/json" },
+  { uri: "akan://workspace/modules", name: "Workspace modules", mimeType: "application/json" }
+];
+var cursorMcpConfigPath = ".cursor/mcp.json";
+var cursorWorkspaceFolder = "$" + "{workspaceFolder}";
+var createAkanCursorMcpServer = (mode = "readonly") => ({
+  type: "stdio",
+  command: "bash",
+  args: ["-lc", `cd "${cursorWorkspaceFolder}" && akan mcp --mode ${mode}`]
+});
+var akanCursorMcpServer = createAkanCursorMcpServer();
+var renderDoctorText = (result) => {
+  const lines = [`Akan doctor status: ${result.status}`];
+  if (result.diagnostics.length === 0) {
+    lines.push("", "No Akan workspace diagnostics found.");
+  } else {
+    lines.push("", ...result.diagnostics.map((diagnostic) => [
+      `[${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`,
+      diagnostic.path ? `  ${diagnostic.path}` : ""
+    ].filter(Boolean).join(`
+`)));
+  }
+  lines.push("", "Generated file freshness:", result.generatedFilesFreshness.message, `Refresh: ${result.generatedFilesFreshness.refreshCommand}`, "", "Repair actions:", ...result.repairActions.length ? result.repairActions.map((action) => `- ${action.command}`) : ["- none"], "", "Validation commands:", ...result.validationCommands.map((command) => `- ${command}`));
+  return `${lines.join(`
+`)}
+`;
+};
 var generatedFiles = [
-  "cnst.ts",
-  "db.ts",
-  "dict.ts",
-  "option.ts",
-  "sig.ts",
-  "srv.ts",
-  "st.ts",
-  "useClient.ts",
-  "useServer.ts"
+  "apps/*/client.ts",
+  "apps/*/server.ts",
+  "*/lib/cnst.ts",
+  "*/lib/db.ts",
+  "*/lib/dict.ts",
+  "*/lib/option.ts",
+  "*/lib/sig.ts",
+  "*/lib/srv.ts",
+  "*/lib/st.ts",
+  "*/lib/useClient.ts",
+  "*/lib/useServer.ts",
+  "*/lib/**/index.ts",
+  "*/ui/index.ts",
+  "*/webkit/index.ts",
+  "*/srvkit/index.ts",
+  "*/common/index.ts"
+];
+var validationCommands = [
+  "akan sync <app-or-lib>",
+  "akan lint <app-or-lib-or-pkg>",
+  "akan typecheck <app-name>",
+  "akan test <app-or-lib-or-pkg>",
+  "akan build <app-name>",
+  "akan doctor --strict --format json"
 ];
+var generatedFilesFreshness = {
+  status: "unknown",
+  message: "Run sync before validation so generated Akan files match the current source conventions.",
+  refreshCommand: "akan sync <app-or-lib>",
+  verifyingCommands: ["akan lint <app-or-lib-or-pkg>", "akan build <app-name>"]
+};
+var repairAction = (kind, command, reason, safeToRun) => ({
+  kind,
+  command,
+  reason,
+  safeToRun
+});
+var moduleShapeFiles = (module) => {
+  if (module.kind === "service") {
+    return [`${module.name}.dictionary.ts`, `${module.name}.service.ts`, `${module.name}.signal.ts`];
+  }
+  if (module.kind === "scalar")
+    return [`${module.name}.constant.ts`, `${module.name}.dictionary.ts`];
+  return [
+    `${module.name}.constant.ts`,
+    `${module.name}.dictionary.ts`,
+    `${module.name}.service.ts`,
+    `${module.name}.store.ts`,
+    `${module.name}.signal.ts`
+  ];
+};
+var constantFieldNames = (content) => [...content.matchAll(/\b([A-Za-z_$][\w$]*)\s*:\s*field\(/g)].map((match) => match[1]).filter(Boolean);
 var appRootAllowFiles = new Set([
   "akan.app.json",
   "akan.config.ts",
@@ -4945,39 +5021,95 @@ class AkanContextAnalyzer {
       libs,
       pkgs,
       generatedFiles,
-      validationCommands: ["akan lint <app-or-lib-or-pkg>", "akan build <app-name>", "akan start <app-name>"]
+      validationCommands
     };
   }
   static async doctor(workspace, { strict = false } = {}) {
     const context = await AkanContextAnalyzer.analyze(workspace);
     const diagnostics = [];
+    const repairActions = [
+      repairAction("generated", "akan repair generated --app <app-or-lib>", "Refresh generated Akan files.", true),
+      repairAction("format", "akan repair format --target <app-or-lib-or-pkg>", "Run the formatter/linter repair path.", true)
+    ];
     for (const app of context.apps) {
       const appPath = path10.join(workspace.workspaceRoot, app.path);
       for (const entry of await safeReadDir(appPath)) {
         const allowed = entry.isDirectory() ? appRootAllowDirs.has(entry.name) : appRootAllowFiles.has(entry.name);
         if (!allowed) {
+          const action = repairAction("module-shape", `akan repair module-shape --app ${app.name}`, "Review app root shape and remove or move the unknown entry.", false);
           diagnostics.push({
-            severity: "warning",
+            severity: "error",
             code: "app-root-unknown-entry",
             path: `${app.path}/${entry.name}`,
-            message: `Unexpected ${entry.isDirectory() ? "folder" : "file"} in app root: ${app.path}/${entry.name}`
+            message: `Unexpected ${entry.isDirectory() ? "folder" : "file"} in app root: ${app.path}/${entry.name}`,
+            repairActions: [action]
           });
+          repairActions.push(action);
         }
       }
     }
     for (const sys2 of [...context.apps, ...context.libs]) {
       for (const module of sys2.modules) {
         if (!module.abstract.exists) {
+          const action = repairAction("module-shape", `akan repair module-shape --app ${sys2.name} --module ${module.name}`, "Create the missing module abstract or inspect required source files.", false);
           diagnostics.push({
             severity: strict ? "error" : "warning",
             code: "module-abstract-missing",
             path: module.abstract.path,
-            message: `${capitalize2(module.kind)} module ${sys2.name}:${module.name} should include ${module.abstract.path}`
+            message: `${capitalize2(module.kind)} module ${sys2.name}:${module.name} should include ${module.abstract.path}`,
+            repairActions: [action]
+          });
+          repairActions.push(action);
+        }
+        const missingFiles = moduleShapeFiles(module).filter((filename) => !module.files.includes(filename));
+        if (missingFiles.length) {
+          const action = repairAction("module-shape", `akan repair module-shape --app ${sys2.name} --module ${module.name}`, "Review missing required module source files.", false);
+          diagnostics.push({
+            severity: "error",
+            code: "module-shape-invalid",
+            path: module.path,
+            message: `${capitalize2(module.kind)} module ${sys2.name}:${module.name} is missing required files: ${missingFiles.join(", ")}`,
+            repairActions: [action]
           });
+          repairActions.push(action);
+        }
+        if (module.kind !== "service" && module.files.includes(`${module.name}.dictionary.ts`)) {
+          const constantPath = path10.join(workspace.workspaceRoot, module.path, `${module.name}.constant.ts`);
+          const dictionaryPath = path10.join(workspace.workspaceRoot, module.path, `${module.name}.dictionary.ts`);
+          const [constantContent, dictionaryContent] = await Promise.all([
+            safeReadText(constantPath),
+            safeReadText(dictionaryPath)
+          ]);
+          if (constantContent && dictionaryContent) {
+            for (const fieldName of constantFieldNames(constantContent)) {
+              if (new RegExp(`\\b${fieldName}\\s*:`).test(dictionaryContent))
+                continue;
+              const action = repairAction("dictionary", `akan repair dictionary --app ${sys2.name} --module ${module.name}`, "Add missing dictionary labels for source constant fields.", false);
+              diagnostics.push({
+                severity: "warning",
+                code: "dictionary-label-missing",
+                path: `${module.path}/${module.name}.dictionary.ts`,
+                message: `Dictionary labels for ${sys2.name}:${module.name}.${fieldName} were not found.`,
+                repairActions: [action]
+              });
+              repairActions.push(action);
+            }
+          }
         }
       }
     }
-    return { schemaVersion: 1, strict, diagnostics };
+    return {
+      schemaVersion: 1,
+      repoName: context.repoName,
+      root: context.root,
+      strict,
+      status: diagnostics.some((diagnostic) => diagnostic.severity === "error") ? "failed" : "passed",
+      diagnostics,
+      generatedFiles: context.generatedFiles,
+      generatedFilesFreshness,
+      validationCommands: context.validationCommands,
+      repairActions
+    };
   }
   static findModules(context, moduleName) {
     const modules = [...context.apps, ...context.libs].flatMap((sys2) => sys2.modules);
@@ -11115,6 +11247,8 @@ var getInternalArgumentValue = async (argMeta, value, workspace) => {
   } else if (sysType === "app") {
     if (value && appNames.includes(value))
       return AppExecutor.from(workspace, value);
+    if (!value && appNames.length === 1 && appNames[0])
+      return AppExecutor.from(workspace, appNames[0]);
     const appName = await select3({ message: `Select the ${sysType} name`, choices: appNames });
     return AppExecutor.from(workspace, appName);
   } else if (sysType === "lib") {
@@ -11690,6 +11824,761 @@ import { Box as Box2, Newline, Text as Text2, useInput as useInput2 } from "ink"
 import { useEffect as useEffect3, useState as useState3 } from "react";
 import { jsxDEV as jsxDEV2, Fragment as Fragment2 } from "react/jsx-dev-runtime";
 "use client";
+// pkgs/@akanjs/devkit/workflow/index.ts
+var jsonText = (value, { trailingNewline = true } = {}) => `${JSON.stringify(value, null, 2)}${trailingNewline ? `
+` : ""}`;
+var surfaceModes = new Set(["infer", "include", "skip"]);
+var parseStringList = (value) => {
+  if (Array.isArray(value)) {
+    const values = value.filter((item) => typeof item === "string" && item.trim().length > 0);
+    return values.length === value.length ? values : null;
+  }
+  if (typeof value !== "string")
+    return null;
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+};
+var normalizeInputValue = (name, spec, value) => {
+  if (spec.type === "string")
+    return typeof value === "string" && value.length > 0 ? value : null;
+  if (spec.type === "string-list") {
+    const values = parseStringList(value);
+    return values && values.length > 0 ? values : null;
+  }
+  if (typeof value === "string" && surfaceModes.has(value))
+    return value;
+  throw new Error(`Unsupported workflow input value for ${name}`);
+};
+var listWorkflowSpecs = (specs) => [...specs].sort((a, b) => a.name.localeCompare(b.name));
+var getWorkflowSpec = (specs, name) => specs.find((spec) => spec.name === name) ?? null;
+var compactWorkflowInputs = (inputs) => Object.fromEntries(Object.entries(inputs).filter(([, value]) => value !== null && value !== ""));
+var createWorkflowPlan = (spec, rawInputs) => {
+  const inputs = {};
+  const diagnostics = [];
+  for (const [name, inputSpec] of Object.entries(spec.inputs)) {
+    const rawValue = rawInputs[name];
+    if (rawValue === undefined || rawValue === null || rawValue === "") {
+      if (inputSpec.required) {
+        diagnostics.push({
+          severity: "error",
+          code: "workflow-input-missing",
+          input: name,
+          message: `Workflow ${spec.name} requires input "${name}".`
+        });
+      }
+      continue;
+    }
+    const value = normalizeInputValue(name, inputSpec, rawValue);
+    if (value === null) {
+      diagnostics.push({
+        severity: "error",
+        code: "workflow-input-invalid",
+        input: name,
+        message: `Workflow ${spec.name} input "${name}" must be ${inputSpec.type}.`
+      });
+      continue;
+    }
+    if (inputSpec.allowedValues && typeof value === "string" && !inputSpec.allowedValues.includes(value)) {
+      diagnostics.push({
+        severity: "error",
+        code: "workflow-input-not-allowed",
+        input: name,
+        message: `Workflow ${spec.name} input "${name}" must be one of: ${inputSpec.allowedValues.join(", ")}.`
+      });
+      continue;
+    }
+    inputs[name] = value;
+  }
+  const fieldType = inputs.type;
+  if (spec.name === "add-field" && typeof fieldType === "string" && (fieldType.toLowerCase() === "number" || fieldType.toLowerCase() === "numeric")) {
+    diagnostics.push({
+      severity: "error",
+      code: "primitive-field-type-unsupported",
+      input: "type",
+      message: `Field type "${fieldType}" is ambiguous in Akan. Use Int for integer fields or Float for decimal fields.`
+    });
+  }
+  return {
+    schemaVersion: 1,
+    workflow: spec.name,
+    mode: "plan",
+    inputs,
+    optionalSurfaces: spec.optionalSurfaces ?? {},
+    steps: spec.steps,
+    predictedChanges: spec.predictedChanges,
+    validation: spec.validation,
+    diagnostics,
+    requiresApproval: true
+  };
+};
+var renderWorkflowList = (specs) => [
+  "# Akan Workflows",
+  "",
+  ...specs.flatMap((spec) => [`- \`${spec.name}\`: ${spec.description}`, `  - When: ${spec.whenToUse}`]),
+  ""
+].join(`
+`);
+var renderWorkflowExplain = (spec) => [
+  `# Workflow: ${spec.name}`,
+  "",
+  spec.description,
+  "",
+  "## When To Use",
+  spec.whenToUse,
+  "",
+  "## Inputs",
+  ...Object.entries(spec.inputs).map(([name, input4]) => `- \`${name}\`${input4.required ? " (required)" : ""}: ${input4.description}${input4.allowedValues ? ` Allowed: ${input4.allowedValues.join(", ")}.` : ""}`),
+  "",
+  "## Optional Surfaces",
+  ...Object.entries(spec.optionalSurfaces ?? {}).map(([name, mode]) => `- \`${name}\`: ${mode}`),
+  "",
+  "## Steps",
+  ...spec.steps.map((step, index) => `${index + 1}. \`${step.id}\` (${step.tool}): ${step.description}`),
+  "",
+  "## Validation",
+  ...spec.validation.map((validation) => `- \`${validation.command}\`: ${validation.reason}`),
+  ""
+].join(`
+`);
+var renderWorkflowPlan = (plan) => [
+  `# Workflow Plan: ${plan.workflow}`,
+  "",
+  `- Mode: ${plan.mode}`,
+  `- Requires approval: ${plan.requiresApproval}`,
+  "",
+  "## Inputs",
+  ...Object.entries(plan.inputs).map(([name, value]) => `- \`${name}\`: ${Array.isArray(value) ? value.join(", ") : value}`),
+  "",
+  "## Optional Surfaces",
+  ...Object.entries(plan.optionalSurfaces).map(([name, mode]) => `- \`${name}\`: ${mode}`),
+  "",
+  "## Steps",
+  ...plan.steps.map((step, index) => `${index + 1}. \`${step.id}\` (${step.tool}): ${step.description}`),
+  "",
+  "## Predicted Changes",
+  ...plan.predictedChanges.map((change) => `- \`${change.action}\` ${change.target}: ${change.reason}`),
+  "",
+  "## Validation",
+  ...plan.validation.map((validation) => `- \`${validation.command}\`: ${validation.reason}`),
+  "",
+  "## Diagnostics",
+  ...plan.diagnostics.length ? plan.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+  ""
+].join(`
+`);
+var workflowStatus = (diagnostics) => diagnostics.some((diagnostic) => diagnostic.severity === "error") ? "failed" : "passed";
+var commandStatus = (commands) => commands.some((command3) => command3.status === "failed") ? "failed" : "passed";
+var uniqueBy = (values, key) => {
+  const seen = new Set;
+  return values.filter((value) => {
+    const itemKey = key(value);
+    if (seen.has(itemKey))
+      return false;
+    seen.add(itemKey);
+    return true;
+  });
+};
+var createWorkflowApplyReport = ({
+  workflow,
+  mode,
+  changedFiles = [],
+  generatedFiles: generatedFiles2 = [],
+  appliedCommands = [],
+  recommendedValidationCommands,
+  commands = [],
+  diagnostics = [],
+  nextActions = [],
+  plan
+}) => {
+  const validationCommands2 = recommendedValidationCommands ?? commands;
+  return {
+    schemaVersion: 1,
+    workflow,
+    mode,
+    status: workflowStatus(diagnostics),
+    changedFiles: uniqueBy(changedFiles, (file) => `${file.action}:${file.path}:${file.reason}`),
+    generatedFiles: uniqueBy(generatedFiles2, (file) => `${file.action}:${file.path}:${file.reason}`),
+    appliedCommands: uniqueBy(appliedCommands, (command3) => command3.command),
+    recommendedValidationCommands: uniqueBy(validationCommands2, (command3) => command3.command),
+    commands: uniqueBy(validationCommands2, (command3) => command3.command),
+    diagnostics,
+    nextActions: uniqueBy(nextActions, (action) => action.command),
+    plan
+  };
+};
+var resolveWorkflowCommand = (command3, plan) => {
+  const target = typeof plan.inputs.app === "string" ? plan.inputs.app : "<app-or-lib>";
+  return command3.replaceAll("<app-or-lib-or-pkg>", target).replaceAll("<app-or-lib>", target).replaceAll("<app-name>", target);
+};
+var workflowCommandsForPlan = (plan) => plan.validation.map((validation) => ({
+  command: resolveWorkflowCommand(validation.command, plan),
+  reason: validation.reason,
+  kind: validation.kind
+}));
+var workflowRunsDir = ".akan/workflows/runs";
+var createWorkflowRunId = (prefix = "run") => `${prefix}-${new Date().toISOString().replace(/[-:.TZ]/g, "").slice(0, 14)}-${Math.random().toString(36).slice(2, 8)}`;
+var getRunId = (artifact) => {
+  if ("runId" in artifact)
+    return artifact.runId;
+  return createWorkflowRunId("mode" in artifact ? artifact.mode : artifact.kind);
+};
+var workflowRunArtifactPath = (runId) => `${workflowRunsDir}/${runId}.json`;
+var writeWorkflowRunArtifact = async (workspace, artifact) => {
+  const runId = getRunId(artifact);
+  const artifactPath = workflowRunArtifactPath(runId);
+  await workspace.writeFile(artifactPath, jsonText(artifact), { silent: true });
+  return { runId, path: artifactPath };
+};
+var readWorkflowRunArtifact = async (workspace, runId) => {
+  const artifactPath = workflowRunArtifactPath(runId);
+  if (!await workspace.exists(artifactPath))
+    throw new Error(`Workflow run artifact does not exist: ${artifactPath}`);
+  return await workspace.readJson(artifactPath);
+};
+var createWorkflowValidationRunReport = async ({
+  runId = createWorkflowRunId("validation"),
+  workflow,
+  source,
+  plan,
+  commands,
+  execute,
+  diagnostics = [],
+  repairActions = []
+}) => {
+  const results = [];
+  for (const command3 of commands) {
+    results.push(await execute(command3));
+  }
+  const commandDiagnostics = results.flatMap((result) => result.status === "failed" ? [
+    {
+      severity: "error",
+      code: "workflow-validation-command-failed",
+      message: `Validation command failed: ${result.command}`,
+      command: result.command,
+      kind: result.kind,
+      failureScope: result.failureScope
+    }
+  ] : []);
+  return {
+    schemaVersion: 1,
+    runId,
+    workflow,
+    mode: "validate",
+    source,
+    status: workflowStatus([...diagnostics, ...commandDiagnostics]) === "failed" ? "failed" : commandStatus(results),
+    commands: results,
+    diagnostics: [...diagnostics, ...commandDiagnostics],
+    repairActions: uniqueBy(repairActions, (action) => action.command),
+    nextActions: results.filter((result) => result.status === "failed").map((result) => ({ command: result.command, reason: "Re-run this validation command after repair." })),
+    plan
+  };
+};
+var createDryRunWorkflowApplyReport = (plan) => {
+  const changedFiles = plan.predictedChanges.flatMap((change) => {
+    if (change.action !== "create" && change.action !== "modify")
+      return [];
+    return [
+      {
+        path: change.target,
+        action: change.action,
+        reason: change.reason
+      }
+    ];
+  });
+  const generatedFiles2 = plan.predictedChanges.flatMap((change) => {
+    if (change.action !== "sync")
+      return [];
+    return [
+      {
+        path: change.target,
+        action: "sync",
+        reason: change.reason
+      }
+    ];
+  });
+  const diagnostics = [...plan.diagnostics];
+  return createWorkflowApplyReport({
+    workflow: plan.workflow,
+    mode: "dry-run",
+    changedFiles,
+    generatedFiles: generatedFiles2,
+    commands: workflowCommandsForPlan(plan),
+    diagnostics,
+    nextActions: workflowCommandsForPlan(plan),
+    plan
+  });
+};
+var workflowStepKey = (workflow, stepId) => `${workflow}:${stepId}`;
+var primitiveReportToWorkflowStepResult = (report) => ({
+  changedFiles: report.changedFiles,
+  generatedFiles: report.generatedFiles,
+  commands: report.validationCommands,
+  diagnostics: report.diagnostics,
+  nextActions: report.nextActions
+});
+var workflowStringInput = (value) => typeof value === "string" ? value : null;
+var workflowStringListInput = (value) => Array.isArray(value) ? value.join(",") : null;
+var resolveWorkflowSys = async (workspace, target) => {
+  if (!target)
+    return null;
+  const [apps, libs] = await workspace.getSyss();
+  if (apps.includes(target))
+    return AppExecutor.from(workspace, target);
+  if (libs.includes(target))
+    return LibExecutor.from(workspace, target);
+  return null;
+};
+var targetMissing = (input4 = "app") => ({
+  severity: "error",
+  code: "workflow-target-missing",
+  input: input4,
+  message: "Workflow target app or library was not found."
+});
+var inputMissing = (input4) => ({
+  severity: "error",
+  code: "workflow-input-missing",
+  input: input4,
+  message: `Workflow input "${input4}" is required for apply.`
+});
+var unsupportedInput = (input4, message) => ({
+  severity: "error",
+  code: "workflow-input-unsupported",
+  input: input4,
+  message
+});
+var createWorkflowStepRegistry = ({
+  workspace,
+  createModule,
+  createScalar,
+  createUi,
+  addField,
+  addEnumField
+}) => {
+  const inspect = async () => {
+    return;
+  };
+  const commandOnly = async () => {
+    return;
+  };
+  return {
+    inspectSystem: inspect,
+    inspectModule: inspect,
+    syncTarget: commandOnly,
+    lintTarget: commandOnly,
+    [workflowStepKey("create-module", "create-module")]: async (_step, plan) => {
+      const app = workflowStringInput(plan.inputs.app);
+      const module = workflowStringInput(plan.inputs.module);
+      const sys3 = await resolveWorkflowSys(workspace, app);
+      if (!sys3 || !module)
+        return { diagnostics: [!sys3 ? targetMissing() : inputMissing("module")] };
+      return primitiveReportToWorkflowStepResult(await createModule(sys3, module));
+    },
+    [workflowStepKey("create-scalar", "create-scalar")]: async (_step, plan) => {
+      const app = workflowStringInput(plan.inputs.app);
+      const scalar = workflowStringInput(plan.inputs.scalar);
+      const sys3 = await resolveWorkflowSys(workspace, app);
+      if (!sys3 || !scalar)
+        return { diagnostics: [!sys3 ? targetMissing() : inputMissing("scalar")] };
+      return primitiveReportToWorkflowStepResult(await createScalar(sys3, scalar));
+    },
+    [workflowStepKey("create-ui", "create-ui")]: async (_step, plan) => {
+      const surface = workflowStringInput(plan.inputs.surface);
+      if (surface !== "view" && surface !== "unit" && surface !== "template") {
+        return {
+          diagnostics: [
+            unsupportedInput("surface", "Workflow apply currently supports create-ui surfaces: view, unit, template.")
+          ]
+        };
+      }
+      return primitiveReportToWorkflowStepResult(await createUi({
+        app: workflowStringInput(plan.inputs.app),
+        module: workflowStringInput(plan.inputs.module),
+        surface
+      }));
+    },
+    [workflowStepKey("add-field", "update-constant")]: async (_step, plan) => {
+      if (workflowStringInput(plan.inputs.type)?.toLowerCase() === "enum") {
+        return primitiveReportToWorkflowStepResult(await addEnumField({
+          app: workflowStringInput(plan.inputs.app),
+          module: workflowStringInput(plan.inputs.module),
+          field: workflowStringInput(plan.inputs.field),
+          values: workflowStringListInput(plan.inputs.values),
+          defaultValue: workflowStringInput(plan.inputs.default)
+        }));
+      }
+      return primitiveReportToWorkflowStepResult(await addField({
+        app: workflowStringInput(plan.inputs.app),
+        module: workflowStringInput(plan.inputs.module),
+        field: workflowStringInput(plan.inputs.field),
+        type: workflowStringInput(plan.inputs.type),
+        defaultValue: workflowStringInput(plan.inputs.default)
+      }));
+    },
+    [workflowStepKey("add-field", "update-dictionary")]: inspect,
+    [workflowStepKey("add-field", "update-ui-surfaces")]: inspect,
+    [workflowStepKey("add-enum-field", "update-constant")]: async (_step, plan) => primitiveReportToWorkflowStepResult(await addEnumField({
+      app: workflowStringInput(plan.inputs.app),
+      module: workflowStringInput(plan.inputs.module),
+      field: workflowStringInput(plan.inputs.field),
+      values: workflowStringListInput(plan.inputs.values),
+      defaultValue: workflowStringInput(plan.inputs.default)
+    })),
+    [workflowStepKey("add-enum-field", "update-dictionary")]: inspect,
+    [workflowStepKey("add-enum-field", "update-option")]: inspect
+  };
+};
+var renderWorkflowApplyReport = (report) => [
+  `# Workflow Apply: ${report.workflow}`,
+  "",
+  `- Mode: ${report.mode}`,
+  `- Status: ${report.status}`,
+  "",
+  "## Changed Files",
+  ...report.changedFiles.length ? report.changedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
+  "",
+  "## Generated Files",
+  ...report.generatedFiles.length ? report.generatedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
+  "",
+  "## Applied Commands",
+  ...report.appliedCommands.length ? report.appliedCommands.map((command3) => `- \`${command3.command}\`: ${command3.reason}`) : ["- none"],
+  "",
+  "## Recommended Validation Commands",
+  ...report.recommendedValidationCommands.length ? report.recommendedValidationCommands.map((command3) => `- \`${command3.command}\`: ${command3.reason}`) : ["- none"],
+  "",
+  "## Diagnostics",
+  ...report.diagnostics.length ? report.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+  "",
+  "## Next Actions",
+  ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+  ""
+].join(`
+`);
+var renderWorkflowApply = (report, format = "markdown") => format === "json" ? jsonText(report) : renderWorkflowApplyReport(report);
+var renderWorkflowValidationRunReport = (report) => [
+  `# Workflow Validation: ${report.workflow}`,
+  "",
+  `- Run: ${report.runId}`,
+  `- Status: ${report.status}`,
+  "",
+  "## Commands",
+  ...report.commands.length ? report.commands.map((command3) => {
+    const scope = command3.failureScope ? ` (${command3.failureScope})` : "";
+    return `- [${command3.status}] \`${command3.command}\`${scope}: ${command3.reason}`;
+  }) : ["- none"],
+  "",
+  "## Diagnostics",
+  ...report.diagnostics.length ? report.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+  "",
+  "## Repair Actions",
+  ...report.repairActions.length ? report.repairActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+  "",
+  "## Next Actions",
+  ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+  ""
+].join(`
+`);
+var renderWorkflowValidation = (report, format = "markdown") => format === "json" ? jsonText(report) : renderWorkflowValidationRunReport(report);
+var renderWorkflowRunArtifact = (artifact, format = "markdown") => {
+  if ("kind" in artifact)
+    return renderRepairReport(artifact, format);
+  if ("mode" in artifact && artifact.mode === "validate")
+    return renderWorkflowValidation(artifact, format);
+  if ("mode" in artifact && (artifact.mode === "apply" || artifact.mode === "dry-run")) {
+    return renderWorkflowApply(artifact, format);
+  }
+  return jsonText(artifact);
+};
+var createRepairReport = ({
+  command: command3,
+  kind,
+  target = null,
+  diagnostics = [],
+  repairActions = [],
+  nextActions = [],
+  commands = []
+}) => ({
+  schemaVersion: 1,
+  command: command3,
+  kind,
+  target,
+  status: workflowStatus(diagnostics) === "failed" || commandStatus(commands) === "failed" ? "failed" : "passed",
+  diagnostics,
+  repairActions: uniqueBy(repairActions, (action) => action.command),
+  nextActions: uniqueBy(nextActions, (action) => action.command),
+  commands
+});
+var renderRepairReportMarkdown = (report) => [
+  `# Akan Repair: ${report.kind}`,
+  "",
+  `- Status: ${report.status}`,
+  `- Target: ${report.target ?? "none"}`,
+  "",
+  "## Commands",
+  ...report.commands.length ? report.commands.map((command3) => `- [${command3.status}] \`${command3.command}\`: ${command3.reason}`) : ["- none"],
+  "",
+  "## Diagnostics",
+  ...report.diagnostics.length ? report.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+  "",
+  "## Next Actions",
+  ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+  ""
+].join(`
+`);
+var renderRepairReport = (report, format = "markdown") => format === "json" ? jsonText(report) : renderRepairReportMarkdown(report);
+
+class WorkflowExecutor {
+  registry;
+  constructor(registry) {
+    this.registry = registry;
+  }
+  async apply(plan) {
+    const changedFiles = [];
+    const generatedFiles2 = [];
+    const recommendedValidationCommands = [];
+    const diagnostics = [...plan.diagnostics];
+    const nextActions = [];
+    if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+      return createWorkflowApplyReport({
+        workflow: plan.workflow,
+        mode: "apply",
+        changedFiles,
+        generatedFiles: generatedFiles2,
+        recommendedValidationCommands,
+        diagnostics,
+        nextActions,
+        plan
+      });
+    }
+    recommendedValidationCommands.push(...workflowCommandsForPlan(plan));
+    nextActions.push(...workflowCommandsForPlan(plan));
+    for (const step of plan.steps) {
+      const runner2 = this.registry[workflowStepKey(plan.workflow, step.id)] ?? this.registry[step.tool] ?? this.registry[step.id];
+      if (!runner2) {
+        diagnostics.push({
+          severity: "error",
+          code: "workflow-step-unsupported",
+          message: `Workflow ${plan.workflow} step "${step.id}" is not supported by workflow apply yet.`
+        });
+        nextActions.push({
+          command: `akan workflow explain ${plan.workflow}`,
+          reason: "Review the unsupported workflow step before retrying apply."
+        });
+        break;
+      }
+      const result = await runner2(step, plan);
+      if (!result)
+        continue;
+      changedFiles.push(...result.changedFiles ?? []);
+      generatedFiles2.push(...result.generatedFiles ?? []);
+      recommendedValidationCommands.push(...result.commands ?? []);
+      diagnostics.push(...result.diagnostics ?? []);
+      nextActions.push(...result.nextActions ?? []);
+      if (diagnostics.some((diagnostic) => diagnostic.severity === "error"))
+        break;
+    }
+    return createWorkflowApplyReport({
+      workflow: plan.workflow,
+      mode: "apply",
+      changedFiles,
+      generatedFiles: generatedFiles2,
+      recommendedValidationCommands,
+      diagnostics,
+      nextActions,
+      plan
+    });
+  }
+}
+var createPrimitiveWriteReport = ({
+  command: command3,
+  status,
+  changedFiles = [],
+  generatedFiles: generatedFiles2 = [],
+  validationCommands: validationCommands2 = [],
+  diagnostics = [],
+  nextActions = []
+}) => ({
+  schemaVersion: 1,
+  command: command3,
+  status: status ?? (diagnostics.some((diagnostic) => diagnostic.severity === "error") ? "failed" : "passed"),
+  changedFiles,
+  generatedFiles: generatedFiles2,
+  validationCommands: validationCommands2,
+  diagnostics,
+  nextActions
+});
+var renderPrimitiveWriteReport = (report) => [
+  `# Primitive Write: ${report.command}`,
+  "",
+  `- Status: ${report.status}`,
+  "",
+  "## Changed Files",
+  ...report.changedFiles.length ? report.changedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
+  "",
+  "## Generated Files",
+  ...report.generatedFiles.length ? report.generatedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`) : ["- none"],
+  "",
+  "## Validation Commands",
+  ...report.validationCommands.length ? report.validationCommands.map((validation) => `- \`${validation.command}\`: ${validation.reason}`) : ["- none"],
+  "",
+  "## Diagnostics",
+  ...report.diagnostics.length ? report.diagnostics.map((diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`) : ["- none"],
+  "",
+  "## Next Actions",
+  ...report.nextActions.length ? report.nextActions.map((action) => `- \`${action.command}\`: ${action.reason}`) : ["- none"],
+  ""
+].join(`
+`);
+var renderPrimitiveReport = (report, format = "markdown") => format === "json" ? jsonText(report) : renderPrimitiveWriteReport(report);
+var getSysRoot = (sys3) => `${sys3.type}s/${sys3.name}`;
+var sourceFile = (sys3, path40, action, reason) => ({
+  path: `${getSysRoot(sys3)}/${path40}`,
+  action,
+  reason
+});
+var generatedFilesForSync = (sys3, reason = "Generated files may change after sync.") => [
+  { path: `${getSysRoot(sys3)}/lib/cnst.ts`, action: "sync", reason },
+  { path: `${getSysRoot(sys3)}/lib/dict.ts`, action: "sync", reason },
+  { path: `${getSysRoot(sys3)}/lib/option.ts`, action: "sync", reason },
+  { path: `${getSysRoot(sys3)}/lib/index.ts`, action: "sync", reason }
+];
+var validationCommandsForTarget = (target) => [
+  { command: `akan sync ${target}`, reason: "Refresh generated Akan files from source conventions." },
+  { command: `akan lint ${target}`, reason: "Validate formatting, imports, and static lint rules." }
+];
+var nextActionsForTarget = (target) => [
+  { command: `akan sync ${target}`, reason: "Refresh generated Akan files after source changes." },
+  { command: `akan lint ${target}`, reason: "Validate the target after generated files are refreshed." }
+];
+var createPassedPrimitiveReport = ({
+  command: command3,
+  changedFiles,
+  generatedFiles: generatedFiles2,
+  target,
+  nextActions
+}) => createPrimitiveWriteReport({
+  command: command3,
+  changedFiles,
+  generatedFiles: generatedFiles2 ?? [],
+  validationCommands: validationCommandsForTarget(target),
+  diagnostics: [],
+  nextActions: nextActions ?? nextActionsForTarget(target)
+});
+var scalarChangedFiles = (sys3, scalarName, files) => Object.values(files).map((file) => sourceFile(sys3, `lib/__scalar/${scalarName}/${file.filename}`, "create", "Scalar source file was created."));
+var titleize = (value) => value.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[-_]+/g, " ").replace(/\b\w/g, (char) => char.toUpperCase());
+var lowerlize = (value) => `${value.slice(0, 1).toLowerCase()}${value.slice(1)}`;
+var compactDiagnostics = (diagnostics) => diagnostics.filter((diagnostic) => !!diagnostic);
+var normalizeFieldType = (typeName) => {
+  const normalizedTypes = {
+    string: "String",
+    boolean: "Boolean",
+    date: "Date",
+    int: "Int",
+    integer: "Int",
+    float: "Float",
+    double: "Float",
+    decimal: "Float"
+  };
+  return normalizedTypes[typeName.toLowerCase()] ?? typeName;
+};
+var ensureBaseTypeImport = (content, typeName) => {
+  if (typeName !== "Int" && typeName !== "Float")
+    return content;
+  if (new RegExp(`import \\{[^}]*\\b${typeName}\\b[^}]*\\} from "akanjs/base";`).test(content))
+    return content;
+  const baseImport = /import \{ ([^}]+) \} from "akanjs\/base";/.exec(content);
+  if (baseImport) {
+    const names = baseImport[1].split(",").map((name) => name.trim()).filter(Boolean);
+    return content.replace(baseImport[0], `import { ${[...names, typeName].sort().join(", ")} } from "akanjs/base";`);
+  }
+  return `import { ${typeName} } from "akanjs/base";
+${content}`;
+};
+var fieldExpression = (typeName, defaultValue) => {
+  const typeExpression = normalizeFieldType(typeName);
+  const defaultOption = defaultValue ? `, { default: ${JSON.stringify(defaultValue)} }` : "";
+  return `field(${typeExpression}${defaultOption})`;
+};
+var insertIntoObject = (content, className, line) => {
+  const classIndex = content.indexOf(`export class ${className} extends via`);
+  if (classIndex < 0)
+    return null;
+  const objectEndIndex = content.indexOf("}))", classIndex);
+  if (objectEndIndex < 0)
+    return null;
+  const prefix = content.slice(0, objectEndIndex);
+  const suffix = content.slice(objectEndIndex);
+  const insertion = prefix.endsWith(`
+`) ? `  ${line}
+` : `
+  ${line}
+`;
+  return `${prefix}${insertion}${suffix}`;
+};
+var ensureEnumImport = (content) => {
+  if (content.includes("enumOf"))
+    return content;
+  const baseImport = /import \{ ([^}]+) \} from "akanjs\/base";/.exec(content);
+  if (baseImport) {
+    const names = baseImport[1]?.split(",").map((name) => name.trim()) ?? [];
+    return content.replace(baseImport[0], `import { ${[...names, "enumOf"].sort().join(", ")} } from "akanjs/base";`);
+  }
+  return `import { enumOf } from "akanjs/base";
+${content}`;
+};
+var insertEnumClass = (content, enumClassName, enumName, values) => {
+  if (content.includes(`export class ${enumClassName} extends enumOf`))
+    return content;
+  const enumClass = `export class ${enumClassName} extends enumOf("${enumName}", [
+${values.map((value) => `  ${JSON.stringify(value)},`).join(`
+`)}
+] as const) {}
+
+`;
+  const firstClassIndex = content.indexOf("export class ");
+  if (firstClassIndex < 0)
+    return `${content}
+${enumClass}`;
+  return `${content.slice(0, firstClassIndex)}${enumClass}${content.slice(firstClassIndex)}`;
+};
+var insertDictionaryModelField = (content, moduleClassName, fieldName) => {
+  if (new RegExp(`\\b${fieldName}\\s*:`).test(content))
+    return content;
+  const label = titleize(fieldName);
+  const modelIndex = content.indexOf(`.model<${moduleClassName}>((t) => ({`);
+  if (modelIndex < 0)
+    return null;
+  const objectEndIndex = content.indexOf("  }))", modelIndex);
+  if (objectEndIndex < 0)
+    return null;
+  return `${content.slice(0, objectEndIndex)}    ${fieldName}: t([${JSON.stringify(label)}, ${JSON.stringify(label)}]).desc([${JSON.stringify(label)}, ${JSON.stringify(label)}]),
+${content.slice(objectEndIndex)}`;
+};
+var ensureConstantTypeImport = (content, constantPath, typeName) => {
+  if (new RegExp(`import type \\{[^}]*\\b${typeName}\\b[^}]*\\} from "${constantPath}";`).test(content))
+    return content;
+  const importPattern = new RegExp(`import type \\{ ([^}]+) \\} from "${constantPath}";`);
+  const existingImport = content.match(importPattern);
+  if (existingImport !== null) {
+    const names = existingImport[1]?.split(",").map((name) => name.trim()) ?? [];
+    return content.replace(existingImport[0], `import type { ${[...names, typeName].sort().join(", ")} } from "${constantPath}";`);
+  }
+  return `import type { ${typeName} } from "${constantPath}";
+${content}`;
+};
+var insertDictionaryEnum = (content, enumClassName, enumName, values) => {
+  if (content.includes(`.enum<${enumClassName}>("${enumName}"`))
+    return content;
+  const enumBlock = `  .enum<${enumClassName}>("${enumName}", (t) => ({
+${values.map((value) => `    ${value}: t([${JSON.stringify(titleize(value))}, ${JSON.stringify(titleize(value))}]),`).join(`
+`)}
+  }))
+`;
+  const chainEndIndex = content.lastIndexOf(";");
+  const insertBeforeIndex = [content.indexOf(".error("), content.indexOf(".translate("), chainEndIndex].filter((index) => index >= 0).sort((a, b) => a - b)[0];
+  if (insertBeforeIndex === undefined)
+    return null;
+  return `${content.slice(0, insertBeforeIndex)}${enumBlock}${content.slice(insertBeforeIndex)}`;
+};
+var parseValues = (value) => value?.split(",").map((item) => item.trim()).filter(Boolean) ?? [];
 // pkgs/@akanjs/devkit/incrementalBuilder/incrementalBuilder.proc.ts
 import { Logger as Logger11 } from "akanjs/common";
 class IncrementalBuilder {