swallowkit 1.0.0-beta.6 → 1.0.0-beta.61

package/src/core/mock/zod-mock-generator.ts

@@ -0,0 +1,205 @@
+/**
+ * Zod スキーマ（ModelInfo）からモックデータを自動生成する
+ * フィールド名・型のヒューリスティクスで現実的な値を生成
+ */
+
+import { ModelInfo, FieldInfo, toCamelCase, toKebabCase } from "../scaffold/model-parser";
+
+/**
+ * 単一のモックドキュメントを生成
+ */
+export function generateMockDocument(
+  model: ModelInfo,
+  index: number,
+  allModels: ModelInfo[] = [model],
+  seenModels: Set<string> = new Set()
+): Record<string, unknown> {
+  const nextSeen = new Set(seenModels);
+  nextSeen.add(model.name);
+
+  const doc: Record<string, unknown> = {};
+  for (const field of model.fields) {
+    doc[field.name] = generateFieldValue(model, field, index, allModels, nextSeen);
+  }
+  return doc;
+}
+
+/**
+ * 複数のモックドキュメントを生成
+ */
+export function generateMockDocuments(
+  model: ModelInfo,
+  count: number = 5,
+  allModels: ModelInfo[] = [model]
+): Record<string, unknown>[] {
+  const docs: Record<string, unknown>[] = [];
+  for (let i = 0; i < count; i++) {
+    docs.push(generateMockDocument(model, i + 1, allModels));
+  }
+  return docs;
+}
+
+// ─── Field Value Generation ─────────────────────────────────
+
+function generateFieldValue(
+  model: ModelInfo,
+  field: FieldInfo,
+  index: number,
+  allModels: ModelInfo[],
+  seenModels: Set<string>
+): unknown {
+  // ネストされたスキーマ
+  if (field.isNestedSchema && field.nestedModelName) {
+    const nestedModel = allModels.find((m) => m.name === field.nestedModelName);
+    if (nestedModel && !seenModels.has(nestedModel.name)) {
+      const nested = generateMockDocument(nestedModel, index, allModels, seenModels);
+      return field.isArray ? [nested] : nested;
+    }
+    const fallback = { id: `${toKebabCase(field.nestedModelName!)}-${padIndex(index)}` };
+    return field.isArray ? [fallback] : fallback;
+  }
+
+  if (field.isArray) {
+    return [generateScalarValue(model, field, index)];
+  }
+
+  return generateScalarValue(model, field, index);
+}
+
+function generateScalarValue(
+  model: ModelInfo,
+  field: FieldInfo,
+  index: number
+): unknown {
+  const name = field.name.toLowerCase();
+  const modelKebab = toKebabCase(model.name);
+
+  // id フィールド
+  if (field.name === "id") {
+    return `${modelKebab}-${padIndex(index)}`;
+  }
+
+  // enum フィールド — ラウンドロビン
+  if (field.enumValues && field.enumValues.length > 0) {
+    return field.enumValues[(index - 1) % field.enumValues.length];
+  }
+
+  // boolean フィールド
+  if (field.type === "boolean") {
+    return index % 2 === 0;
+  }
+
+  // number フィールド
+  if (field.type === "number") {
+    return generateNumberValue(name, index);
+  }
+
+  // date フィールド / *At パターン
+  if (field.type === "date" || name.endsWith("at")) {
+    return generateDateValue(index);
+  }
+
+  // object フィールド
+  if (field.type === "object") {
+    return {};
+  }
+
+  // string フィールド — 名前パターンで分岐
+  return generateStringValue(model, field, index);
+}
+
+function generateStringValue(model: ModelInfo, field: FieldInfo, index: number): string {
+  const name = field.name.toLowerCase();
+  const modelKebab = toKebabCase(model.name);
+
+  // email
+  if (name.includes("email") || name.includes("mail")) {
+    return `${modelKebab}-${padIndex(index)}@example.com`;
+  }
+
+  // URL / ウェブサイト
+  if (name.includes("url") || name.includes("website") || name.includes("link") || name === "href") {
+    return `https://example.com/${modelKebab}/${padIndex(index)}`;
+  }
+
+  // 電話番号
+  if (name.includes("phone") || name.includes("tel")) {
+    return `090-0000-${String(index).padStart(4, "0")}`;
+  }
+
+  // 名前系
+  if (name === "name" || name === "displayname" || name === "fullname" || name === "username") {
+    return `${model.name} ${index}`;
+  }
+  if (name === "firstname" || name === "givenname") {
+    return `FirstName${index}`;
+  }
+  if (name === "lastname" || name === "familyname" || name === "surname") {
+    return `LastName${index}`;
+  }
+
+  // タイトル / 件名
+  if (name === "title" || name === "subject" || name === "summary") {
+    return `Sample ${model.displayName || model.name} ${index}`;
+  }
+
+  // 説明 / 本文
+  if (name === "description" || name === "body" || name === "content" || name === "text") {
+    return `This is a sample ${toCamelCase(model.name)} description for item ${index}.`;
+  }
+
+  // コード / キー
+  if (name.includes("code") || name.includes("key") && !name.includes("api")) {
+    return `${modelKebab.toUpperCase().replace(/-/g, "_")}-${String(index).padStart(3, "0")}`;
+  }
+
+  // ステータス
+  if (name === "status") {
+    const statuses = ["active", "inactive", "pending"];
+    return statuses[(index - 1) % statuses.length];
+  }
+
+  // タイプ / カテゴリ
+  if (name === "type" || name === "category") {
+    return `type-${((index - 1) % 3) + 1}`;
+  }
+
+  // 住所
+  if (name.includes("address") || name.includes("city") || name.includes("country")) {
+    return `Address ${index}`;
+  }
+
+  // 部署
+  if (name === "department" || name === "team" || name === "group") {
+    const depts = ["Engineering", "Sales", "Marketing", "Support", "HR"];
+    return depts[(index - 1) % depts.length];
+  }
+
+  // *Id パターン（外部キー）
+  if (name.endsWith("id") && name !== "id") {
+    const refName = field.name.replace(/Id$/, "");
+    return `${toKebabCase(refName)}-${padIndex(((index - 1) % 3) + 1)}`;
+  }
+
+  // デフォルト
+  return `${modelKebab}-${toKebabCase(field.name)}-${index}`;
+}
+
+function generateNumberValue(name: string, index: number): number {
+  if (name.includes("age")) return 20 + index;
+  if (name.includes("price") || name.includes("cost") || name.includes("amount")) return index * 1000;
+  if (name.includes("count") || name.includes("quantity") || name.includes("qty")) return index * 5;
+  if (name.includes("priority") || name.includes("order") || name.includes("sort")) return index;
+  if (name.includes("rating") || name.includes("score")) return Math.min(index, 5);
+  return index;
+}
+
+function generateDateValue(index: number): string {
+  const baseDate = new Date("2026-01-01T00:00:00.000Z");
+  baseDate.setDate(baseDate.getDate() + index);
+  return baseDate.toISOString();
+}
+
+function padIndex(index: number): string {
+  return String(index).padStart(3, "0");
+}

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

@@ -0,0 +1,360 @@
+/**
+ * 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;
+  /** SWA の許可 identity provider。未指定時は add-auth 側の既定 (['aad'])。 */
+  allowedProviders?: 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;
+  allowedProviders?: 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, allowedProviders: options.allowedProviders });
+        });
+      });
+    });
+
+    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,
+        allowedProviders: options.allowedProviders,
+        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 } : {}),
+    ...(options.allowedProviders && options.allowedProviders.length > 0 ? { allowedProviders: options.allowedProviders } : {}),
+    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;
+  allowedProviders?: 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, allowedProviders: options.allowedProviders });
+        });
+      });
+
+      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,
+    allowedProviders: options.allowedProviders ?? basePlan?.allowedProviders,
+  };
+
+  // 常に最新状態で 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,
+  };
+}