swallowkit 1.0.0 → 1.0.2

package/src/__tests__/plan-apply.test.ts

@@ -9,6 +9,7 @@ jest.mock("child_process", () => {
   const actual = jest.requireActual<typeof import("child_process")>("child_process");
   return {
     ...actual,
+    execFileSync: jest.fn(actual.execFileSync),
     spawn: jest.fn(),
     spawnSync: jest.fn(),
   };
@@ -143,6 +144,8 @@ describe("plan / apply / drift / verify machine commands", () => {
   beforeEach(() => {
     tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-agent-"));
     process.chdir(tempDir);
+    const actual = jest.requireActual<typeof import("child_process")>("child_process");
+    (childProcess.execFileSync as unknown as ReturnType<typeof jest.fn>).mockImplementation(actual.execFileSync);
   });
 
   afterEach(() => {
@@ -161,6 +164,16 @@ describe("plan / apply / drift / verify machine commands", () => {
     expect(response.status).toBe("complete");
     expect(response.data.planId).toMatch(/^[0-9a-f]{12}$/);
     expect(response.data.requiresApproval).toBe(false);
+    expect(response.data.schemaAnalysis).toMatchObject({
+      parserMode: "static-ast",
+      semanticFingerprint: expect.stringMatching(/^[0-9a-f]{64}$/),
+      canonicalModel: expect.objectContaining({
+        name: "Todo",
+        fields: expect.arrayContaining([expect.objectContaining({ name: "id", type: "string" })]),
+      }),
+      warnings: [],
+    });
+    expect(response.data.diagnostics).toEqual([]);
     expect(response.data.operations).toEqual(
       expect.arrayContaining([
         expect.objectContaining({ path: "app/api/todo/route.ts", action: "create", ownership: "managed" }),
@@ -309,6 +322,55 @@ describe("plan / apply / drift / verify machine commands", () => {
     }
   );
 
+  it("preserves enum and literal semantics in UI, OpenAPI, and C# artifacts", async () => {
+    createNativeBackendFixture(tempDir, "csharp");
+    writeFile(
+      path.join(tempDir, "shared", "models", "learning-question.ts"),
+      `import { z } from 'zod/v4';
+export const LearningQuestion = z.object({
+  id: z.string(),
+  kind: z.enum(['grammar', 'vocabulary']),
+  level: z.literal('5'),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+export type LearningQuestion = z.infer<typeof LearningQuestion>;
+`
+    );
+    const restoreCodegenMocks = mockSuccessfulNativeCodegen();
+
+    try {
+      const applied = await runMachine(machineArgs("apply", "scaffold", "learning-question"));
+      expect(applied.response).toEqual(expect.objectContaining({ ok: true, status: "complete" }));
+
+      const form = fs.readFileSync(
+        path.join(tempDir, "app", "learning-question", "_components", "LearningQuestionForm.tsx"),
+        "utf-8"
+      );
+      expect(form).toContain('<select');
+      expect(form).toContain('<option value="grammar">grammar</option>');
+      expect(form).toContain('<option value="5">5</option>');
+
+      const openApi = JSON.parse(
+        fs.readFileSync(path.join(tempDir, "functions", "openapi", "learning-question.openapi.json"), "utf-8")
+      );
+      const properties = openApi.components.schemas.LearningQuestion.properties;
+      expect(properties.kind.enum).toEqual(["grammar", "vocabulary"]);
+      expect(properties.level.enum).toEqual(["5"]);
+
+      const csharp = fs.readFileSync(
+        path.join(tempDir, "functions", "generated", "csharp-models", "src", "SwallowKitBackendModels", "Model", "LearningQuestion.cs"),
+        "utf-8"
+      );
+      expect(csharp).toContain("public enum KindEnum");
+      expect(csharp).toContain("public enum LevelEnum");
+      expect(csharp).not.toContain("Dictionary<string, object> Kind");
+      expect(csharp).not.toContain("Dictionary<string, object> Level");
+    } finally {
+      restoreCodegenMocks();
+    }
+  });
+
   it("leaves the project untouched when the native toolchain validation fails on apply", async () => {
     createNativeBackendFixture(tempDir, "csharp");
     const spawnSyncMock = childProcess.spawnSync as unknown as any;
@@ -356,6 +418,96 @@ describe("plan / apply / drift / verify machine commands", () => {
     expect(fs.existsSync(path.join(tempDir, "app"))).toBe(false);
   });
 
+  it("blocks planning without writing artifacts when dynamic schema evaluation cannot start", async () => {
+    createProjectFixture(tempDir);
+    writeFile(
+      path.join(tempDir, "shared", "models", "computed.ts"),
+      `import { z } from 'zod/v4';
+const field = z.string();
+export const Computed = z.object({ id: field.transform(value => value) });
+`
+    );
+    const unavailable = Object.assign(new Error("spawn EPERM"), { code: "EPERM" });
+    (childProcess.execFileSync as unknown as ReturnType<typeof jest.fn>).mockImplementation(() => { throw unavailable; });
+
+    const { response, exitCode } = await runMachine(machineArgs("plan", "scaffold", "computed", "--api-only"));
+
+    expect(exitCode).toBe(1);
+    expect(response).toMatchObject({
+      ok: false,
+      status: "blocked",
+      error: {
+        code: "schema-evaluation-unavailable",
+        details: expect.objectContaining({ command: process.execPath, reason: "EPERM" }),
+      },
+    });
+    expect(fs.existsSync(path.join(tempDir, "app"))).toBe(false);
+    expect(fs.existsSync(path.join(tempDir, ".swallowkit", "artifacts.json"))).toBe(false);
+  });
+
+  it("blocks apply when saved parser metadata differs from current analysis", async () => {
+    createProjectFixture(tempDir);
+    const plan = await runMachine(machineArgs("plan", "scaffold", "todo", "--api-only"));
+    const planPath = path.join(tempDir, ".swallowkit", "state", "plans", `${plan.response.data.planId}.json`);
+    const savedPlan = JSON.parse(fs.readFileSync(planPath, "utf-8"));
+    savedPlan.schemaAnalysis.parserMode = "dynamic";
+    fs.writeFileSync(planPath, JSON.stringify(savedPlan, null, 2));
+
+    const { response, exitCode } = await runMachine(
+      machineArgs("apply", "scaffold", "--plan", plan.response.data.planId)
+    );
+
+    expect(exitCode).toBe(1);
+    expect(response).toMatchObject({ ok: false, status: "blocked", error: { code: "schema-analysis-mismatch" } });
+    expect(fs.existsSync(path.join(tempDir, "app"))).toBe(false);
+    expect(fs.existsSync(path.join(tempDir, ".swallowkit", "artifacts.json"))).toBe(false);
+  });
+
+  it("blocks apply without writes when dynamic evaluation becomes unavailable after planning", async () => {
+    createProjectFixture(tempDir);
+    writeFile(
+      path.join(tempDir, "shared", "models", "computed.ts"),
+      `import { z } from 'zod/v4';
+const baseFields = { id: z.string(), kind: z.enum(['grammar', 'vocabulary']) };
+export const Computed = z.object({ ...baseFields, level: z.literal('5') });
+`
+    );
+    const plan = await runMachine(machineArgs("plan", "scaffold", "computed", "--api-only"));
+    expect(plan.response).toMatchObject({
+      ok: true,
+      data: { schemaAnalysis: { parserMode: "dynamic" } },
+    });
+
+    const unavailable = Object.assign(new Error("spawn EPERM"), { code: "EPERM" });
+    (childProcess.execFileSync as unknown as ReturnType<typeof jest.fn>).mockImplementation(() => { throw unavailable; });
+    const applied = await runMachine(machineArgs("apply", "scaffold", "--plan", plan.response.data.planId));
+
+    expect(applied.exitCode).toBe(1);
+    expect(applied.response).toMatchObject({
+      ok: false,
+      status: "blocked",
+      error: { code: "schema-evaluation-unavailable" },
+    });
+    expect(fs.existsSync(path.join(tempDir, "app"))).toBe(false);
+    expect(fs.existsSync(path.join(tempDir, ".swallowkit", "artifacts.json"))).toBe(false);
+  });
+
+  it("does not report schema drift for an unrelated exported response contract", async () => {
+    createProjectFixture(tempDir);
+    await runMachine(machineArgs("apply", "scaffold", "todo", "--api-only"));
+    fs.appendFileSync(
+      path.join(tempDir, "shared", "models", "todo.ts"),
+      "\nexport const TodoRevealFeedback = z.object({ message: z.string() });\n"
+    );
+
+    const drift = await runMachine(machineArgs("inspect", "drift"));
+
+    expect(drift.response.ok).toBe(true);
+    expect(
+      drift.response.data.findings.filter((finding: { kind: string }) => finding.kind === "schema-drift")
+    ).toEqual([]);
+  });
+
   it("rejects a native backend plan when a nested model changes after planning", async () => {
     createNativeBackendFixture(tempDir, "csharp");
     writeFile(path.join(tempDir, "shared", "models", "member.ts"), createModelSource("Member"));

package/src/cli/commands/scaffold.ts

@@ -8,6 +8,7 @@ import * as path from "path";
 import { spawnSync } from "child_process";
 import { getBackendLanguage, getConnectorDefinition, getAuthConfig, getFullConfig, getNormalizedAuthConfig, ensureSwallowKitProject, normalizeAuthConfig, validateConfig } from "../../core/config";
 import { ModelInfo, parseModelFile, toKebabCase, toPascalCase, toCamelCase } from "../../core/scaffold/model-parser";
+import { MachineCommandError } from "../../machine/errors";
 import {
   generateCSharpAzureFunctionsCRUD,
   generateCompactAzureFunctionsCRUD,
@@ -47,7 +48,7 @@ import { generateBFFCallFunctionWithAuth, generateBFFCallFunctionWithMultipleAut
 import {
   FileOperationSession,
   getActiveFileSession,
-  hashFileIfExists,
+  SchemaAnalysisSnapshot,
 } from "../../core/operations/file-session";
 import { recordSessionOperations } from "../../core/project/artifacts";
 
@@ -58,6 +59,7 @@ interface ScaffoldOptions {
   functionsDir?: string; // Azure Functions のディレクトリ（デフォルト: "functions"）
   apiDir?: string; // Next.js API routes のディレクトリ（デフォルト: "app/api"）
   apiOnly?: boolean; // true の場合、UI を生成しない（デフォルト: false）
+  expectedSchemaAnalysis?: SchemaAnalysisSnapshot;
 }
 
 function getMachineAwareStdio(): "inherit" | "pipe" {
@@ -100,6 +102,31 @@ export async function scaffoldCommand(options: ScaffoldOptions) {
     // 2. Parse model file
     console.log("🔍 Parsing model file...");
     const modelInfo = await parseModelFile(modelPath);
+    const schemaAnalysis: SchemaAnalysisSnapshot = {
+      parserMode: modelInfo.parserMode,
+      semanticFingerprint: modelInfo.semanticFingerprint,
+      canonicalModel: {
+        name: modelInfo.name,
+        schemaName: modelInfo.schemaName,
+        fields: modelInfo.fields,
+        nestedSchemaRefs: modelInfo.nestedSchemaRefs,
+        partitionKey: modelInfo.partitionKey,
+        connectorConfig: modelInfo.connectorConfig,
+        authPolicy: modelInfo.authPolicy,
+      },
+      warnings: modelInfo.parserWarnings,
+    };
+    if (options.expectedSchemaAnalysis &&
+        (options.expectedSchemaAnalysis.parserMode !== schemaAnalysis.parserMode ||
+         options.expectedSchemaAnalysis.semanticFingerprint !== schemaAnalysis.semanticFingerprint)) {
+      throw new MachineCommandError(
+        "schema-analysis-mismatch",
+        "Schema analysis changed between plan and apply; no artifacts were written.",
+        { expected: options.expectedSchemaAnalysis, actual: schemaAnalysis, nextAction: "Re-run plan scaffold in the same environment, then apply the new plan." },
+        "blocked"
+      );
+    }
+    session.setSchemaAnalysis(schemaAnalysis);
     console.log(`✅ Model parsed: ${modelInfo.name} (${modelInfo.schemaName})`);
 
     const backendLanguage = getBackendLanguage();
@@ -199,7 +226,7 @@ export async function scaffoldCommand(options: ScaffoldOptions) {
 
     if (session.mode === "commit") {
       recordSessionOperations(session.operations, {
-        schemaHash: hashFileIfExists(modelPath) ?? undefined,
+        schemaHash: modelInfo.semanticFingerprint,
         sourceModel: modelInfo.name,
       });
       await syncProjectManifest();
@@ -223,6 +250,7 @@ export async function scaffoldCommand(options: ScaffoldOptions) {
     );
     console.log(`  ${options.apiOnly ? (backendLanguage === "typescript" ? "4" : "5") : (backendLanguage === "typescript" ? "6" : "7")}. Run '${getCommands(detectFromProject()).exec} swallowkit dev' to test the generated code`);
   } catch (error: any) {
+    if (error instanceof MachineCommandError) throw error;
     console.error("\n❌ Scaffold failed:", error.message);
     process.exit(1);
   }

package/src/core/operations/file-session.ts

@@ -43,6 +43,13 @@ export interface RecordedFileOperation {
   newHash: string | null;
 }
 
+export interface SchemaAnalysisSnapshot {
+  parserMode: string;
+  semanticFingerprint: string;
+  canonicalModel: unknown;
+  warnings: string[];
+}
+
 export function normalizeContentForHash(content: string): string {
   return content.replace(/\r\n/g, "\n");
 }
@@ -78,6 +85,7 @@ export class FileOperationSession {
   private readonly inputFingerprintsByPath = new Map<string, string | null>();
   /** overlay: absolute normalized path -> content (null = deleted in session) */
   private readonly overlay = new Map<string, string | null>();
+  private schemaAnalysisValue: SchemaAnalysisSnapshot | null = null;
 
   constructor(mode: FileSessionMode, rootDirectory: string = process.cwd()) {
     this.mode = mode;
@@ -94,6 +102,14 @@ export class FileOperationSession {
     );
   }
 
+  get schemaAnalysis(): SchemaAnalysisSnapshot | null {
+    return this.schemaAnalysisValue;
+  }
+
+  setSchemaAnalysis(analysis: SchemaAnalysisSnapshot): void {
+    this.schemaAnalysisValue = analysis;
+  }
+
   addWarning(message: string): void {
     if (!this.warnings.includes(message)) {
       this.warnings.push(message);

package/src/core/operations/scaffold-apply.ts

@@ -75,6 +75,23 @@ export async function applyScaffoldOperation(options: ApplyScaffoldOptions): Pro
   // 常に最新状態で collect し、競合を検出する(plan 指定時も現況を再確認)
   const currentPlan = await planScaffoldOperation(effectiveOptions);
 
+  if (basePlan &&
+      (!basePlan.schemaAnalysis ||
+       basePlan.schemaAnalysis.parserMode !== currentPlan.schemaAnalysis.parserMode ||
+       basePlan.schemaAnalysis.semanticFingerprint !== currentPlan.schemaAnalysis.semanticFingerprint)) {
+    throw new MachineCommandError(
+      "schema-analysis-mismatch",
+      `Plan "${basePlan.planId}" used different schema analysis metadata; no artifacts were written.`,
+      {
+        planId: basePlan.planId,
+        expected: basePlan.schemaAnalysis,
+        actual: currentPlan.schemaAnalysis,
+        nextAction: "Re-run plan scaffold in the same environment, then apply the new plan.",
+      },
+      "blocked"
+    );
+  }
+
   if (currentPlan.requiresApproval && !options.approve) {
     // 承認待ちの plan は残し、参照できるようにする
     throw new MachineCommandError(
@@ -88,7 +105,10 @@ export async function applyScaffoldOperation(options: ApplyScaffoldOptions): Pro
     );
   }
 
-  const result = await runMachineScaffoldOperation(effectiveOptions);
+  const result = await runMachineScaffoldOperation({
+    ...effectiveOptions,
+    expectedSchemaAnalysis: currentPlan.schemaAnalysis,
+  });
 
   // 適用済み plan の状態を破棄
   deletePlanState(currentPlan.planId, projectRoot);

package/src/core/operations/scaffold-machine.ts

@@ -1,4 +1,5 @@
 import { scaffoldCommand } from "../../cli/commands/scaffold";
+import { SchemaAnalysisSnapshot } from "./file-session";
 import {
   captureConsoleMessagesWithError,
   deriveCapturedErrorMessage,
@@ -12,6 +13,7 @@ export interface MachineScaffoldOperationOptions {
   functionsDir?: string;
   apiDir?: string;
   apiOnly?: boolean;
+  expectedSchemaAnalysis?: SchemaAnalysisSnapshot;
 }
 
 export interface MachineScaffoldOperationResult {

package/src/core/operations/scaffold-plan.ts

@@ -12,6 +12,7 @@ import { savePlanState } from "../project/state";
 import {
   ArtifactOwnership,
   FileOperationSession,
+  SchemaAnalysisSnapshot,
   hashFileIfExists,
   runWithFileSession,
 } from "./file-session";
@@ -52,6 +53,8 @@ export interface ScaffoldPlanData {
   swallowkitVersion: string;
   operations: ScaffoldPlanOperation[];
   warnings: string[];
+  diagnostics: string[];
+  schemaAnalysis: SchemaAnalysisSnapshot;
   conflicts: ScaffoldPlanOperation[];
   requiresApproval: boolean;
   /** project-relative path -> pre-plan content hash (null = did not exist). Used for stale-plan detection. */
@@ -112,6 +115,10 @@ export async function planScaffoldOperation(options: PlanScaffoldOptions): Promi
   const operations: ScaffoldPlanOperation[] = [];
   const fingerprints: Record<string, string | null> = { ...session.inputFingerprints };
   const warnings = [...session.warnings];
+  const schemaAnalysis = session.schemaAnalysis;
+  if (!schemaAnalysis) {
+    throw new Error("Scaffold completed without recording schema analysis metadata.");
+  }
 
   for (const op of session.operations) {
     fingerprints[op.path] = op.previousHash;
@@ -173,6 +180,7 @@ export async function planScaffoldOperation(options: PlanScaffoldOptions): Promi
         options: { functionsDir: options.functionsDir, apiDir: options.apiDir, apiOnly: options.apiOnly },
         operations: operations.map((op) => ({ path: op.path, action: op.action })),
         fingerprints,
+        schemaAnalysis,
       })
     )
     .digest("hex")
@@ -191,6 +199,8 @@ export async function planScaffoldOperation(options: PlanScaffoldOptions): Promi
     swallowkitVersion: getSwallowKitVersion(),
     operations,
     warnings,
+    diagnostics: schemaAnalysis.warnings.map((warning) => `warning:${warning}`),
+    schemaAnalysis,
     conflicts,
     requiresApproval: conflicts.length > 0,
     fingerprints,

package/src/core/project/drift.ts

@@ -12,6 +12,7 @@
 import * as path from "path";
 import { getSwallowKitVersion } from "../../version";
 import { hashFileIfExists } from "../operations/file-session";
+import { parseModelFile } from "../scaffold/model-parser";
 import { ArtifactRecord, loadArtifactLedger } from "./artifacts";
 import { buildProjectManifest, readProjectManifest, SWALLOWKIT_MANIFEST_PATH } from "./manifest";
 
@@ -84,23 +85,22 @@ function detectArtifactDrift(
   }
 }
 
-function detectSchemaDrift(
+async function detectSchemaDrift(
   records: ArtifactRecord[],
   projectRoot: string,
   findings: DriftFinding[]
-): void {
-  const bySchema = new Map<string, { schemaHash: string; sourceModel?: string; paths: string[] }>();
+): Promise<void> {
+  const byModel = new Map<string, ArtifactRecord[]>();
 
   for (const record of records) {
     if (!record.schemaHash || !record.sourceModel) continue;
-    const key = record.sourceModel;
-    const entry = bySchema.get(key) ?? { schemaHash: record.schemaHash, sourceModel: record.sourceModel, paths: [] };
-    entry.schemaHash = record.schemaHash;
-    entry.paths.push(record.path);
-    bySchema.set(key, entry);
+    if (record.ownership === "extension-point" || record.ownership === "user-owned") continue;
+    const modelRecords = byModel.get(record.sourceModel) ?? [];
+    modelRecords.push(record);
+    byModel.set(record.sourceModel, modelRecords);
   }
 
-  for (const [modelName, entry] of bySchema) {
+  for (const [modelName, modelRecords] of byModel) {
     // モデルファイルは shared/models/<kebab>.ts 規約
     const kebab = modelName
       .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
@@ -111,15 +111,20 @@ function detectSchemaDrift(
     if (currentSchemaHash === null) {
       continue; // モデルファイルが見つからない場合は manifest-drift 側で検出される
     }
-    if (currentSchemaHash !== entry.schemaHash) {
+    const semanticSchemaHash = (await parseModelFile(modelPath)).semanticFingerprint;
+    const staleRecords = modelRecords.filter(
+      (record) => record.schemaHash !== semanticSchemaHash && record.schemaHash !== currentSchemaHash
+    );
+    if (staleRecords.length > 0) {
+      const staleSchemaHashes = [...new Set(staleRecords.map((record) => record.schemaHash!))].sort();
       findings.push({
         kind: "schema-drift",
         severity: "warning",
-        message: `Model "${modelName}" changed after its artifacts were generated (${entry.paths.length} artifact(s) are stale).`,
+        message: `Model "${modelName}" changed after its artifacts were generated (${staleRecords.length} artifact(s) are stale).`,
         path: `shared/models/${kebab}.ts`,
         entity: modelName,
-        expected: entry.schemaHash,
-        actual: currentSchemaHash,
+        expected: staleSchemaHashes.join(", "),
+        actual: semanticSchemaHash,
         repairAction: `Run "swallowkit machine plan scaffold ${kebab}" then apply to regenerate artifacts for ${modelName}.`,
       });
     }
@@ -181,7 +186,7 @@ export async function detectDrift(projectRoot: string = process.cwd()): Promise<
     for (const record of ledger.artifacts) {
       detectArtifactDrift(record, projectRoot, findings);
     }
-    detectSchemaDrift(ledger.artifacts, projectRoot, findings);
+    await detectSchemaDrift(ledger.artifacts, projectRoot, findings);
     detectGeneratorDrift(ledger.artifacts, findings);
   } else {
     findings.push({