@akanjs/devkit 3.1.1-rc.16 → 3.1.1-rc.18

package/typecheck/typecheck.proc.ts

@@ -24,6 +24,12 @@ try {
   const configPath = process.env.AKAN_TYPECHECK_TSCONFIG;
   if (!configPath) throw new Error("AKAN_TYPECHECK_TSCONFIG is required");
   const result = TypeChecker.checkProject(configPath);
+  if (process.env.AKAN_TYPECHECK_FORMAT === "json") {
+    //? Not process.cwd(): that is the realpath (/private/var on macOS) while TypeScript keeps the spelling it was given.
+    const root = process.env.AKAN_TYPECHECK_ROOT ?? process.cwd();
+    process.stdout.write(JSON.stringify(TypeChecker.toRecords(result.errors, root)));
+    process.exit(result.errors.length > 0 ? 1 : 0);
+  }
   if (result.errors.length > 0) {
     console.error(result.message);
     process.exit(1);

package/typecheck/typecheckFailure.ts

@@ -0,0 +1,13 @@
+import type { TypecheckRecord } from "../typeChecker";
+
+export class TypecheckFailure extends Error {
+  constructor(readonly records: TypecheckRecord[]) {
+    super(
+      records
+        .slice(0, 20)
+        .map((record) => `${record.file ?? "-"}:${record.line}:${record.col} ${record.code} ${record.message}`)
+        .join("\n") || "Typecheck failed",
+    );
+    this.name = "TypecheckFailure";
+  }
+}

package/workflow/artifacts.ts

@@ -282,6 +282,15 @@ const statusForValidationKind = (
   return matching.some((command) => command.status === "failed") ? "failed" : "passed";
 };
 
+//? `akan verify` syncs first and names a failed sync in its header line (`sync 1 error`), so one run answers both.
+const generatedSyncStatus = (commands: readonly WorkflowValidationCommandResult[]): WorkflowValidationStatus => {
+  const sync = statusForValidationKind(commands, "sync");
+  const verify = commands.filter((command) => command.kind === "verify");
+  if (sync !== "unknown" || verify.length === 0) return sync;
+  const syncFailed = verify.some((command) => /^verify fail · .*\bsync \d+ errors?\b/m.test(command.stdout ?? ""));
+  return syncFailed ? "failed" : "passed";
+};
+
 const statusForCommands = (commands: readonly WorkflowValidationCommandResult[]): WorkflowValidationStatus => {
   if (commands.length === 0) return "unknown";
   return commandStatus(commands) === "failed" ? "failed" : "passed";
@@ -438,7 +447,7 @@ const createValidationStatuses = (
     overallStatus,
     summary: {
       sourceChange: sourceStatus,
-      generatedSync: statusForValidationKind(commands, "sync"),
+      generatedSync: generatedSyncStatus(commands),
       validationCommands: validationCommandsStatus,
       baseline: baselineStatus,
       workspaceConfig: statusForScope(commands, diagnostics, scopes, "workspace-config"),

package/workflow/render.ts

@@ -1,3 +1,4 @@
+import { camelToKebabCase } from "../commandDecorators/camelToKebabCase";
 import type {
   PrimitiveFormat,
   PrimitiveWriteReport,
@@ -63,9 +64,9 @@ export const renderWorkflowExplain = (spec: WorkflowSpec) =>
     "## Inputs",
     ...Object.entries(spec.inputs).map(
       ([name, input]) =>
-        `- \`${name}\`${input.required ? " (required)" : ""}: ${input.description}${
-          input.allowedValues ? ` Allowed: ${input.allowedValues.join(", ")}.` : ""
-        }`,
+        `- \`${name}\`${camelToKebabCase(name) === name ? "" : ` (\`--${camelToKebabCase(name)}\`)`}${
+          input.required ? " (required)" : ""
+        }: ${input.description}${input.allowedValues ? ` Allowed: ${input.allowedValues.join(", ")}.` : ""}`,
     ),
     "",
     "## Optional Surfaces",

package/workflow/source.test.ts

@@ -10,6 +10,7 @@ import {
   hasSourceParseErrors,
   insertClassMethod,
   insertDictionaryEndpointEntry,
+  insertDictionaryEnum,
   insertSignalFactoryEntry,
   inspectDictionaryStructure,
 } from "./source";
@@ -251,6 +252,60 @@ describe("dictionary endpoint entries", () => {
   });
 });
 
+describe("insertDictionaryEnum", () => {
+  const dictionary = (tail: string) => `import { modelDictionary } from "akanjs/dictionary";
+
+import type { Task } from "./task.constant";
+
+// Stages: .model() field labels, .enum() value labels, .error() messages, .translate() UI messages.
+
+export const dictionary = modelDictionary(["en", "ko"])
+  .of((t) => t(["Task", "할 일"]))
+  .model<Task>((t) => ({
+    title: t(["Title", "제목"]),
+  }))${tail};
+`;
+
+  test("inserts before the chain's own .error() stage, not a comment that names it", () => {
+    const next = insertDictionaryEnum(
+      dictionary(`
+  .error({ notFound: ["Not found", "없음"] })
+  .translate({})`),
+      "TaskPriority",
+      "taskPriority",
+      ["low", "high"],
+    );
+    expect(next).not.toBeNull();
+    expect(hasSourceParseErrors(next ?? "", "task.dictionary.ts")).toBe(false);
+    expect(next?.split("\n").slice(-7)).toEqual([
+      '  .enum<TaskPriority>("taskPriority", (t) => ({',
+      '    low: t(["Low", "Low"]),',
+      '    high: t(["High", "High"]),',
+      "  }))",
+      '  .error({ notFound: ["Not found", "없음"] })',
+      "  .translate({});",
+      "",
+    ]);
+    expect(inspectDictionaryStructure(next ?? "", "Task").chainOrderValid).toBe(true);
+  });
+
+  test("appends to the end of a chain with no later stage", () => {
+    const next = insertDictionaryEnum(dictionary(""), "TaskPriority", "taskPriority", ["low"]);
+    expect(hasSourceParseErrors(next ?? "", "task.dictionary.ts")).toBe(false);
+    expect(next).toContain(
+      '  }))\n  .enum<TaskPriority>("taskPriority", (t) => ({\n    low: t(["Low", "Low"]),\n  }));\n',
+    );
+  });
+
+  test("leaves an existing enum stage alone and refuses a file that does not parse", () => {
+    const withEnum = insertDictionaryEnum(dictionary(""), "TaskPriority", "taskPriority", ["low"]) ?? "";
+    expect(insertDictionaryEnum(withEnum, "TaskPriority", "taskPriority", ["low"])).toBe(withEnum);
+    expect(
+      insertDictionaryEnum("export const dictionary = modelDictionary([", "TaskPriority", "taskPriority", ["low"]),
+    ).toBeNull();
+  });
+});
+
 describe("classMethodParameters", () => {
   test("reads names and which parameters a caller may leave out", () => {
     const content = `export class NoteService {

package/workflow/source.ts

@@ -58,14 +58,12 @@ export const generatedFilesForSync = (sys: Sys, reason = "Generated files may ch
 
 export const validationCommandsForTarget = (target: string) =>
   [
-    { command: `akan sync ${target}`, reason: "Refresh generated Akan files from source conventions." },
-    { command: `akan lint ${target}`, reason: "Validate formatting, imports, and static lint rules." },
+    { command: `akan verify ${target}`, reason: "Sync, lint, typecheck and build the target in one run." },
   ] satisfies PrimitiveValidationCommand[];
 
 export const nextActionsForTarget = (target: string) =>
   [
-    { 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." },
+    { command: `akan verify ${target}`, reason: "Refresh generated files and validate the target in one run." },
   ] satisfies PrimitiveNextAction[];
 
 export const createPrimitiveWriteReport = ({
@@ -898,17 +896,38 @@ export const ensureConstantTypeImport = (content: string, constantPath: string,
   return `import type { ${typeName} } from "${constantPath}";\n${content}`;
 };
 
+const dictionaryChainOf = (node: ts.Node): ts.CallExpression | undefined => {
+  if (
+    ts.isCallExpression(node) &&
+    outermostFluentCall(node) === node &&
+    protectedDictionaryChainOrder.some((method) => chainMethodsForCall(node).includes(method))
+  )
+    return node;
+  return ts.forEachChild(node, dictionaryChainOf);
+};
+
+const chainMethodNames = (call: ts.Expression): ts.Identifier[] => {
+  if (!ts.isCallExpression(call) || !ts.isPropertyAccessExpression(call.expression)) return [];
+  const name = call.expression.name;
+  return [...chainMethodNames(call.expression.expression), ...(ts.isIdentifier(name) ? [name] : [])];
+};
+
+//* Located on the parsed chain, never by text search: the sample dictionary's header comment mentions `.error()`.
 export const insertDictionaryEnum = (content: string, enumClassName: string, enumName: string, values: string[]) => {
   if (content.includes(`.enum<${enumClassName}>("${enumName}"`)) return content;
+  const source = sourceFileFor("dictionary.ts", content);
+  if (hasParseDiagnostics(source)) return null;
+  const chain = dictionaryChainOf(source);
+  if (!chain) return null;
   const enumBlock = `  .enum<${enumClassName}>("${enumName}", (t) => ({\n${values
     .map((value) => `    ${value}: t([${JSON.stringify(titleize(value))}, ${JSON.stringify(titleize(value))}]),`)
     .join("\n")}\n  }))\n`;
-  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)}`;
+  const later = chainMethodNames(chain).find((name) => name.text === "error" || name.text === "translate");
+  if (!later) return spliceText(content, chain.getEnd(), chain.getEnd(), `\n${enumBlock.trimEnd()}`);
+  const dot = content.lastIndexOf(".", later.getStart(source));
+  const lineStart = lineStartAt(content, dot);
+  if (content.slice(lineStart, dot).trim() === "") return spliceText(content, lineStart, lineStart, enumBlock);
+  return spliceText(content, dot, dot, `\n${enumBlock}`);
 };
 
 export const parseValues = (value: string | null) =>

package/workflow/types.ts

@@ -8,7 +8,7 @@ export type WorkflowFormat = "markdown" | "json";
 export type WorkflowPlanInputs = Record<string, string | null>;
 export type PrimitiveFormat = "markdown" | "json";
 export type UiSurface = "view" | "unit" | "template";
-export type WorkflowValidationKind = "sync" | "lint" | "typecheck" | "doctor" | "custom";
+export type WorkflowValidationKind = "verify" | "sync" | "lint" | "typecheck" | "doctor" | "custom";
 export type WorkflowFailureScope = "workspace-config" | "environment" | "source-change" | "unknown";
 export type WorkflowValidationStatus = "passed" | "failed" | "unknown";
 export interface WorkflowValidationSummary {