@akanjs/devkit 2.3.9-rc.5 → 2.3.9-rc.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "2.3.9-rc.5",
+  "version": "2.3.9-rc.6",
   "sourceType": "module",
   "type": "module",
   "publishConfig": {
@@ -32,7 +32,7 @@
     "@langchain/openai": "^1.4.6",
     "@tailwindcss/node": "^4.3.0",
     "@trapezedev/project": "^7.1.4",
-    "akanjs": "2.3.9-rc.5",
+    "akanjs": "2.3.9-rc.6",
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "daisyui": "5.5.23",

package/workflow/artifacts.ts

@@ -28,6 +28,7 @@ export const createWorkflowApplyReport = ({
   recommendedValidationCommands,
   commands = [],
   diagnostics = [],
+  postApplyChecks = [],
   recommendations = [],
   nextActions = [],
   plan,
@@ -41,14 +42,21 @@ export const createWorkflowApplyReport = ({
   | "appliedCommands"
   | "recommendedValidationCommands"
   | "commands"
+  | "postApplyChecks"
   | "recommendations"
 > & {
   appliedCommands?: WorkflowApplyCommand[];
   recommendedValidationCommands?: WorkflowApplyCommand[];
   commands?: WorkflowApplyCommand[];
+  postApplyChecks?: WorkflowApplyReport["postApplyChecks"];
   recommendations?: WorkflowApplyReport["recommendations"];
 }): WorkflowApplyReport => {
   const validationCommands = recommendedValidationCommands ?? commands;
+  const orderedNextActions = uniqueBy(nextActions, (action) => action.command).sort((left, right) => {
+    const leftRepair = left.command.startsWith("akan workflow explain") ? 0 : 1;
+    const rightRepair = right.command.startsWith("akan workflow explain") ? 0 : 1;
+    return leftRepair - rightRepair;
+  });
   return {
     schemaVersion: 1,
     workflow,
@@ -60,8 +68,9 @@ export const createWorkflowApplyReport = ({
     recommendedValidationCommands: uniqueBy(validationCommands, (command) => command.command),
     commands: uniqueBy(validationCommands, (command) => command.command),
     diagnostics,
+    postApplyChecks,
     recommendations: uniqueBy(recommendations, (recommendation) => `${recommendation.kind}:${recommendation.code}`),
-    nextActions: uniqueBy(nextActions, (action) => action.command),
+    nextActions: orderedNextActions.slice(0, 3),
     plan,
   };
 };

package/workflow/executor.ts

@@ -1,4 +1,5 @@
 import { capitalize } from "akanjs/common";
+import ts from "typescript";
 import type { Sys, Workspace } from "../commandDecorators";
 import { AppExecutor, LibExecutor } from "../executors";
 import { createWorkflowApplyReport, workflowCommandsForPlan } from "./artifacts";
@@ -12,7 +13,9 @@ import type {
   WorkflowDiagnostic,
   WorkflowInputValue,
   WorkflowPlan,
+  WorkflowPostApplyCheck,
   WorkflowPrimitiveOperations,
+  WorkflowRecommendation,
   WorkflowStep,
   WorkflowStepRegistry,
   WorkflowStepResult,
@@ -36,6 +39,103 @@ const workflowStringListInput = (value: WorkflowInputValue | undefined) =>
 const workflowStringArrayInput = (value: WorkflowInputValue | undefined) => (Array.isArray(value) ? value : null);
 const workflowBooleanInput = (value: WorkflowInputValue | undefined) => (typeof value === "boolean" ? value : null);
 
+const postApplyDiagnostic = (code: string, message: string, target: string): WorkflowDiagnostic => ({
+  severity: "error",
+  code,
+  message,
+  failureScope: "source-change",
+  context: { target },
+});
+
+const sourceKindForPath = (filePath: string) => {
+  if (filePath.endsWith(".tsx")) return ts.ScriptKind.TSX;
+  if (filePath.endsWith(".ts")) return ts.ScriptKind.TS;
+  return null;
+};
+
+const checkPathCasing = async (workspace: Workspace, filePath: string) => {
+  const segments = filePath.split("/").filter(Boolean);
+  let current = ".";
+  for (const segment of segments) {
+    const entries = await workspace.readdir(current);
+    if (entries.includes(segment)) {
+      current = current === "." ? segment : `${current}/${segment}`;
+      continue;
+    }
+    const caseInsensitiveMatch = entries.find((entry) => entry.toLowerCase() === segment.toLowerCase());
+    return caseInsensitiveMatch
+      ? {
+          code: "workflow-path-casing-mismatch",
+          message: `Reported path segment "${segment}" does not match actual casing "${caseInsensitiveMatch}" in ${filePath}.`,
+        }
+      : {
+          code: "workflow-path-missing",
+          message: `Reported path does not exist: ${filePath}.`,
+        };
+  }
+  return null;
+};
+
+const checkTypeScriptSyntax = async (workspace: Workspace, filePath: string) => {
+  const scriptKind = sourceKindForPath(filePath);
+  if (!scriptKind) return null;
+  const content = await workspace.readFile(filePath);
+  const source = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true, scriptKind);
+  const diagnostic = source.parseDiagnostics[0];
+  if (!diagnostic) return null;
+  const position = diagnostic.file?.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
+  const location = position ? `:${position.line + 1}:${position.character + 1}` : "";
+  return {
+    code: "workflow-post-apply-syntax-error",
+    message: `Generated source has a TypeScript syntax error at ${filePath}${location}: ${ts.flattenDiagnosticMessageText(
+      diagnostic.messageText,
+      " ",
+    )}`,
+  };
+};
+
+const checkChangedFile = async (workspace: Workspace, file: PrimitiveChangedFile): Promise<WorkflowStepResult> => {
+  if (file.action === "remove") return { postApplyChecks: [] };
+  const diagnostics: WorkflowDiagnostic[] = [];
+  const checks: WorkflowPostApplyCheck[] = [];
+  const pathIssue = await checkPathCasing(workspace, file.path);
+  if (pathIssue) {
+    diagnostics.push(postApplyDiagnostic(pathIssue.code, pathIssue.message, file.path));
+    checks.push({ ...pathIssue, target: file.path, status: "failed" });
+    return { diagnostics, postApplyChecks: checks };
+  }
+  const syntaxIssue = await checkTypeScriptSyntax(workspace, file.path);
+  if (syntaxIssue) {
+    diagnostics.push(postApplyDiagnostic(syntaxIssue.code, syntaxIssue.message, file.path));
+    checks.push({ ...syntaxIssue, target: file.path, status: "failed" });
+    return { diagnostics, postApplyChecks: checks };
+  }
+  checks.push({
+    code: "workflow-post-apply-file-valid",
+    target: file.path,
+    status: "passed",
+    message: "Changed file exists with exact casing and parses as source when applicable.",
+  });
+  return { postApplyChecks: checks };
+};
+
+const checkRecommendationPath = async (
+  workspace: Workspace,
+  recommendation: WorkflowRecommendation,
+): Promise<WorkflowDiagnostic | null> => {
+  if (!recommendation.target || recommendation.target.includes("*") || recommendation.target.startsWith("<"))
+    return null;
+  const pathIssue = await checkPathCasing(workspace, recommendation.target);
+  if (!pathIssue) return null;
+  return {
+    severity: "warning",
+    code: "workflow-recommendation-path-unverified",
+    message: `${pathIssue.message} Recommendation "${recommendation.code}" should not be treated as an exact file target until the path is corrected.`,
+    failureScope: "source-change",
+    context: { target: recommendation.target },
+  };
+};
+
 const resolveWorkflowSys = async (workspace: Workspace, target: string | null): Promise<Sys | null> => {
   if (!target) return null;
   const [apps, libs] = await workspace.getSyss();
@@ -197,13 +297,17 @@ export const createWorkflowStepCommandResult = (
 });
 
 export class WorkflowExecutor {
-  constructor(private readonly registry: WorkflowStepRegistry) {}
+  constructor(
+    private readonly registry: WorkflowStepRegistry,
+    private readonly workspace?: Workspace,
+  ) {}
 
   async apply(plan: WorkflowPlan) {
     const changedFiles: PrimitiveChangedFile[] = [];
     const generatedFiles: PrimitiveGeneratedFile[] = [];
     const recommendedValidationCommands: WorkflowApplyCommand[] = [];
     const diagnostics: WorkflowDiagnostic[] = [...plan.diagnostics];
+    const postApplyChecks: WorkflowPostApplyCheck[] = [];
     const recommendations = [...plan.recommendations];
     const nextActions: PrimitiveNextAction[] = [];
 
@@ -215,6 +319,7 @@ export class WorkflowExecutor {
         generatedFiles,
         recommendedValidationCommands,
         diagnostics,
+        postApplyChecks,
         recommendations,
         nextActions,
         plan,
@@ -251,6 +356,20 @@ export class WorkflowExecutor {
       if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) break;
     }
 
+    if (this.workspace && !diagnostics.some((diagnostic) => diagnostic.severity === "error")) {
+      for (const file of changedFiles) {
+        const result = await checkChangedFile(this.workspace, file);
+        postApplyChecks.push(...(result.postApplyChecks ?? []));
+        diagnostics.push(...(result.diagnostics ?? []));
+      }
+      const recommendationDiagnostics = await Promise.all(
+        recommendations.map((recommendation) => checkRecommendationPath(this.workspace as Workspace, recommendation)),
+      );
+      diagnostics.push(
+        ...recommendationDiagnostics.filter((diagnostic): diagnostic is WorkflowDiagnostic => !!diagnostic),
+      );
+    }
+
     return createWorkflowApplyReport({
       workflow: plan.workflow,
       mode: "apply",
@@ -258,6 +377,7 @@ export class WorkflowExecutor {
       generatedFiles,
       recommendedValidationCommands,
       diagnostics,
+      postApplyChecks,
       recommendations,
       nextActions,
       plan,

package/workflow/render.ts

@@ -93,6 +93,17 @@ const renderRecommendation = (recommendation: WorkflowApplyReport["recommendatio
 const renderDiagnostic = (diagnostic: WorkflowApplyReport["diagnostics"][number]) =>
   `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`;
 
+const applySourceStatus = (report: WorkflowApplyReport) =>
+  report.diagnostics.some(
+    (diagnostic) =>
+      diagnostic.severity === "error" &&
+      (diagnostic.failureScope === "source-change" ||
+        !diagnostic.failureScope ||
+        diagnostic.failureScope === "unknown"),
+  )
+    ? "failed"
+    : "passed";
+
 export const renderWorkflowApplyReport = (report: WorkflowApplyReport) => {
   const manualReviewItems = [
     ...report.diagnostics.filter((diagnostic) => diagnostic.severity === "warning").map(renderDiagnostic),
@@ -107,13 +118,32 @@ export const renderWorkflowApplyReport = (report: WorkflowApplyReport) => {
         (diagnostic.failureScope === "workspace-config" || diagnostic.failureScope === "environment"),
     )
     .map(renderDiagnostic);
+  const sourceBlockers = report.diagnostics
+    .filter(
+      (diagnostic) =>
+        diagnostic.severity === "error" &&
+        (diagnostic.failureScope === "source-change" ||
+          !diagnostic.failureScope ||
+          diagnostic.failureScope === "unknown"),
+    )
+    .map(renderDiagnostic);
   return [
     `# Workflow Apply: ${report.workflow}`,
     "",
     `- Mode: ${report.mode}`,
     `- Status: ${report.status}`,
+    `- Source-change status: ${applySourceStatus(report)}`,
+    `- Workspace status: ${validationBlockers.length ? "blocked" : "not blocked during apply"}`,
     ...(report.validationTarget ? [`- Validation target: ${report.validationTarget}`] : []),
     "",
+    "## Apply Checks",
+    ...(report.postApplyChecks?.length
+      ? report.postApplyChecks.map((check) => `- [${check.status}] ${check.code} ${check.target}: ${check.message}`)
+      : ["- not run"]),
+    "",
+    "## Source Change Blockers",
+    ...(sourceBlockers.length ? sourceBlockers : ["- none"]),
+    "",
     "## Automatically Modified",
     ...(report.changedFiles.length
       ? report.changedFiles.map((file) => `- \`${file.action}\` ${file.path}: ${file.reason}`)
@@ -148,7 +178,7 @@ export const renderWorkflowApplyReport = (report: WorkflowApplyReport) => {
     ...(report.diagnostics.length ? report.diagnostics.map(renderDiagnostic) : ["- none"]),
     "",
     "## Recommendations",
-    ...(report.recommendations.length ? report.recommendations.map(renderRecommendation) : ["- none"]),
+    ...(report.recommendations.length ? report.recommendations.slice(0, 3).map(renderRecommendation) : ["- none"]),
     "",
     "## Next Actions",
     ...(report.nextActions.length
@@ -172,10 +202,24 @@ export const renderWorkflowValidationRunReport = (report: WorkflowValidationRunR
     `- Overall status: ${report.overallStatus}`,
     "",
     "## Status Summary",
-    `- Required source-change validation: ${report.summary.sourceChange}`,
-    `- Generated sync validation: ${report.summary.generatedSync}`,
-    `- Workspace configuration validation: ${report.summary.workspaceConfig}`,
-    `- Environment validation: ${report.summary.environment}`,
+    `- Source-change: ${report.summary.sourceChange}`,
+    `- Generated sync: ${report.summary.generatedSync}`,
+    `- Workspace config: ${report.summary.workspaceConfig}`,
+    `- Environment: ${report.summary.environment}`,
+    "",
+    "## Source Change Diagnostics",
+    ...(report.workflowDiagnostics?.length
+      ? report.workflowDiagnostics.map(
+          (diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`,
+        )
+      : ["- none"]),
+    "",
+    "## Existing Workspace Blockers",
+    ...(report.baselineDiagnostics?.length
+      ? report.baselineDiagnostics.map(
+          (diagnostic) => `- [${diagnostic.severity}] ${diagnostic.code}: ${diagnostic.message}`,
+        )
+      : ["- none"]),
     "",
     "## Known Blockers",
     ...(report.knownBlockers.length

package/workflow/source.ts

@@ -290,7 +290,7 @@ export const coerceFieldDefault = (
 export const fieldExpression = (
   typeName: string,
   defaultValue?: FieldDefaultValue,
-  options: { enumValues?: readonly string[] | null } = {},
+  options: { enumValues?: readonly string[] | null; builderName?: string } = {},
 ) => {
   const typeExpression = normalizeFieldType(typeName);
   const defaultExpression = coerceFieldDefault(
@@ -299,7 +299,14 @@ export const fieldExpression = (
     options,
   ).expression;
   const defaultOption = defaultExpression ? `, { default: ${defaultExpression} }` : "";
-  return `field(${typeExpression}${defaultOption})`;
+  return `${options.builderName ?? "field"}(${typeExpression}${defaultOption})`;
+};
+
+export const viaBuilderParameterName = (content: string, className: string) => {
+  const classIndex = content.indexOf(`export class ${className} extends via`);
+  if (classIndex < 0) return null;
+  const signature = content.slice(classIndex, content.indexOf("=>", classIndex));
+  return /via\(\(\s*([A-Za-z_$][\w$]*)\s*\)/.exec(signature)?.[1] ?? null;
 };
 
 export const insertIntoObject = (content: string, className: string, line: string) => {
@@ -379,17 +386,60 @@ export const insertEnumClass = (content: string, enumClassName: string, enumName
   return `${content.slice(0, firstClassIndex)}${enumClass}${content.slice(firstClassIndex)}`;
 };
 
-export const insertDictionaryModelField = (content: string, moduleClassName: string, fieldName: string) => {
-  if (new RegExp(`\\b${fieldName}\\s*:`).test(content)) return content;
+const findMatchingBrace = (content: string, openIndex: number) => {
+  let depth = 0;
+  let quote: '"' | "'" | "`" | null = null;
+  let escaped = false;
+  for (let index = openIndex; index < content.length; index++) {
+    const char = content[index];
+    if (quote) {
+      if (escaped) {
+        escaped = false;
+        continue;
+      }
+      if (char === "\\") {
+        escaped = true;
+        continue;
+      }
+      if (char === quote) quote = null;
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "{") depth += 1;
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return index;
+    }
+  }
+  return -1;
+};
+
+const dictionaryModelFieldLine = (fieldName: string) => {
   const label = bilingualLabelForField(fieldName);
   const desc = bilingualDescriptionForField(fieldName);
-  const modelIndex = content.indexOf(`.model<${moduleClassName}>((t) => ({`);
+  return `${fieldName}: t([${JSON.stringify(label.en)}, ${JSON.stringify(label.ko)}]).desc([${JSON.stringify(
+    desc.en,
+  )}, ${JSON.stringify(desc.ko)}]),`;
+};
+
+export const insertDictionaryModelField = (content: string, moduleClassName: string, fieldName: string) => {
+  if (new RegExp(`\\b${fieldName}\\s*:`).test(content)) return content;
+  const modelIndex = content.indexOf(`.model<${moduleClassName}>((t) => (`);
   if (modelIndex < 0) return null;
-  const objectEndIndex = content.indexOf("  }))", modelIndex);
+  const objectStartIndex = content.indexOf("{", modelIndex);
+  if (objectStartIndex < 0) return null;
+  const objectEndIndex = findMatchingBrace(content, objectStartIndex);
   if (objectEndIndex < 0) return null;
-  return `${content.slice(0, objectEndIndex)}    ${fieldName}: t([${JSON.stringify(label.en)}, ${JSON.stringify(
-    label.ko,
-  )}]).desc([${JSON.stringify(desc.en)}, ${JSON.stringify(desc.ko)}]),\n${content.slice(objectEndIndex)}`;
+  const fieldLine = dictionaryModelFieldLine(fieldName);
+  const body = content.slice(objectStartIndex + 1, objectEndIndex);
+  if (body.trim().length === 0) {
+    return `${content.slice(0, objectStartIndex + 1)}\n    ${fieldLine}\n  ${content.slice(objectEndIndex)}`;
+  }
+  const insertion = body.endsWith("\n") ? `    ${fieldLine}\n` : `\n    ${fieldLine}\n`;
+  return `${content.slice(0, objectEndIndex)}${insertion}${content.slice(objectEndIndex)}`;
 };
 
 export const ensureConstantTypeImport = (content: string, constantPath: string, typeName: string) => {

package/workflow/types.ts

@@ -177,6 +177,13 @@ export interface PrimitiveChangedFile {
   reason: string;
 }
 
+export interface WorkflowPostApplyCheck {
+  code: string;
+  target: string;
+  status: "passed" | "failed";
+  message: string;
+}
+
 export interface PrimitiveGeneratedFile {
   path: string;
   action: "sync";
@@ -220,6 +227,7 @@ export interface WorkflowApplyReport {
   recommendedValidationCommands: WorkflowApplyCommand[];
   commands: WorkflowApplyCommand[];
   diagnostics: WorkflowDiagnostic[];
+  postApplyChecks?: WorkflowPostApplyCheck[];
   recommendations: WorkflowRecommendation[];
   nextActions: PrimitiveNextAction[];
   plan: WorkflowPlan;
@@ -279,6 +287,7 @@ export interface WorkflowStepResult {
   generatedFiles?: PrimitiveGeneratedFile[];
   commands?: WorkflowApplyCommand[];
   diagnostics?: WorkflowDiagnostic[];
+  postApplyChecks?: WorkflowPostApplyCheck[];
   recommendations?: WorkflowRecommendation[];
   nextActions?: PrimitiveNextAction[];
 }