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

package/devkitUtils.test.ts

@@ -269,11 +269,11 @@ describe("getModelFileData", () => {
         ].join("\n"),
       );
       await write(
-        path.join(root, "apps/demo/lib/post/post.Unit.tsx"),
+        path.join(root, "apps/demo/lib/post/Post.Unit.tsx"),
         "export default function Unit() { return null; }\n",
       );
       await write(
-        path.join(root, "apps/demo/lib/post/post.View.tsx"),
+        path.join(root, "apps/demo/lib/post/Post.View.tsx"),
         "export default function View() { return null; }\n",
       );
 

package/executors.ts

@@ -626,14 +626,14 @@ export class Executor {
       overwrite?: boolean;
     },
     dict: { [key: string]: string } = {},
-    options: { [key: string]: any } = {},
+    options: { [key: string]: unknown } = {},
   ): Promise<FileContent | null> {
     if (targetPath.endsWith(".ts") || targetPath.endsWith(".tsx")) {
       const getContent = (await import(templatePath)) as {
         default: (
           scanInfo: AppInfo | LibInfo | null,
           dict: { [key: string]: string },
-          options?: { [key: string]: any },
+          options?: { [key: string]: unknown },
         ) => Promise<string | null | { filename: string; content: string }>;
       };
       const result = await getContent.default(scanInfo ?? null, dict, options);
@@ -686,7 +686,7 @@ export class Executor {
     template: string;
     scanInfo?: AppInfo | LibInfo | null;
     dict?: { [key: string]: string };
-    options?: { [key: string]: any };
+    options?: { [key: string]: unknown };
     overwrite?: boolean;
   }): Promise<FileContent[]> {
     const templateRoot = await this.#resolveTemplateRoot();
@@ -752,7 +752,7 @@ export class Executor {
     basePath: string;
     template: string;
     dict?: { [key: string]: string };
-    options?: { [key: string]: any };
+    options?: { [key: string]: unknown };
     overwrite?: boolean;
   }): Promise<FileContent[]> {
     const dict = {
@@ -827,10 +827,10 @@ export class Executor {
     filePath: string,
     { fix = false, dryRun = false }: { fix?: boolean; dryRun?: boolean } = {},
   ): Promise<{
-    results: any[]; // ESLint.LintResult[];
+    results: unknown[]; // ESLint.LintResult[];
     message: string;
-    errors: any[]; // ESLintLinter.LintMessage[];
-    warnings: any[]; // ESLintLinter.LintMessage[];
+    errors: unknown[]; // ESLintLinter.LintMessage[];
+    warnings: unknown[]; // ESLintLinter.LintMessage[];
   }> {
     const path = this.getPath(filePath);
     const linter = this.getLinter();
@@ -1225,40 +1225,44 @@ export class SysExecutor extends Executor {
   async getViewComponents() {
     const viewComponents = (await this.readdir("lib"))
       .filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts"))
-      .filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.View.tsx`).exists());
+      .filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.View.tsx`).exists());
     return viewComponents;
   }
 
   async getUnitComponents() {
     const unitComponents = (await this.readdir("lib"))
       .filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts"))
-      .filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.Unit.tsx`).exists());
+      .filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.Unit.tsx`).exists());
     return unitComponents;
   }
   async getTemplateComponents() {
     const templateComponents = (await this.readdir("lib"))
       .filter((name) => !name.startsWith("_") && !name.startsWith("__") && !name.endsWith(".ts"))
-      .filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${name}.Template.tsx`).exists());
+      .filter((name) => Bun.file(`${this.cwdPath}/lib/${name}/${capitalize(name)}.Template.tsx`).exists());
     return templateComponents;
   }
 
   async getViewsSourceCode() {
     const viewComponents = await this.getViewComponents();
     return Promise.all(
-      viewComponents.map((viewComponent) => this.getLocalFile(`lib/${viewComponent}/${viewComponent}.View.tsx`)),
+      viewComponents.map((viewComponent) =>
+        this.getLocalFile(`lib/${viewComponent}/${capitalize(viewComponent)}.View.tsx`),
+      ),
     );
   }
   async getUnitsSourceCode() {
     const unitComponents = await this.getUnitComponents();
     return Promise.all(
-      unitComponents.map((unitComponent) => this.getLocalFile(`lib/${unitComponent}/${unitComponent}.Unit.tsx`)),
+      unitComponents.map((unitComponent) =>
+        this.getLocalFile(`lib/${unitComponent}/${capitalize(unitComponent)}.Unit.tsx`),
+      ),
     );
   }
   async getTemplatesSourceCode() {
     const templateComponents = await this.getTemplateComponents();
     return Promise.all(
       templateComponents.map((templateComponent) =>
-        this.getLocalFile(`lib/${templateComponent}/${templateComponent}.Template.tsx`),
+        this.getLocalFile(`lib/${templateComponent}/${capitalize(templateComponent)}.Template.tsx`),
       ),
     );
   }

package/getModelFileData.ts

@@ -1,3 +1,5 @@
+import { capitalize } from "akanjs/common";
+
 interface ModelFileData {
   moduleType: "lib" | "app";
   moduleName: string;
@@ -16,9 +18,10 @@ interface ModelFileData {
 export const getModelFileData = async (modulePath: string, modelName: string): Promise<ModelFileData> => {
   const moduleType = modulePath.startsWith("apps") ? "app" : "lib";
   const moduleName = modulePath.split("/")[1] ?? "";
+  const modelComponentName = capitalize(modelName);
   const constantFilePath = `${modulePath}/lib/${modelName}/${modelName}.constant.ts`;
-  const unitFilePath = `${modulePath}/lib/${modelName}/${modelName}.Unit.tsx`;
-  const viewFilePath = `${modulePath}/lib/${modelName}/${modelName}.View.tsx`;
+  const unitFilePath = `${modulePath}/lib/${modelName}/${modelComponentName}.Unit.tsx`;
+  const viewFilePath = `${modulePath}/lib/${modelName}/${modelComponentName}.View.tsx`;
   const [constantFileStr, unitFileStr, viewFileStr] = await Promise.all([
     Bun.file(constantFilePath).text(),
     Bun.file(unitFilePath).text(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/devkit",
-  "version": "2.3.9-rc.4",
+  "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.4",
+    "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,
   };
 };
@@ -186,6 +195,15 @@ const statusForScope = (
   return hasScopeFailure(scopes, expectedScope, diagnostics) ? "failed" : "passed";
 };
 
+const statusForValidationKind = (
+  commands: readonly WorkflowValidationCommandResult[],
+  kind: WorkflowValidationCommandResult["kind"],
+): WorkflowValidationStatus => {
+  const matching = commands.filter((command) => command.kind === kind);
+  if (matching.length === 0) return "unknown";
+  return matching.some((command) => command.status === "failed") ? "failed" : "passed";
+};
+
 const createKnownBlockers = (
   commands: readonly WorkflowValidationCommandResult[],
   diagnostics: readonly WorkflowDiagnostic[],
@@ -251,7 +269,17 @@ const createValidationStatuses = (
         : workflowStatus(diagnostics) === "failed" || commandStatus(commands) === "failed"
           ? "failed"
           : "passed";
-  return { sourceStatus, workspaceStatus, overallStatus };
+  return {
+    sourceStatus,
+    workspaceStatus,
+    overallStatus,
+    summary: {
+      sourceChange: sourceStatus,
+      generatedSync: statusForValidationKind(commands, "sync"),
+      workspaceConfig: statusForScope(commands, diagnostics, scopes, "workspace-config"),
+      environment: statusForScope(commands, diagnostics, scopes, "environment"),
+    },
+  };
 };
 
 export const createWorkflowValidationRunReport = async ({

package/workflow/executor.ts

@@ -1,7 +1,9 @@
 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";
+import { moduleSourcePaths } from "./source";
 import type {
   PrimitiveChangedFile,
   PrimitiveGeneratedFile,
@@ -11,11 +13,14 @@ import type {
   WorkflowDiagnostic,
   WorkflowInputValue,
   WorkflowPlan,
+  WorkflowPostApplyCheck,
   WorkflowPrimitiveOperations,
+  WorkflowRecommendation,
   WorkflowStep,
   WorkflowStepRegistry,
   WorkflowStepResult,
 } from "./types";
+import { addFieldUiPolicyForType } from "./uiPolicy";
 
 export const workflowStepKey = (workflow: string, stepId: string) => `${workflow}:${stepId}`;
 
@@ -31,6 +36,105 @@ export const primitiveReportToWorkflowStepResult = (report: PrimitiveWriteReport
 const workflowStringInput = (value: WorkflowInputValue | undefined) => (typeof value === "string" ? value : null);
 const workflowStringListInput = (value: WorkflowInputValue | undefined) =>
   Array.isArray(value) ? value.join(",") : null;
+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;
@@ -66,22 +170,22 @@ const addFieldUiSurfaceInspection = (plan: WorkflowPlan): WorkflowStepResult =>
   const module = workflowStringInput(plan.inputs.module) ?? "<module>";
   const field = workflowStringInput(plan.inputs.field) ?? "<field>";
   const typeName = workflowStringInput(plan.inputs.type);
-  const isNumeric = typeName === "Int" || typeName === "Float" || typeName === "integer" || typeName === "float";
+  const policy = addFieldUiPolicyForType(typeName ?? "String");
+  const surfaces = workflowStringArrayInput(plan.inputs.surfaces);
+  const templateRequested = surfaces?.includes("template") ?? false;
   const moduleClassName = capitalize(module);
-  const target = `${app ? `apps/${app}` : "*"}/lib/${module}/${moduleClassName}.Template.tsx`;
+  const target = `${app ? `apps/${app}` : "*"}/${moduleSourcePaths(module).template}`;
   return {
     recommendations: [
       {
         code: "add-field-ui-surface-review",
         kind: "manual-action",
         target,
-        action: isNumeric
-          ? `Review ${moduleClassName} Template/Unit/View/Store surfaces before adding ${field}; confirm the local Field.Text numeric parser/formatter, validation rule, and dictionary label pattern.`
-          : `Add ${field} to ${moduleClassName} UI surfaces only when the local Field.* pattern is clear.`,
+        action: templateRequested
+          ? `Template was requested for ${field}. If no Template file changed, auto-edit was skipped because the file was missing, the generated ${module}Form/Layout.Template pattern was not found, or ${policy.component} needs option binding. Candidate position: inside Layout.Template near the existing Field components.`
+          : `Template was not selected, so UI files are intentionally left unchanged. Candidate positions if you expose it later: Layout.Template field list for editing, Light${moduleClassName} projection for list/card data, and Unit/View card sections for display.`,
         confidence: "medium",
-        message: isNumeric
-          ? `No UI file was modified automatically because a safe numeric input component pattern is not yet detected for ${module}.${field}.`
-          : `Review Template/Unit/View/Store surfaces for ${module}.${field}; no UI file was modified automatically.`,
+        message: `Review UI surfaces for ${module}.${field}; recommended component is ${policy.component}, with manual reasons and candidate positions in action.`,
       },
     ],
     nextActions: [
@@ -149,6 +253,8 @@ export const createWorkflowStepRegistry = ({
             field: workflowStringInput(plan.inputs.field),
             values: workflowStringListInput(plan.inputs.values),
             defaultValue: workflowStringInput(plan.inputs.default),
+            surfaces: workflowStringArrayInput(plan.inputs.surfaces),
+            includeInLight: workflowBooleanInput(plan.inputs.includeInLight),
           }),
         );
       }
@@ -159,6 +265,8 @@ export const createWorkflowStepRegistry = ({
           field: workflowStringInput(plan.inputs.field),
           type: workflowStringInput(plan.inputs.type),
           defaultValue: workflowStringInput(plan.inputs.default),
+          surfaces: workflowStringArrayInput(plan.inputs.surfaces),
+          includeInLight: workflowBooleanInput(plan.inputs.includeInLight),
         }),
       );
     },
@@ -189,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[] = [];
 
@@ -207,6 +319,7 @@ export class WorkflowExecutor {
         generatedFiles,
         recommendedValidationCommands,
         diagnostics,
+        postApplyChecks,
         recommendations,
         nextActions,
         plan,
@@ -243,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",
@@ -250,6 +377,7 @@ export class WorkflowExecutor {
       generatedFiles,
       recommendedValidationCommands,
       diagnostics,
+      postApplyChecks,
       recommendations,
       nextActions,
       plan,

package/workflow/index.ts

@@ -5,4 +5,5 @@ export * from "./primitive";
 export * from "./render";
 export * from "./source";
 export * from "./types";
+export * from "./uiPolicy";
 export * from "./utils";