swallowkit 1.0.0-beta.55 → 1.0.0-beta.57

package/src/cli/index.ts

@@ -8,6 +8,10 @@ import { initCommand, devCommand, devSeedsCommand, scaffoldCommand, createModelC
 import { provisionCommand } from "./commands/provision";
 import { addConnectorCommand } from "./commands/add-connector";
 import { addAuthCommand } from "./commands/add-auth";
+import { planScaffoldOperation } from "../core/operations/scaffold-plan";
+import { inspectArtifacts } from "../core/project/artifacts";
+import { detectDrift } from "../core/project/drift";
+import { runVerify } from "../core/verify";
 import { isMachineCommand, runMachineCli } from "../machine";
 
 const packageJsonPath = path.resolve(__dirname, "../../package.json");
@@ -147,8 +151,19 @@ export function createProgram(devCommandOverride: Command = devCommand): Command
     .option("--functions-dir <dir>", "Azure Functions directory", "functions")
     .option("--api-dir <dir>", "Next.js API routes directory", "app/api")
     .option("--api-only", "Skip UI components; still update Functions, BFF routes, OpenAPI, and native schema assets", false)
-    .action((model, options) => {
-      scaffoldCommand({
+    .option("--dry-run", "Show planned file changes without writing anything", false)
+    .action(async (model, options) => {
+      if (options.dryRun) {
+        await runScaffoldDryRun({
+          model,
+          functionsDir: options.functionsDir,
+          apiDir: options.apiDir,
+          apiOnly: options.apiOnly,
+        });
+        return;
+      }
+
+      await scaffoldCommand({
         model,
         functionsDir: options.functionsDir,
         apiDir: options.apiDir,
@@ -181,9 +196,140 @@ export function createProgram(devCommandOverride: Command = devCommand): Command
       });
     });
 
+  program
+    .command("status")
+    .description("Show generated artifact status and drift against the current project state")
+    .option("--artifacts", "List all tracked artifacts with ownership", false)
+    .action(async (options) => {
+      await runStatusCommand({ artifacts: options.artifacts });
+    });
+
+  program
+    .command("verify")
+    .description("Run verification checks (structure, drift, typecheck)")
+    .option("--checks <ids>", "Comma-separated check ids to run (structure,drift,typecheck)")
+    .action(async (options) => {
+      await runVerifyCommand({ checks: options.checks });
+    });
+
   return program;
 }
 
+async function runScaffoldDryRun(options: { model: string; functionsDir?: string; apiDir?: string; apiOnly?: boolean }): Promise<void> {
+  console.log("🔍 Scaffold dry-run — no files will be written.\n");
+
+  const plan = await planScaffoldOperation(options);
+
+  const actionIcons: Record<string, string> = {
+    create: "➕",
+    update: "♻️ ",
+    overwrite: "⚠️ ",
+    append: "🔗",
+    delete: "🗑️ ",
+    skip: "⏭️ ",
+  };
+
+  for (const operation of plan.operations) {
+    if (operation.action === "skip") continue;
+    const icon = actionIcons[operation.action] ?? "•";
+    const conflictNote = operation.conflict ? ` (conflict: ${operation.conflictReason})` : "";
+    console.log(`  ${icon} ${operation.action.padEnd(9)} ${operation.path} [${operation.ownership}]${conflictNote}`);
+  }
+
+  const skipped = plan.operations.filter((operation) => operation.action === "skip").length;
+  if (skipped > 0) {
+    console.log(`  ⏭️  ${skipped} file(s) unchanged (skipped)`);
+  }
+
+  if (plan.warnings.length > 0) {
+    console.log("\n⚠️  Warnings:");
+    for (const warning of plan.warnings) {
+      console.log(`  - ${warning}`);
+    }
+  }
+
+  console.log(`\n📋 Plan ${plan.planId} saved.`);
+  if (plan.requiresApproval) {
+    console.log(`⚠️  ${plan.conflicts.length} file(s) were modified after generation and would be overwritten.`);
+    console.log(`   Review the conflicts, then run: swallowkit scaffold ${options.model} (or machine apply scaffold --plan ${plan.planId} --approve)`);
+  } else {
+    console.log(`   Run without --dry-run to apply: swallowkit scaffold ${options.model}`);
+  }
+}
+
+async function runStatusCommand(options: { artifacts?: boolean }): Promise<void> {
+  const inspection = inspectArtifacts();
+  const drift = await detectDrift();
+
+  console.log("📦 SwallowKit project status\n");
+
+  if (!inspection.ledgerFound) {
+    console.log("ℹ️  No artifact ledger (.swallowkit/artifacts.json) found yet.");
+    console.log("   Run scaffold once with this SwallowKit version to start tracking artifacts.\n");
+  } else {
+    const total = inspection.artifacts.length;
+    const missing = inspection.artifacts.filter((artifact) => !artifact.exists).length;
+    const modified = inspection.artifacts.filter((artifact) => artifact.modified).length;
+    console.log(`  Tracked artifacts: ${total}`);
+    console.log(`  Modified after generation: ${modified}`);
+    console.log(`  Missing: ${missing}\n`);
+
+    if (options.artifacts) {
+      for (const artifact of inspection.artifacts) {
+        const flags = [
+          artifact.modified ? "modified" : null,
+          !artifact.exists ? "missing" : null,
+        ].filter(Boolean);
+        const suffix = flags.length > 0 ? ` (${flags.join(", ")})` : "";
+        console.log(`  - ${artifact.path} [${artifact.ownership}]${suffix}`);
+      }
+      console.log("");
+    }
+  }
+
+  if (drift.findings.length === 0) {
+    console.log("✅ No drift detected.");
+    return;
+  }
+
+  console.log(`⚠️  Drift findings (${drift.findings.length}):`);
+  for (const finding of drift.findings) {
+    console.log(`  [${finding.severity}] ${finding.kind}: ${finding.message}`);
+    console.log(`     → ${finding.repairAction}`);
+  }
+}
+
+async function runVerifyCommand(options: { checks?: string }): Promise<void> {
+  console.log("🔎 Running verification checks...\n");
+
+  const result = await runVerify(options.checks ? options.checks.split(",") : undefined);
+
+  const statusIcons: Record<string, string> = {
+    pass: "✅",
+    fail: "❌",
+    skip: "⏭️ ",
+    error: "💥",
+  };
+
+  for (const check of result.checks) {
+    console.log(`  ${statusIcons[check.status]} ${check.id.padEnd(10)} ${check.title} (${check.durationMs}ms)`);
+    if (check.status === "fail" || check.status === "error") {
+      for (const action of check.suggestedActions) {
+        console.log(`     → ${action}`);
+      }
+    }
+  }
+
+  console.log(
+    `\n${result.summary.done ? "✅" : "❌"} ${result.summary.passed} passed, ${result.summary.failed} failed, ${result.summary.skipped} skipped, ${result.summary.errors} error(s)`
+  );
+
+  if (!result.summary.done) {
+    console.log('   Details: swallowkit machine explain failure');
+    process.exitCode = 1;
+  }
+}
+
 export async function runCli(argv: string[] = process.argv): Promise<void> {
   ensureUtf8ConsoleOnWindows();
   if (isMachineCommand(argv)) {

package/src/core/config.ts

@@ -37,7 +37,7 @@ const DEFAULT_CONFIG: SwallowKitConfig = {
 /**
  * 設定ファイルを読み込み
  */
-export function loadConfig(configPath?: string, throwOnError = false): SwallowKitConfig {
+export function loadConfig(configPath?: string, throwOnError = false, quiet = false): SwallowKitConfig {
   const defaultPaths = [
     "swallowkit.config.json",
     "swallowkit.config.js",
@@ -51,7 +51,7 @@ export function loadConfig(configPath?: string, throwOnError = false): SwallowKi
     
     if (fs.existsSync(fullPath)) {
       try {
-        console.log(`📋 設定ファイルを読み込み: ${filePath}`);
+        if (!quiet) console.log(`📋 設定ファイルを読み込み: ${filePath}`);
         
         if (filePath.endsWith(".json")) {
           const configData = fs.readFileSync(fullPath, "utf-8");
@@ -64,12 +64,12 @@ export function loadConfig(configPath?: string, throwOnError = false): SwallowKi
         }
       } catch (error) {
         if (throwOnError) throw error;
-        console.warn(`⚠️ 設定ファイルの読み込みに失敗: ${filePath}`, error);
+        if (!quiet) console.warn(`⚠️ 設定ファイルの読み込みに失敗: ${filePath}`, error);
       }
     }
   }
 
-  console.log("📋 デフォルト設定を使用");
+  if (!quiet) console.log("📋 デフォルト設定を使用");
   return DEFAULT_CONFIG;
 }
 
@@ -98,6 +98,7 @@ function mergeConfig(defaultConfig: SwallowKitConfig, userConfig: Partial<Swallo
     auth: userConfig.auth
       ? { ...defaultConfig.auth, ...userConfig.auth }
       : defaultConfig.auth,
+    verify: userConfig.verify ?? defaultConfig.verify,
   };
 }
 

package/src/core/operations/auth-operations.ts

@@ -0,0 +1,353 @@
+/**
+ * Plan / Apply Auth — add-auth を collect モードで実行して差分計画を作成し、
+ * 承認・鮮度チェックを経て実際に適用する。
+ */
+
+import * as crypto from "crypto";
+import * as path from "path";
+import { addAuthCommand } from "../../cli/commands/add-auth";
+import { MachineCommandError } from "../../machine/errors";
+import { getSwallowKitVersion } from "../../version";
+import { findArtifactRecord, loadArtifactLedger } from "../project/artifacts";
+import { deletePlanState, loadPlanState, savePlanState } from "../project/state";
+import {
+  ArtifactOwnership,
+  FileOperationSession,
+  hashFileIfExists,
+  runWithFileSession,
+} from "./file-session";
+import {
+  captureConsoleMessagesWithError,
+  deriveCapturedErrorMessage,
+  interceptProcessExit,
+  ProcessExitInterceptError,
+  trackFileMutations,
+} from "./runtime";
+
+export interface PlanAuthOptions {
+  provider: string;
+  scheme?: string;
+}
+
+export type AuthPlanAction = "create" | "update" | "overwrite" | "append" | "delete" | "skip";
+
+export interface AuthPlanOperation {
+  path: string;
+  action: AuthPlanAction;
+  ownership: ArtifactOwnership;
+  conflict: boolean;
+  conflictReason?: string;
+}
+
+export interface AuthPlanData {
+  planId: string;
+  planType: "auth";
+  provider: string;
+  scheme?: string;
+  createdAt: string;
+  swallowkitVersion: string;
+  operations: AuthPlanOperation[];
+  warnings: string[];
+  conflicts: AuthPlanOperation[];
+  requiresApproval: boolean;
+  /** project-relative path -> pre-plan content hash (null = did not exist). Used for stale-plan detection. */
+  fingerprints: Record<string, string | null>;
+}
+
+function deriveAuthErrorMessage(messages: { errors: string[]; warnings: string[]; logs: string[] }): string {
+  return deriveCapturedErrorMessage(messages, "Auth operation failed.");
+}
+
+/**
+ * add-auth を collect セッションで実行し、記録された操作を返す。ディスクには書き込まない。
+ */
+async function collectAuthOperations(options: PlanAuthOptions): Promise<FileOperationSession> {
+  const session = new FileOperationSession("collect");
+  const originalMachineOutput = process.env.SWALLOWKIT_MACHINE_OUTPUT;
+  process.env.SWALLOWKIT_MACHINE_OUTPUT = "1";
+
+  try {
+    const captured = await captureConsoleMessagesWithError(async () => {
+      await interceptProcessExit(async () => {
+        await runWithFileSession(session, async () => {
+          await addAuthCommand({ provider: options.provider, scheme: options.scheme });
+        });
+      });
+    });
+
+    if (captured.error) {
+      if (captured.error instanceof ProcessExitInterceptError) {
+        throw new Error(deriveAuthErrorMessage(captured.messages));
+      }
+      if (captured.error instanceof Error) {
+        throw captured.error;
+      }
+      throw new Error(deriveAuthErrorMessage(captured.messages));
+    }
+
+    return session;
+  } finally {
+    if (originalMachineOutput === undefined) {
+      delete process.env.SWALLOWKIT_MACHINE_OUTPUT;
+    } else {
+      process.env.SWALLOWKIT_MACHINE_OUTPUT = originalMachineOutput;
+    }
+  }
+}
+
+export async function planAuthOperation(options: PlanAuthOptions): Promise<AuthPlanData> {
+  const projectRoot = process.cwd();
+  const session = await collectAuthOperations(options);
+  const ledger = loadArtifactLedger(projectRoot);
+
+  const operations: AuthPlanOperation[] = [];
+  const fingerprints: Record<string, string | null> = {};
+  const warnings = [...session.warnings];
+
+  for (const op of session.operations) {
+    fingerprints[op.path] = op.previousHash;
+
+    let action: AuthPlanAction;
+    let conflict = false;
+    let conflictReason: string | undefined;
+
+    switch (op.action) {
+      case "create":
+        action = "create";
+        break;
+      case "skip":
+        action = "skip";
+        break;
+      case "append":
+        action = "append";
+        break;
+      case "delete":
+        action = "delete";
+        break;
+      case "modify": {
+        if (op.ownership === "extension-point") {
+          // 設定ファイル・登録ポイントへの追記型変更は想定内の更新として扱う
+          action = "update";
+          break;
+        }
+        const record = ledger ? findArtifactRecord(ledger, op.path) : undefined;
+        if (record && record.contentHash === op.previousHash) {
+          action = "update";
+        } else if (record) {
+          action = "overwrite";
+          conflict = true;
+          conflictReason = "modified-after-generation";
+        } else {
+          action = "overwrite";
+          conflict = true;
+          conflictReason = "unknown-provenance";
+          warnings.push(
+            `unknown-provenance: ${op.path} exists but is not tracked in .swallowkit/artifacts.json; regenerating will overwrite it.`
+          );
+        }
+        break;
+      }
+    }
+
+    operations.push({
+      path: op.path,
+      action,
+      ownership: op.ownership,
+      conflict,
+      ...(conflictReason ? { conflictReason } : {}),
+    });
+  }
+
+  const conflicts = operations.filter((op) => op.conflict);
+
+  const planId = crypto
+    .createHash("sha256")
+    .update(
+      JSON.stringify({
+        provider: options.provider,
+        scheme: options.scheme,
+        operations: operations.map((op) => ({ path: op.path, action: op.action })),
+        fingerprints,
+      })
+    )
+    .digest("hex")
+    .slice(0, 12);
+
+  const plan: AuthPlanData = {
+    planId,
+    planType: "auth",
+    provider: options.provider,
+    ...(options.scheme ? { scheme: options.scheme } : {}),
+    createdAt: new Date().toISOString(),
+    swallowkitVersion: getSwallowKitVersion(),
+    operations,
+    warnings,
+    conflicts,
+    requiresApproval: conflicts.length > 0,
+    fingerprints,
+  };
+
+  savePlanState(plan, projectRoot);
+  return plan;
+}
+
+export function verifyAuthPlanFingerprints(
+  plan: AuthPlanData,
+  projectRoot: string = process.cwd()
+): { fresh: boolean; changedFiles: string[] } {
+  const changedFiles: string[] = [];
+  for (const [relativePath, expectedHash] of Object.entries(plan.fingerprints)) {
+    const currentHash = hashFileIfExists(path.join(projectRoot, relativePath));
+    if (currentHash !== expectedHash) {
+      changedFiles.push(relativePath);
+    }
+  }
+  return { fresh: changedFiles.length === 0, changedFiles };
+}
+
+export interface ApplyAuthOptions {
+  provider?: string;
+  scheme?: string;
+  planId?: string;
+  approve?: boolean;
+}
+
+export interface ApplyAuthResult {
+  provider: string;
+  scheme?: string;
+  planId: string;
+  createdFiles: string[];
+  updatedFiles: string[];
+  appendedFiles: string[];
+  deletedFiles: string[];
+  createdDirectories: string[];
+  diagnostics: string[];
+  approvedConflicts: AuthPlanOperation[];
+  warnings: string[];
+}
+
+async function runCommitAuthOperation(options: PlanAuthOptions): Promise<{
+  createdFiles: string[];
+  updatedFiles: string[];
+  appendedFiles: string[];
+  deletedFiles: string[];
+  createdDirectories: string[];
+  diagnostics: string[];
+}> {
+  const originalMachineOutput = process.env.SWALLOWKIT_MACHINE_OUTPUT;
+  process.env.SWALLOWKIT_MACHINE_OUTPUT = "1";
+
+  try {
+    const tracked = await trackFileMutations(async () => {
+      const captured = await captureConsoleMessagesWithError(async () => {
+        await interceptProcessExit(async () => {
+          await addAuthCommand({ provider: options.provider, scheme: options.scheme });
+        });
+      });
+
+      if (captured.error) {
+        if (captured.error instanceof ProcessExitInterceptError) {
+          throw new Error(deriveAuthErrorMessage(captured.messages));
+        }
+        if (captured.error instanceof Error) {
+          throw captured.error;
+        }
+        throw new Error(deriveAuthErrorMessage(captured.messages));
+      }
+
+      return captured.messages;
+    });
+
+    return {
+      createdFiles: tracked.mutations.createdFiles,
+      updatedFiles: tracked.mutations.updatedFiles,
+      appendedFiles: tracked.mutations.appendedFiles,
+      deletedFiles: tracked.mutations.deletedFiles,
+      createdDirectories: tracked.mutations.createdDirectories,
+      diagnostics: [
+        ...tracked.result.warnings.map((warning) => `warning:${warning}`),
+        ...tracked.result.errors.map((error) => `error:${error}`),
+      ],
+    };
+  } finally {
+    if (originalMachineOutput === undefined) {
+      delete process.env.SWALLOWKIT_MACHINE_OUTPUT;
+    } else {
+      process.env.SWALLOWKIT_MACHINE_OUTPUT = originalMachineOutput;
+    }
+  }
+}
+
+export async function applyAuthOperation(options: ApplyAuthOptions): Promise<ApplyAuthResult> {
+  const projectRoot = process.cwd();
+
+  let basePlan: AuthPlanData | null = null;
+
+  if (options.planId) {
+    basePlan = loadPlanState<AuthPlanData>(options.planId, projectRoot);
+    if (!basePlan) {
+      throw new MachineCommandError(
+        "plan-not-found",
+        `Plan "${options.planId}" was not found. Run "plan auth" to create a new plan.`,
+        { planId: options.planId },
+        "blocked"
+      );
+    }
+
+    const freshness = verifyAuthPlanFingerprints(basePlan, projectRoot);
+    if (!freshness.fresh) {
+      throw new MachineCommandError(
+        "stale-plan",
+        `Plan "${options.planId}" is stale: ${freshness.changedFiles.length} file(s) changed after the plan was created. Re-run "plan auth".`,
+        { planId: options.planId, changedFiles: freshness.changedFiles },
+        "blocked"
+      );
+    }
+  }
+
+  const provider = options.provider ?? basePlan?.provider;
+  if (!provider) {
+    throw new MachineCommandError(
+      "invalid-arguments",
+      "Either --provider or --plan <planId> must be provided.",
+      undefined,
+      "failed"
+    );
+  }
+
+  const effectiveOptions: PlanAuthOptions = {
+    provider,
+    scheme: options.scheme ?? basePlan?.scheme,
+  };
+
+  // 常に最新状態で collect し、競合を再確認する
+  const currentPlan = await planAuthOperation(effectiveOptions);
+
+  if (currentPlan.requiresApproval && !options.approve) {
+    throw new MachineCommandError(
+      "approval-required",
+      `${currentPlan.conflicts.length} file(s) were modified after generation and would be overwritten. Review the conflicts and re-run with --approve to proceed.`,
+      {
+        planId: currentPlan.planId,
+        conflicts: currentPlan.conflicts,
+      },
+      "requires-human"
+    );
+  }
+
+  const result = await runCommitAuthOperation(effectiveOptions);
+
+  deletePlanState(currentPlan.planId, projectRoot);
+  if (options.planId && options.planId !== currentPlan.planId) {
+    deletePlanState(options.planId, projectRoot);
+  }
+
+  return {
+    ...result,
+    provider,
+    ...(effectiveOptions.scheme ? { scheme: effectiveOptions.scheme } : {}),
+    planId: currentPlan.planId,
+    approvedConflicts: options.approve ? currentPlan.conflicts : [],
+    warnings: currentPlan.warnings,
+  };
+}

package/src/core/operations/create-model.ts

@@ -1,8 +1,11 @@
-import * as fs from "fs";
 import * as path from "path";
 import { ensureSwallowKitProject, loadConfig } from "../config";
 import { toPascalCase } from "../scaffold/model-parser";
 import { syncProjectManifest } from "../project/manifest";
+import { recordSessionOperations } from "../project/artifacts";
+import { FileOperationSession, getActiveFileSession } from "./file-session";
+
+const CREATE_MODEL_GENERATOR = "create-model";
 
 export interface CreateModelOperationOptions {
   names: string[];
@@ -87,21 +90,24 @@ export const connectorConfig = {
 `;
 }
 
-function updateSharedIndex(kebabName: string, pascalName: string): boolean {
-  const indexPath = path.join("shared", "index.ts");
+function updateSharedIndex(kebabName: string, pascalName: string, session: FileOperationSession): boolean {
+  const indexPath = path.join(process.cwd(), "shared", "index.ts");
 
-  if (!fs.existsSync(indexPath)) {
+  if (!session.fileExists(indexPath)) {
     return false;
   }
 
-  const content = fs.readFileSync(indexPath, "utf-8");
+  const content = session.readFile(indexPath);
   const exportLine = `export { ${pascalName} } from './models/${kebabName}';`;
 
   if (content.includes(exportLine)) {
     return false;
   }
 
-  fs.appendFileSync(indexPath, `${exportLine}\n`);
+  session.writeFile(indexPath, `${content}${exportLine}\n`, {
+    ownership: "extension-point",
+    generator: CREATE_MODEL_GENERATOR,
+  });
   return true;
 }
 
@@ -123,9 +129,8 @@ export async function createModelOperation(options: CreateModelOperationOptions)
   }
 
   const modelsDir = options.modelsDir || "shared/models";
-  if (!fs.existsSync(modelsDir)) {
-    fs.mkdirSync(modelsDir, { recursive: true });
-  }
+
+  const session = getActiveFileSession() ?? new FileOperationSession("commit");
 
   const createdFiles: string[] = [];
   const skippedFiles: string[] = [];
@@ -136,7 +141,7 @@ export async function createModelOperation(options: CreateModelOperationOptions)
     const filePath = path.join(modelsDir, `${kebabName}.ts`);
     const pascalName = toPascalCase(name);
 
-    if (fs.existsSync(filePath)) {
+    if (session.fileExists(path.resolve(filePath))) {
       const overwriteMode = options.overwriteMode || "prompt";
       const shouldOverwrite = overwriteMode === "always"
         ? true
@@ -155,15 +160,22 @@ export async function createModelOperation(options: CreateModelOperationOptions)
     const content = options.connector && connectorType
       ? generateConnectorModelTemplate(name, options.connector, connectorType)
       : generateModelTemplate(name);
-    fs.writeFileSync(filePath, content, "utf-8");
+    session.writeFile(path.resolve(filePath), content, {
+      ownership: "user-owned",
+      generator: CREATE_MODEL_GENERATOR,
+      sourceModel: pascalName,
+    });
     createdFiles.push(filePath.replace(/\\/g, "/"));
 
-    if (updateSharedIndex(kebabName, pascalName)) {
+    if (updateSharedIndex(kebabName, pascalName, session)) {
       updatedIndex = true;
     }
   }
 
-  await syncProjectManifest();
+  if (session.mode === "commit") {
+    recordSessionOperations(session.operations, {});
+    await syncProjectManifest();
+  }
 
   return {
     createdFiles,