swallowkit 1.0.0-beta.54 → 1.0.0-beta.56

package/src/core/scaffold/ui-generator.ts

@@ -71,7 +71,7 @@ export function generateListPage(model: ModelInfo, sharedPackageName: string, au
     const refModelCamel = toCamelCase(refModel);
     return `    fetch('/api/${refModelCamel}')
       .then(res => res.json())
-      .then((data: any[]) => {
+      .then((data: Array<{ id: string; name?: string; title?: string }>) => {
         const map: Record<string, string> = {};
         data.forEach(item => {
           // name または title フィールドを表示用文字列として使用
@@ -138,8 +138,8 @@ ${hasForeignKeys ? foreignKeyFetches : ''}
       if (!res.ok) throw new Error('Failed to delete ${modelCamel}');
 
       set${modelName}s(${modelCamel}s.filter((item) => item.id !== id));
-    } catch (err: any) {
-      alert(\`Error: \${err.message}\`);
+    } catch (err) {
+      alert(\`Error: \${err instanceof Error ? err.message : String(err)}\`);
     }
   };
 
@@ -216,7 +216,7 @@ ${displayFields.map(f => {
     const displayField = f.nestedDisplayField || 'name';
     if (f.isArray) {
       return `                  <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900 dark:text-gray-100">
-                    {Array.isArray(item.${f.name}) ? item.${f.name}.map((ref: any) => ref?.${displayField} || '-').join(', ') : '-'}
+                    {Array.isArray(item.${f.name}) ? item.${f.name}.map((ref: unknown) => (ref as { ${displayField}?: string } | null)?.${displayField} || '-').join(', ') : '-'}
                   </td>`;
     } else {
       return `                  <td className="px-6 py-4 whitespace-nowrap text-sm text-gray-900 dark:text-gray-100">
@@ -317,7 +317,7 @@ export function generateDetailPage(model: ModelInfo, sharedPackageName: string,
     const refModelCamel = toCamelCase(refModel);
     return `    fetch('/api/${refModelCamel}')
       .then(res => res.json())
-      .then((data: any[]) => {
+      .then((data: Array<{ id: string; name?: string; title?: string }>) => {
         const map: Record<string, string> = {};
         data.forEach(item => {
           map[item.id] = item.name || item.title || item.id;
@@ -389,8 +389,8 @@ ${hasForeignKeys ? foreignKeyFetches : ''}
       if (!res.ok) throw new Error('Failed to delete ${modelCamel}');
 
       router.push('/${modelKebab}');
-    } catch (err: any) {
-      alert(\`Error: \${err.message}\`);
+    } catch (err) {
+      alert(\`Error: \${err instanceof Error ? err.message : String(err)}\`);
     }
   };
 
@@ -455,7 +455,7 @@ ${model.fields.map(f => {
     if (f.isArray) {
       return `            <div>
               <dt className="text-sm font-medium text-gray-500 dark:text-gray-400">${label}</dt>
-              <dd className="mt-1 text-sm text-gray-900 dark:text-gray-100">{Array.isArray(${modelCamel}.${f.name}) ? ${modelCamel}.${f.name}.map((ref: any) => ref?.${displayField} || '-').join(', ') : '-'}</dd>
+              <dd className="mt-1 text-sm text-gray-900 dark:text-gray-100">{Array.isArray(${modelCamel}.${f.name}) ? ${modelCamel}.${f.name}.map((ref: unknown) => (ref as { ${displayField}?: string } | null)?.${displayField} || '-').join(', ') : '-'}</dd>
             </div>`;
     } else {
       return `            <div>
@@ -547,7 +547,7 @@ export function generateFormComponent(model: ModelInfo, sharedPackageName: strin
     return `    // ${refModelPascal} の一覧を取得
     fetch('/api/${refModelCamel}')
       .then(res => res.json())
-      .then(data => set${refModelPascal}Options(data.map((item: any) => ({ id: item.id, name: item.${displayField} || item.name || item.title || item.id }))))
+      .then(data => set${refModelPascal}Options(data.map((item: Record<string, string>) => ({ id: item.id, name: item.${displayField} || item.name || item.title || item.id }))))
       .catch(err => console.error('Failed to load ${refModelPascal} options:', err));`;
   }).join('\n');
   
@@ -581,7 +581,7 @@ ${formFields.map(f => {
   // ネストスキーマの場合は参照ID（単一: string, 配列: string[]）を管理
   if (f.isNestedSchema) {
     if (f.isArray) {
-      return `    ${f.name}Ids: initialData?.${f.name} ? (Array.isArray(initialData.${f.name}) ? initialData.${f.name}.map((item: any) => item.id) : []) : [] as string[],`;
+      return `    ${f.name}Ids: initialData?.${f.name} ? (Array.isArray(initialData.${f.name}) ? initialData.${f.name}.map((item: { id: string }) => item.id) : []) : [] as string[],`;
     } else {
       return `    ${f.name}Id: initialData?.${f.name}?.id ?? '',`;
     }
@@ -615,7 +615,7 @@ ${needsUseEffect ? `
 ${hasForignKeys ? foreignKeyFields.map(f => `    // ${f.referencedModel} の一覧を取得
     fetch('/api/${toKebabCase(f.referencedModel!)}')
       .then(res => res.json())
-      .then(data => set${f.referencedModel}Options(data.map((item: any) => ({ id: item.id, name: item.name || item.title || item.id }))))
+      .then(data => set${f.referencedModel}Options(data.map((item: Record<string, string>) => ({ id: item.id, name: item.name || item.title || item.id }))))
       .catch(err => console.error('Failed to load ${f.referencedModel} options:', err));`).join('\n') : ''}
 ${hasNestedSchemas ? nestedSchemaFetches : ''}
   }, []);
@@ -627,7 +627,7 @@ ${hasNestedSchemas ? nestedSchemaFetches : ''}
 
     try {
       // Array フィールドをカンマ区切りから配列に変換
-      const submitData: any = { ...formData };
+      const submitData: Record<string, unknown> = { ...formData };
 ${formFields.filter(f => f.isArray && !f.isNestedSchema).map(f => `      if (typeof submitData.${f.name} === 'string') {
         submitData.${f.name} = submitData.${f.name}.split(',').map((s: string) => s.trim()).filter((s: string) => s.length > 0);
       }`).join('\n')}
@@ -651,7 +651,7 @@ ${nestedSchemaFields.map(f => {
   if (f.isArray) {
     return `      // ${refModelPascal} 配列参照の変換
       if (submitData.${f.name}Ids) {
-        submitData.${f.name} = submitData.${f.name}Ids
+        submitData.${f.name} = (submitData.${f.name}Ids as string[])
           .map((refId: string) => ${refModelCamel}Options.find(opt => opt.id === refId))
           .filter(Boolean);
         delete submitData.${f.name}Ids;
@@ -688,17 +688,17 @@ ${nestedSchemaFields.map(f => {
       }
 
       router.push('/${toKebabCase(modelName)}');
-    } catch (err: any) {
-      if (err.issues) {
+    } catch (err) {
+      if (err instanceof z.ZodError) {
         // Zod validation errors
         const fieldErrors: Record<string, string> = {};
-        err.issues.forEach((error: any) => {
-          const field = error.path[0];
-          fieldErrors[field] = error.message;
+        err.issues.forEach((issue) => {
+          const field = String(issue.path[0]);
+          fieldErrors[field] = issue.message;
         });
         setErrors(fieldErrors);
       } else {
-        alert(\`Error: \${err.message}\`);
+        alert(\`Error: \${err instanceof Error ? err.message : String(err)}\`);
       }
       setLoading(false);
     }

package/src/core/verify/index.ts

@@ -0,0 +1,392 @@
+/**
+ * Verify — 生成後の検証チェックを実行し、機械可読な結果を返す。
+ *
+ * 提供チェック:
+ * - structure:  プロジェクト構造規約 (validateProject)
+ * - drift:      生成物と現在状態の乖離 (detectDrift)
+ * - typecheck:  TypeScript 型チェック (tsc --noEmit / typecheck script)
+ * - build/lint/test: package.json scripts に同名 script がある場合のみ実行 (なければ skip)
+ * - custom:     swallowkit.config の verify.checks で定義されたプロジェクト固有チェック
+ *
+ * 既定実行セットは structure/drift/typecheck + custom。build/lint/test は --checks で明示指定。
+ */
+
+import * as fs from "fs";
+import * as path from "path";
+import { spawnSync } from "child_process";
+import { loadConfig } from "../config";
+import { detectDrift, DriftFinding } from "../project/drift";
+import { saveLastVerifyState } from "../project/state";
+import { ProjectViolation, validateProject } from "../project/validation";
+import { CustomVerifyCheck } from "../../types";
+import { detectFromProject, getCommands } from "../../utils/package-manager";
+
+export type VerifyCheckStatus = "pass" | "fail" | "skip" | "error";
+
+export interface VerifyCheckEvidence {
+  command?: string;
+  exitCode?: number;
+  violations?: ProjectViolation[];
+  findings?: DriftFinding[];
+  logTail?: string[];
+}
+
+export interface VerifyCheckResult {
+  id: string;
+  title: string;
+  status: VerifyCheckStatus;
+  durationMs: number;
+  fixable: boolean;
+  evidence: VerifyCheckEvidence;
+  suggestedActions: string[];
+}
+
+export interface VerifySummary {
+  passed: number;
+  failed: number;
+  skipped: number;
+  errors: number;
+  /** true = すべてのチェックが pass または skip */
+  done: boolean;
+}
+
+export interface VerifyResult {
+  checks: VerifyCheckResult[];
+  summary: VerifySummary;
+  verifiedAt: string;
+}
+
+export const AVAILABLE_VERIFY_CHECKS = ["structure", "drift", "typecheck", "build", "lint", "test"] as const;
+export type VerifyCheckId = (typeof AVAILABLE_VERIFY_CHECKS)[number];
+
+/** 既定で実行される built-in チェック。build/lint/test は明示指定時のみ。 */
+export const DEFAULT_VERIFY_CHECKS = ["structure", "drift", "typecheck"] as const;
+
+async function runStructureCheck(projectRoot: string): Promise<VerifyCheckResult> {
+  const startedAt = Date.now();
+  try {
+    const result = await validateProject(projectRoot);
+    const errors = result.violations.filter((violation) => violation.severity === "error");
+    return {
+      id: "structure",
+      title: "Project structure conventions",
+      status: errors.length === 0 ? "pass" : "fail",
+      durationMs: Date.now() - startedAt,
+      fixable: true,
+      evidence: { violations: result.violations },
+      suggestedActions:
+        errors.length === 0
+          ? []
+          : errors.map((violation) => violation.suggestedFix ?? violation.message),
+    };
+  } catch (error) {
+    return {
+      id: "structure",
+      title: "Project structure conventions",
+      status: "error",
+      durationMs: Date.now() - startedAt,
+      fixable: false,
+      evidence: { logTail: [error instanceof Error ? error.message : String(error)] },
+      suggestedActions: ["Run this command inside a SwallowKit project root."],
+    };
+  }
+}
+
+async function runDriftCheck(projectRoot: string): Promise<VerifyCheckResult> {
+  const startedAt = Date.now();
+  try {
+    const result = await detectDrift(projectRoot);
+    const errors = result.findings.filter((finding) => finding.severity === "error");
+    return {
+      id: "drift",
+      title: "Generated artifact drift",
+      status: errors.length === 0 ? "pass" : "fail",
+      durationMs: Date.now() - startedAt,
+      fixable: true,
+      evidence: { findings: result.findings },
+      suggestedActions: errors.map((finding) => finding.repairAction),
+    };
+  } catch (error) {
+    return {
+      id: "drift",
+      title: "Generated artifact drift",
+      status: "error",
+      durationMs: Date.now() - startedAt,
+      fixable: false,
+      evidence: { logTail: [error instanceof Error ? error.message : String(error)] },
+      suggestedActions: [],
+    };
+  }
+}
+
+function tailLines(text: string, count: number): string[] {
+  return text
+    .split(/\r?\n/)
+    .filter((line) => line.trim().length > 0)
+    .slice(-count);
+}
+
+interface CommandCheckSpec {
+  id: string;
+  title: string;
+  command: string;
+  args: string[];
+  timeoutMs?: number;
+  failAction: string;
+}
+
+function runCommandCheck(projectRoot: string, spec: CommandCheckSpec): VerifyCheckResult {
+  const startedAt = Date.now();
+  const commandLabel = [spec.command, ...spec.args].join(" ").trim();
+  try {
+    const result = spawnSync(spec.command, spec.args, {
+      cwd: projectRoot,
+      shell: true,
+      encoding: "utf-8",
+      timeout: spec.timeoutMs ?? 5 * 60 * 1000,
+    });
+
+    const output = `${result.stdout ?? ""}\n${result.stderr ?? ""}`;
+    const exitCode = typeof result.status === "number" ? result.status : -1;
+
+    if (result.error) {
+      return {
+        id: spec.id,
+        title: spec.title,
+        status: "error",
+        durationMs: Date.now() - startedAt,
+        fixable: false,
+        evidence: { command: commandLabel, logTail: [result.error.message] },
+        suggestedActions: [`Ensure "${commandLabel}" can run in this project.`],
+      };
+    }
+
+    return {
+      id: spec.id,
+      title: spec.title,
+      status: exitCode === 0 ? "pass" : "fail",
+      durationMs: Date.now() - startedAt,
+      fixable: true,
+      evidence: {
+        command: commandLabel,
+        exitCode,
+        logTail: tailLines(output, 50),
+      },
+      suggestedActions: exitCode === 0 ? [] : [spec.failAction],
+    };
+  } catch (error) {
+    return {
+      id: spec.id,
+      title: spec.title,
+      status: "error",
+      durationMs: Date.now() - startedAt,
+      fixable: false,
+      evidence: { command: commandLabel, logTail: [error instanceof Error ? error.message : String(error)] },
+      suggestedActions: [],
+    };
+  }
+}
+
+function readPackageScripts(projectRoot: string): Record<string, string> {
+  const packageJsonPath = path.join(projectRoot, "package.json");
+  if (!fs.existsSync(packageJsonPath)) return {};
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8")) as { scripts?: Record<string, string> };
+    return pkg.scripts ?? {};
+  } catch {
+    return {};
+  }
+}
+
+function runTypecheckCheck(projectRoot: string): VerifyCheckResult {
+  const startedAt = Date.now();
+
+  if (!fs.existsSync(path.join(projectRoot, "tsconfig.json"))) {
+    return {
+      id: "typecheck",
+      title: "TypeScript type check",
+      status: "skip",
+      durationMs: Date.now() - startedAt,
+      fixable: false,
+      evidence: { logTail: ["tsconfig.json not found; skipping typecheck."] },
+      suggestedActions: [],
+    };
+  }
+
+  const scripts = readPackageScripts(projectRoot);
+  let command: string;
+  let args: string[];
+  if (typeof scripts.typecheck === "string") {
+    const pm = detectFromProject(projectRoot);
+    command = getCommands(pm).name;
+    args = ["run", "typecheck"];
+  } else {
+    command = "npx";
+    args = ["tsc", "--noEmit"];
+  }
+
+  return runCommandCheck(projectRoot, {
+    id: "typecheck",
+    title: "TypeScript type check",
+    command,
+    args,
+    failAction: "Fix the TypeScript errors listed in evidence.logTail, then re-run verify.",
+  });
+}
+
+const SCRIPT_CHECK_TITLES: Record<string, string> = {
+  build: "Project build",
+  lint: "Lint",
+  test: "Test suite",
+};
+
+function runScriptCheck(projectRoot: string, scriptName: "build" | "lint" | "test"): VerifyCheckResult {
+  const startedAt = Date.now();
+  const scripts = readPackageScripts(projectRoot);
+  const title = SCRIPT_CHECK_TITLES[scriptName];
+
+  if (typeof scripts[scriptName] !== "string") {
+    return {
+      id: scriptName,
+      title,
+      status: "skip",
+      durationMs: Date.now() - startedAt,
+      fixable: false,
+      evidence: { logTail: [`No "${scriptName}" script in package.json; skipping.`] },
+      suggestedActions: [],
+    };
+  }
+
+  const pm = detectFromProject(projectRoot);
+  return runCommandCheck(projectRoot, {
+    id: scriptName,
+    title,
+    command: getCommands(pm).name,
+    args: ["run", scriptName],
+    timeoutMs: 10 * 60 * 1000,
+    failAction: `Fix the ${scriptName} failures listed in evidence.logTail, then re-run verify.`,
+  });
+}
+
+const CUSTOM_CHECK_ID = /^[a-z][a-z0-9-]*$/;
+
+/** swallowkit.config の verify.checks を projectRoot 基準で静かに読み込む。 */
+export function loadCustomVerifyChecks(projectRoot: string): CustomVerifyCheck[] {
+  const configNames = ["swallowkit.config.json", "swallowkit.config.js", ".swallowkitrc.json"];
+  for (const name of configNames) {
+    const configPath = path.join(projectRoot, name);
+    if (!fs.existsSync(configPath)) continue;
+    try {
+      const checks = loadConfig(configPath, false, true).verify?.checks ?? [];
+      return checks.filter(
+        (check) =>
+          typeof check?.id === "string" &&
+          CUSTOM_CHECK_ID.test(check.id) &&
+          !(AVAILABLE_VERIFY_CHECKS as readonly string[]).includes(check.id) &&
+          typeof check.command === "string" &&
+          check.command.trim().length > 0
+      );
+    } catch {
+      return [];
+    }
+  }
+  return [];
+}
+
+function runCustomCheck(projectRoot: string, check: CustomVerifyCheck): VerifyCheckResult {
+  return runCommandCheck(projectRoot, {
+    id: check.id,
+    title: check.title ?? `Custom check: ${check.id}`,
+    command: check.command,
+    args: [],
+    timeoutMs: check.timeoutMs,
+    failAction: `Fix the failures reported by "${check.command}", then re-run verify.`,
+  });
+}
+
+export async function runVerify(
+  checkIds?: string[],
+  projectRoot: string = process.cwd()
+): Promise<VerifyResult> {
+  const customChecks = loadCustomVerifyChecks(projectRoot);
+  const customIds = customChecks.map((check) => check.id);
+  const availableIds = [...AVAILABLE_VERIFY_CHECKS, ...customIds];
+
+  const requested = (checkIds && checkIds.length > 0
+    ? checkIds
+    : [...DEFAULT_VERIFY_CHECKS, ...customIds]
+  ).map((id) => id.trim()).filter(Boolean);
+
+  const unknown = requested.filter((id) => !availableIds.includes(id));
+  if (unknown.length > 0) {
+    throw new Error(
+      `Unknown verify check(s): ${unknown.join(", ")}. Available checks: ${availableIds.join(", ")}`
+    );
+  }
+
+  const checks: VerifyCheckResult[] = [];
+  for (const id of requested) {
+    if (id === "structure") {
+      checks.push(await runStructureCheck(projectRoot));
+    } else if (id === "drift") {
+      checks.push(await runDriftCheck(projectRoot));
+    } else if (id === "typecheck") {
+      checks.push(runTypecheckCheck(projectRoot));
+    } else if (id === "build" || id === "lint" || id === "test") {
+      checks.push(runScriptCheck(projectRoot, id));
+    } else {
+      const custom = customChecks.find((check) => check.id === id);
+      if (custom) checks.push(runCustomCheck(projectRoot, custom));
+    }
+  }
+
+  const summary: VerifySummary = {
+    passed: checks.filter((check) => check.status === "pass").length,
+    failed: checks.filter((check) => check.status === "fail").length,
+    skipped: checks.filter((check) => check.status === "skip").length,
+    errors: checks.filter((check) => check.status === "error").length,
+    done: checks.every((check) => check.status === "pass" || check.status === "skip"),
+  };
+
+  const result: VerifyResult = {
+    checks,
+    summary,
+    verifiedAt: new Date().toISOString(),
+  };
+
+  saveLastVerifyState(result, projectRoot);
+  return result;
+}
+
+export interface FailureExplanation {
+  checkId: string;
+  title: string;
+  status: VerifyCheckStatus;
+  verifiedAt: string;
+  evidence: VerifyCheckEvidence;
+  suggestedActions: string[];
+}
+
+export function explainVerifyFailure(
+  lastVerify: VerifyResult,
+  checkId?: string
+): FailureExplanation[] {
+  const targets = checkId
+    ? lastVerify.checks.filter((check) => check.id === checkId)
+    : lastVerify.checks.filter((check) => check.status === "fail" || check.status === "error");
+
+  if (checkId && targets.length === 0) {
+    throw new Error(
+      `Unknown check "${checkId}" in the last verify result. Available: ${lastVerify.checks.map((check) => check.id).join(", ")}`
+    );
+  }
+
+  return targets.map((check) => ({
+    checkId: check.id,
+    title: check.title,
+    status: check.status,
+    verifiedAt: lastVerify.verifiedAt,
+    evidence: check.evidence,
+    suggestedActions: check.suggestedActions,
+  }));
+}

package/src/machine/contracts.ts

@@ -1,12 +1,28 @@
+export type MachineOperationStatus =
+  | "complete"
+  | "in-progress"
+  | "blocked"
+  | "requires-human"
+  | "unsafe"
+  | "failed";
+
+export interface MachineNextAction {
+  command: string;
+  description: string;
+}
+
 export interface MachineSuccessResponse<TData> {
   ok: true;
   command: string;
+  status?: MachineOperationStatus;
+  nextActions?: MachineNextAction[];
   data: TData;
 }
 
 export interface MachineErrorResponse {
   ok: false;
   command: string;
+  status?: MachineOperationStatus;
   error: {
     code: string;
     message: string;

package/src/machine/errors.ts

@@ -1,13 +1,24 @@
+import type { MachineOperationStatus } from "./contracts";
+
 export class MachineCommandError extends Error {
   readonly code: string;
   readonly details?: unknown;
+  readonly status?: MachineOperationStatus;
 
-  constructor(code: string, message: string, details?: unknown) {
+  constructor(code: string, message: string, details?: unknown, status?: MachineOperationStatus) {
     super(message);
     this.name = "MachineCommandError";
     this.code = code;
     this.details = details;
+    this.status = status;
+  }
+}
+
+export function resolveMachineErrorStatus(error: unknown): MachineOperationStatus {
+  if (error instanceof MachineCommandError && error.status) {
+    return error.status;
   }
+  return "failed";
 }
 
 export function toMachineError(error: unknown): { code: string; message: string; details?: unknown } {