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

package/workflow/source.ts

@@ -18,6 +18,26 @@ export const sourceFile = (sys: Sys, path: string, action: PrimitiveChangedFile[
   reason,
 });
 
+export const moduleComponentName = (moduleName: string) =>
+  `${moduleName.slice(0, 1).toUpperCase()}${moduleName.slice(1)}`;
+
+export const moduleSourcePaths = (moduleName: string) => {
+  const componentName = moduleComponentName(moduleName);
+  return {
+    abstract: `lib/${moduleName}/${moduleName}.abstract.md`,
+    constant: `lib/${moduleName}/${moduleName}.constant.ts`,
+    dictionary: `lib/${moduleName}/${moduleName}.dictionary.ts`,
+    service: `lib/${moduleName}/${moduleName}.service.ts`,
+    signal: `lib/${moduleName}/${moduleName}.signal.ts`,
+    store: `lib/${moduleName}/${moduleName}.store.ts`,
+    template: `lib/${moduleName}/${componentName}.Template.tsx`,
+    unit: `lib/${moduleName}/${componentName}.Unit.tsx`,
+    util: `lib/${moduleName}/${componentName}.Util.tsx`,
+    view: `lib/${moduleName}/${componentName}.View.tsx`,
+    zone: `lib/${moduleName}/${componentName}.Zone.tsx`,
+  };
+};
+
 export const generatedFilesForSync = (sys: Sys, reason = "Generated files may change after sync.") =>
   generatedFilePathsForTarget(getSysRoot(sys), reason);
 
@@ -68,6 +88,60 @@ export const titleize = (value: string) =>
 
 export const lowerlize = (value: string) => `${value.slice(0, 1).toLowerCase()}${value.slice(1)}`;
 
+const koLabels: Record<string, string> = {
+  amount: "금액",
+  budget: "예산",
+  category: "카테고리",
+  content: "내용",
+  count: "개수",
+  createdAt: "생성일",
+  date: "날짜",
+  description: "설명",
+  due: "마감일",
+  dueAt: "마감일",
+  email: "이메일",
+  enabled: "활성화",
+  endAt: "종료일",
+  id: "ID",
+  name: "이름",
+  owner: "담당자",
+  priority: "우선순위",
+  project: "프로젝트",
+  rating: "평점",
+  startAt: "시작일",
+  status: "상태",
+  title: "제목",
+  updatedAt: "수정일",
+};
+
+const splitFieldWords = (fieldName: string) =>
+  fieldName
+    .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
+    .replace(/[-_]+/g, " ")
+    .split(/\s+/)
+    .map((word) => word.trim())
+    .filter(Boolean);
+
+const koLabelForField = (fieldName: string) => {
+  if (koLabels[fieldName]) return koLabels[fieldName];
+  const words = splitFieldWords(fieldName);
+  const translated = words.map((word) => koLabels[word] ?? koLabels[lowerlize(word)] ?? null);
+  return translated.every(Boolean) ? translated.join(" ") : null;
+};
+
+export const bilingualLabelForField = (fieldName: string) => {
+  const en = titleize(fieldName);
+  return { en, ko: koLabelForField(fieldName) ?? en };
+};
+
+export const bilingualDescriptionForField = (fieldName: string) => {
+  const label = bilingualLabelForField(fieldName);
+  return {
+    en: `Enter ${label.en.toLowerCase()}.`,
+    ko: `${label.ko} 값을 입력합니다.`,
+  };
+};
+
 export const normalizeFieldType = (typeName: string) => {
   const normalizedTypes: Record<string, string> = {
     string: "String",
@@ -96,24 +170,54 @@ export const ensureBaseTypeImport = (content: string, typeName: string) => {
   return `import { ${typeName} } from "akanjs/base";\n${content}`;
 };
 
-const numericDefault = (typeName: "Int" | "Float", rawDefault: string): string | null => {
+export type FieldDefaultValue = string | number | boolean | null;
+
+const numericDefault = (typeName: "Int" | "Float", rawDefault: FieldDefaultValue): string | null => {
+  if (typeof rawDefault === "number") {
+    if (!Number.isFinite(rawDefault)) return null;
+    if (typeName === "Int" && !Number.isInteger(rawDefault)) return null;
+    return String(rawDefault);
+  }
+  if (typeof rawDefault !== "string") return null;
   const trimmed = rawDefault.trim();
   if (!trimmed || !Number.isFinite(Number(trimmed))) return null;
   if (typeName === "Int" && !/^-?\d+$/.test(trimmed)) return null;
   return trimmed;
 };
 
+const booleanDefault = (rawDefault: FieldDefaultValue): string | null => {
+  if (typeof rawDefault === "boolean") return String(rawDefault);
+  if (typeof rawDefault !== "string") return null;
+  const lowered = rawDefault.trim().toLowerCase();
+  return lowered === "true" || lowered === "false" ? lowered : null;
+};
+
+const dateDefault = (rawDefault: FieldDefaultValue): string | null => {
+  if (typeof rawDefault === "number" && Number.isFinite(rawDefault)) return `new Date(${rawDefault})`;
+  if (typeof rawDefault !== "string") return null;
+  const trimmed = rawDefault.trim();
+  if (!trimmed) return null;
+  if (trimmed === "now") return "new Date()";
+  if (!Number.isNaN(Date.parse(trimmed))) return `new Date(${JSON.stringify(trimmed)})`;
+  return null;
+};
+
 export const coerceFieldDefault = (
   typeName: string,
-  defaultValue?: string | null,
-): { expression: string | null; diagnostic?: WorkflowDiagnostic } => {
-  if (defaultValue === undefined || defaultValue === null || defaultValue === "") return { expression: null };
-  const normalizedType = normalizeFieldType(typeName);
+  defaultValue?: FieldDefaultValue,
+  options: { enumValues?: readonly string[] | null } = {},
+): { expression: string | null; diagnostic?: WorkflowDiagnostic; normalized: boolean; normalizedType: string } => {
+  const normalizedType = typeName.toLowerCase() === "enum" ? "enum" : normalizeFieldType(typeName);
+  if (defaultValue === undefined || defaultValue === null || defaultValue === "") {
+    return { expression: null, normalized: false, normalizedType };
+  }
   if (normalizedType === "Int" || normalizedType === "Float") {
     const expression = numericDefault(normalizedType, defaultValue);
-    if (expression !== null) return { expression };
+    if (expression !== null) return { expression, normalized: typeof defaultValue === "string", normalizedType };
     return {
       expression: null,
+      normalized: false,
+      normalizedType,
       diagnostic: {
         severity: "error",
         code: "primitive-default-value-invalid",
@@ -124,10 +228,12 @@ export const coerceFieldDefault = (
     };
   }
   if (normalizedType === "Boolean") {
-    const lowered = defaultValue.trim().toLowerCase();
-    if (lowered === "true" || lowered === "false") return { expression: lowered };
+    const expression = booleanDefault(defaultValue);
+    if (expression !== null) return { expression, normalized: typeof defaultValue === "string", normalizedType };
     return {
       expression: null,
+      normalized: false,
+      normalizedType,
       diagnostic: {
         severity: "error",
         code: "primitive-default-value-invalid",
@@ -137,14 +243,70 @@ export const coerceFieldDefault = (
       },
     };
   }
-  return { expression: JSON.stringify(defaultValue) };
+  if (normalizedType === "Date") {
+    const expression = dateDefault(defaultValue);
+    if (expression !== null) return { expression, normalized: true, normalizedType };
+    return {
+      expression: null,
+      normalized: false,
+      normalizedType,
+      diagnostic: {
+        severity: "error",
+        code: "primitive-default-value-invalid",
+        input: "default",
+        failureScope: "source-change",
+        message: `Default value for Date must be "now", a timestamp, or a parseable date string. Received: ${JSON.stringify(
+          defaultValue,
+        )}.`,
+      },
+    };
+  }
+  if (normalizedType === "enum") {
+    if (typeof defaultValue === "string" && options.enumValues?.includes(defaultValue)) {
+      return { expression: JSON.stringify(defaultValue), normalized: false, normalizedType };
+    }
+    return {
+      expression: null,
+      normalized: false,
+      normalizedType,
+      diagnostic: {
+        severity: "error",
+        code: "primitive-default-value-invalid",
+        input: "default",
+        failureScope: "source-change",
+        message: `Default value for enum must be one of: ${(options.enumValues ?? []).join(", ")}. Received: ${JSON.stringify(
+          defaultValue,
+        )}.`,
+      },
+    };
+  }
+  return {
+    expression: JSON.stringify(String(defaultValue)),
+    normalized: typeof defaultValue !== "string",
+    normalizedType,
+  };
 };
 
-export const fieldExpression = (typeName: string, defaultValue?: string | null) => {
+export const fieldExpression = (
+  typeName: string,
+  defaultValue?: FieldDefaultValue,
+  options: { enumValues?: readonly string[] | null; builderName?: string } = {},
+) => {
   const typeExpression = normalizeFieldType(typeName);
-  const defaultExpression = coerceFieldDefault(typeExpression, defaultValue).expression;
+  const defaultExpression = coerceFieldDefault(
+    options.enumValues ? "enum" : typeExpression,
+    defaultValue,
+    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) => {
@@ -158,6 +320,52 @@ export const insertIntoObject = (content: string, className: string, line: strin
   return `${prefix}${insertion}${suffix}`;
 };
 
+export const insertLightProjectionField = (content: string, moduleClassName: string, fieldName: string) => {
+  const classIndex = content.indexOf(`export class Light${moduleClassName} extends via`);
+  if (classIndex < 0) return null;
+  const arrayMatch = /\[([\s\S]*?)\]\s+as const/.exec(content.slice(classIndex));
+  if (!arrayMatch || arrayMatch.index === undefined) return null;
+  const arrayStart = classIndex + arrayMatch.index;
+  const arrayEnd = arrayStart + arrayMatch[0].length;
+  const fields = [...arrayMatch[1].matchAll(/"([^"]+)"/g)].map((match) => match[1]).filter(Boolean);
+  if (fields.includes(fieldName)) return content;
+  const nextFields = [...fields, fieldName];
+  const nextArray =
+    nextFields.length === 0
+      ? "[] as const"
+      : `[\n${nextFields.map((field) => `  ${JSON.stringify(field)},`).join("\n")}\n] as const`;
+  return `${content.slice(0, arrayStart)}${nextArray}${content.slice(arrayEnd)}`;
+};
+
+export const insertTemplateField = ({
+  content,
+  moduleName,
+  moduleClassName,
+  fieldName,
+  component,
+}: {
+  content: string;
+  moduleName: string;
+  moduleClassName: string;
+  fieldName: string;
+  component: "Field.Text" | "Field.Number" | "Field.Date";
+}) => {
+  if (content.includes(`l("${moduleName}.${fieldName}")`) || content.includes(`.${fieldName}`)) return content;
+  const layoutEndIndex = content.indexOf("    </Layout.Template>");
+  if (layoutEndIndex < 0) return null;
+  const formName = `${moduleName}Form`;
+  if (!content.includes(`const ${formName} = st.use.${moduleName}Form();`)) return null;
+  const fieldSetter = `st.do.set${moduleComponentName(fieldName)}On${moduleClassName}`;
+  const fieldBlock = `      <${component}
+        label={l("${moduleName}.${fieldName}")}
+        desc={l("${moduleName}.${fieldName}.desc")}
+        value={${formName}.${fieldName}}
+        onChange={${fieldSetter}}
+      />
+`;
+  return `${content.slice(0, layoutEndIndex)}${fieldBlock}${content.slice(layoutEndIndex)}`;
+};
+
 export const ensureEnumImport = (content: string) => {
   if (content.includes("enumOf")) return content;
   const baseImport = /import \{ ([^}]+) \} from "akanjs\/base";/.exec(content);
@@ -178,16 +386,60 @@ export const insertEnumClass = (content: string, enumClassName: string, enumName
   return `${content.slice(0, firstClassIndex)}${enumClass}${content.slice(firstClassIndex)}`;
 };
 
+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);
+  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 label = titleize(fieldName);
-  const modelIndex = content.indexOf(`.model<${moduleClassName}>((t) => ({`);
+  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)}, ${JSON.stringify(
-    label,
-  )}]).desc([${JSON.stringify(label)}, ${JSON.stringify(label)}]),\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

@@ -1,8 +1,9 @@
 import type { Sys, Workspace } from "../commandDecorators";
+import type { FieldDefaultValue } from "./source";
 
-export type WorkflowInputType = "string" | "string-list" | "surface-mode";
+export type WorkflowInputType = "string" | "string-list" | "surface-mode" | "boolean";
 export type WorkflowSurfaceMode = "infer" | "include" | "skip";
-export type WorkflowInputValue = string | string[] | WorkflowSurfaceMode;
+export type WorkflowInputValue = string | string[] | boolean | WorkflowSurfaceMode;
 export type WorkflowFormat = "markdown" | "json";
 export type WorkflowPlanInputs = Record<string, string | null>;
 export type PrimitiveFormat = "markdown" | "json";
@@ -10,6 +11,12 @@ export type UiSurface = "view" | "unit" | "template";
 export type WorkflowValidationKind = "sync" | "lint" | "typecheck" | "doctor" | "custom";
 export type WorkflowFailureScope = "workspace-config" | "environment" | "source-change" | "unknown";
 export type WorkflowValidationStatus = "passed" | "failed" | "unknown";
+export interface WorkflowValidationSummary {
+  sourceChange: WorkflowValidationStatus;
+  generatedSync: WorkflowValidationStatus;
+  workspaceConfig: WorkflowValidationStatus;
+  environment: WorkflowValidationStatus;
+}
 export type WorkflowOverallStatus = "passed" | "failed" | "blocked-by-workspace-config" | "blocked-by-environment";
 
 export interface PrimitiveTargetInput {
@@ -20,13 +27,17 @@ export interface PrimitiveTargetInput {
 export interface AddFieldInput extends PrimitiveTargetInput {
   field: string | null;
   type: string | null;
-  defaultValue?: string | null;
+  defaultValue?: FieldDefaultValue;
+  surfaces?: string[] | null;
+  includeInLight?: boolean | null;
 }
 
 export interface AddEnumFieldInput extends PrimitiveTargetInput {
   field: string | null;
   values: string | null;
-  defaultValue?: string | null;
+  defaultValue?: FieldDefaultValue;
+  surfaces?: string[] | null;
+  includeInLight?: boolean | null;
 }
 
 export interface WorkflowInputSpec {
@@ -150,6 +161,7 @@ export interface WorkflowKnownBlocker {
   command?: string;
   kind?: WorkflowValidationKind;
   count: number;
+  known?: boolean;
 }
 
 export interface RepairAction {
@@ -165,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";
@@ -208,6 +227,7 @@ export interface WorkflowApplyReport {
   recommendedValidationCommands: WorkflowApplyCommand[];
   commands: WorkflowApplyCommand[];
   diagnostics: WorkflowDiagnostic[];
+  postApplyChecks?: WorkflowPostApplyCheck[];
   recommendations: WorkflowRecommendation[];
   nextActions: PrimitiveNextAction[];
   plan: WorkflowPlan;
@@ -222,6 +242,7 @@ export interface WorkflowValidationRunReport {
   status: "passed" | "failed";
   sourceStatus: WorkflowValidationStatus;
   workspaceStatus: WorkflowValidationStatus;
+  summary: WorkflowValidationSummary;
   overallStatus: WorkflowOverallStatus;
   knownBlockers: WorkflowKnownBlocker[];
   commands: WorkflowValidationCommandResult[];
@@ -266,6 +287,7 @@ export interface WorkflowStepResult {
   generatedFiles?: PrimitiveGeneratedFile[];
   commands?: WorkflowApplyCommand[];
   diagnostics?: WorkflowDiagnostic[];
+  postApplyChecks?: WorkflowPostApplyCheck[];
   recommendations?: WorkflowRecommendation[];
   nextActions?: PrimitiveNextAction[];
 }

package/workflow/uiPolicy.ts

@@ -0,0 +1,45 @@
+import { normalizeFieldType } from "./source";
+
+export type AddFieldUiComponent = "Field.Text" | "Field.Number" | "Field.Date" | "Field.ToggleSelect";
+
+export const addFieldUiPolicyForType = (typeName: string) => {
+  const normalizedType = typeName.toLowerCase() === "enum" ? "enum" : normalizeFieldType(typeName);
+  if (normalizedType === "Int" || normalizedType === "Float") {
+    return {
+      normalizedType,
+      component: "Field.Number" as const,
+      confidence: "high" as const,
+      autoTemplateSupported: true,
+    };
+  }
+  if (normalizedType === "Date") {
+    return {
+      normalizedType,
+      component: "Field.Date" as const,
+      confidence: "high" as const,
+      autoTemplateSupported: true,
+    };
+  }
+  if (normalizedType === "Boolean" || normalizedType === "enum") {
+    return {
+      normalizedType,
+      component: "Field.ToggleSelect" as const,
+      confidence: "medium" as const,
+      autoTemplateSupported: false,
+    };
+  }
+  if (normalizedType === "String") {
+    return {
+      normalizedType,
+      component: "Field.Text" as const,
+      confidence: "high" as const,
+      autoTemplateSupported: true,
+    };
+  }
+  return {
+    normalizedType,
+    component: "Field.Text" as const,
+    confidence: "low" as const,
+    autoTemplateSupported: false,
+  };
+};