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

package/src/core/operations/runtime.ts

@@ -0,0 +1,258 @@
+import * as fs from "fs";
+import * as path from "path";
+
+export interface CapturedConsoleMessages {
+  logs: string[];
+  warnings: string[];
+  errors: string[];
+}
+
+export interface FileMutationSummary {
+  createdFiles: string[];
+  updatedFiles: string[];
+  appendedFiles: string[];
+  deletedFiles: string[];
+  createdDirectories: string[];
+}
+
+export class ProcessExitInterceptError extends Error {
+  readonly exitCode: number;
+
+  constructor(exitCode: number) {
+    super(`Process exited with code ${exitCode}`);
+    this.name = "ProcessExitInterceptError";
+    this.exitCode = exitCode;
+  }
+}
+
+/**
+ * Captured console 出力からエラーメッセージ全文を組み立てる。
+ * 最終行だけでなく全 error 行を保持し(装飾絵文字は除去)、機械可読な診断に使う。
+ */
+export function deriveCapturedErrorMessage(messages: CapturedConsoleMessages, fallback: string): string {
+  const errorText = messages.errors
+    .map((entry) => entry.replace(/[❌💡]\s*/gu, "").trim())
+    .filter((entry) => entry.length > 0)
+    .join("\n");
+  if (errorText) {
+    return errorText;
+  }
+  const warningText = messages.warnings[messages.warnings.length - 1];
+  if (warningText) {
+    return warningText.trim();
+  }
+  const logText = messages.logs[messages.logs.length - 1];
+  if (logText) {
+    return logText.trim();
+  }
+  return fallback;
+}
+
+function formatConsoleArgs(args: unknown[]): string {
+  return args
+    .map((arg) => {
+      if (typeof arg === "string") {
+        return arg;
+      }
+
+      if (arg instanceof Error) {
+        return arg.stack || arg.message;
+      }
+
+      try {
+        return JSON.stringify(arg);
+      } catch {
+        return String(arg);
+      }
+    })
+    .join(" ");
+}
+
+function normalizePathForSummary(targetPath: string): string {
+  const relative = path.relative(process.cwd(), targetPath);
+  return relative && !relative.startsWith("..") ? relative.replace(/\\/g, "/") : targetPath.replace(/\\/g, "/");
+}
+
+interface FileSystemEntrySnapshot {
+  type: "file" | "directory";
+  mtimeMs: number;
+  size: number;
+}
+
+function snapshotFileSystem(rootDirectory: string): Map<string, FileSystemEntrySnapshot> {
+  const snapshot = new Map<string, FileSystemEntrySnapshot>();
+  const excludedDirectoryNames = new Set([".git", "node_modules"]);
+
+  function walk(currentDirectory: string): void {
+    for (const entry of fs.readdirSync(currentDirectory, { withFileTypes: true })) {
+      if (entry.isDirectory() && excludedDirectoryNames.has(entry.name)) {
+        continue;
+      }
+
+      const entryPath = path.join(currentDirectory, entry.name);
+      const stats = fs.statSync(entryPath);
+      snapshot.set(entryPath, {
+        type: entry.isDirectory() ? "directory" : "file",
+        mtimeMs: stats.mtimeMs,
+        size: stats.size,
+      });
+
+      if (entry.isDirectory()) {
+        walk(entryPath);
+      }
+    }
+  }
+
+  if (fs.existsSync(rootDirectory)) {
+    walk(rootDirectory);
+  }
+
+  return snapshot;
+}
+
+export async function withWorkingDirectory<T>(directory: string, action: () => Promise<T>): Promise<T> {
+  const originalDirectory = process.cwd();
+  process.chdir(directory);
+
+  try {
+    return await action();
+  } finally {
+    process.chdir(originalDirectory);
+  }
+}
+
+export async function captureConsoleMessages<T>(
+  action: () => Promise<T>
+): Promise<{ result: T; messages: CapturedConsoleMessages }> {
+  const messages: CapturedConsoleMessages = {
+    logs: [],
+    warnings: [],
+    errors: [],
+  };
+
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+
+  console.log = (...args: unknown[]) => {
+    messages.logs.push(formatConsoleArgs(args));
+  };
+  console.warn = (...args: unknown[]) => {
+    messages.warnings.push(formatConsoleArgs(args));
+  };
+  console.error = (...args: unknown[]) => {
+    messages.errors.push(formatConsoleArgs(args));
+  };
+
+  try {
+    const result = await action();
+    return { result, messages };
+  } finally {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.error = originalError;
+  }
+}
+
+export async function captureConsoleMessagesWithError<T>(
+  action: () => Promise<T>
+): Promise<{ result?: T; messages: CapturedConsoleMessages; error?: unknown }> {
+  const messages: CapturedConsoleMessages = {
+    logs: [],
+    warnings: [],
+    errors: [],
+  };
+
+  const originalLog = console.log;
+  const originalWarn = console.warn;
+  const originalError = console.error;
+
+  console.log = (...args: unknown[]) => {
+    messages.logs.push(formatConsoleArgs(args));
+  };
+  console.warn = (...args: unknown[]) => {
+    messages.warnings.push(formatConsoleArgs(args));
+  };
+  console.error = (...args: unknown[]) => {
+    messages.errors.push(formatConsoleArgs(args));
+  };
+
+  try {
+    return { result: await action(), messages };
+  } catch (error) {
+    return { messages, error };
+  } finally {
+    console.log = originalLog;
+    console.warn = originalWarn;
+    console.error = originalError;
+  }
+}
+
+export async function interceptProcessExit<T>(action: () => Promise<T>): Promise<T> {
+  const originalExit = process.exit;
+
+  process.exit = ((code?: number | string | null) => {
+    const normalizedCode = typeof code === "number"
+      ? code
+      : typeof process.exitCode === "number"
+        ? process.exitCode
+        : 1;
+    throw new ProcessExitInterceptError(normalizedCode);
+  }) as typeof process.exit;
+
+  try {
+    return await action();
+  } finally {
+    process.exit = originalExit;
+  }
+}
+
+export async function trackFileMutations<T>(
+  action: () => Promise<T>
+): Promise<{ result: T; mutations: FileMutationSummary }> {
+  const rootDirectory = process.cwd();
+  const before = snapshotFileSystem(rootDirectory);
+  const result = await action();
+  const after = snapshotFileSystem(rootDirectory);
+
+  const createdFiles = new Set<string>();
+  const updatedFiles = new Set<string>();
+  const deletedFiles = new Set<string>();
+  const createdDirectories = new Set<string>();
+
+  for (const [entryPath, afterEntry] of after.entries()) {
+    const beforeEntry = before.get(entryPath);
+    if (!beforeEntry) {
+      if (afterEntry.type === "directory") {
+        createdDirectories.add(normalizePathForSummary(entryPath));
+      } else {
+        createdFiles.add(normalizePathForSummary(entryPath));
+      }
+      continue;
+    }
+
+    if (
+      afterEntry.type === "file" &&
+      (beforeEntry.mtimeMs !== afterEntry.mtimeMs || beforeEntry.size !== afterEntry.size)
+    ) {
+      updatedFiles.add(normalizePathForSummary(entryPath));
+    }
+  }
+
+  for (const [entryPath, beforeEntry] of before.entries()) {
+    if (!after.has(entryPath) && beforeEntry.type === "file") {
+      deletedFiles.add(normalizePathForSummary(entryPath));
+    }
+  }
+
+  return {
+    result,
+    mutations: {
+      createdFiles: Array.from(createdFiles).sort(),
+      updatedFiles: Array.from(updatedFiles).sort(),
+      appendedFiles: [],
+      deletedFiles: Array.from(deletedFiles).sort(),
+      createdDirectories: Array.from(createdDirectories).sort(),
+    },
+  };
+}

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

@@ -0,0 +1,106 @@
+/**
+ * Apply Scaffold — Plan の検証(stale 検出・承認チェック)を経て scaffold を実際に適用する。
+ */
+
+import { MachineCommandError } from "../../machine/errors";
+import { deletePlanState, loadPlanState } from "../project/state";
+import { runMachineScaffoldOperation, MachineScaffoldOperationResult } from "./scaffold-machine";
+import {
+  planScaffoldOperation,
+  ScaffoldPlanData,
+  ScaffoldPlanOperation,
+  verifyPlanFingerprints,
+} from "./scaffold-plan";
+
+export interface ApplyScaffoldOptions {
+  model?: string;
+  planId?: string;
+  approve?: boolean;
+  functionsDir?: string;
+  apiDir?: string;
+  apiOnly?: boolean;
+}
+
+export interface ApplyScaffoldResult extends MachineScaffoldOperationResult {
+  model: string;
+  planId: string;
+  approvedConflicts: ScaffoldPlanOperation[];
+  warnings: string[];
+}
+
+export async function applyScaffoldOperation(options: ApplyScaffoldOptions): Promise<ApplyScaffoldResult> {
+  const projectRoot = process.cwd();
+
+  let basePlan: ScaffoldPlanData | null = null;
+
+  if (options.planId) {
+    basePlan = loadPlanState<ScaffoldPlanData>(options.planId, projectRoot);
+    if (!basePlan) {
+      throw new MachineCommandError(
+        "plan-not-found",
+        `Plan "${options.planId}" was not found. Run "plan scaffold" to create a new plan.`,
+        { planId: options.planId },
+        "blocked"
+      );
+    }
+
+    const freshness = verifyPlanFingerprints(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 scaffold".`,
+        { planId: options.planId, changedFiles: freshness.changedFiles },
+        "blocked"
+      );
+    }
+  }
+
+  const model = options.model ?? basePlan?.model;
+  if (!model) {
+    throw new MachineCommandError(
+      "invalid-arguments",
+      "Either a model name or --plan <planId> must be provided.",
+      undefined,
+      "failed"
+    );
+  }
+
+  const effectiveOptions = {
+    model,
+    functionsDir: options.functionsDir ?? basePlan?.options.functionsDir,
+    apiDir: options.apiDir ?? basePlan?.options.apiDir,
+    apiOnly: options.apiOnly ?? basePlan?.options.apiOnly,
+  };
+
+  // 常に最新状態で collect し、競合を検出する(plan 指定時も現況を再確認)
+  const currentPlan = await planScaffoldOperation(effectiveOptions);
+
+  if (currentPlan.requiresApproval && !options.approve) {
+    // 承認待ちの plan は残し、参照できるようにする
+    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 runMachineScaffoldOperation(effectiveOptions);
+
+  // 適用済み plan の状態を破棄
+  deletePlanState(currentPlan.planId, projectRoot);
+  if (options.planId && options.planId !== currentPlan.planId) {
+    deletePlanState(options.planId, projectRoot);
+  }
+
+  return {
+    ...result,
+    model,
+    planId: currentPlan.planId,
+    approvedConflicts: options.approve ? currentPlan.conflicts : [],
+    warnings: currentPlan.warnings,
+  };
+}

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

@@ -0,0 +1,77 @@
+import { scaffoldCommand } from "../../cli/commands/scaffold";
+import {
+  captureConsoleMessagesWithError,
+  deriveCapturedErrorMessage,
+  interceptProcessExit,
+  ProcessExitInterceptError,
+  trackFileMutations,
+} from "./runtime";
+
+export interface MachineScaffoldOperationOptions {
+  model: string;
+  functionsDir?: string;
+  apiDir?: string;
+  apiOnly?: boolean;
+}
+
+export interface MachineScaffoldOperationResult {
+  createdFiles: string[];
+  updatedFiles: string[];
+  appendedFiles: string[];
+  deletedFiles: string[];
+  createdDirectories: string[];
+  diagnostics: string[];
+}
+
+function deriveErrorMessage(messages: { errors: string[]; warnings: string[]; logs: string[] }): string {
+  return deriveCapturedErrorMessage(messages, "Scaffold failed.");
+}
+
+export async function runMachineScaffoldOperation(
+  options: MachineScaffoldOperationOptions
+): Promise<MachineScaffoldOperationResult> {
+  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 scaffoldCommand(options);
+        });
+      });
+
+      if (captured.error) {
+        if (captured.error instanceof ProcessExitInterceptError) {
+          throw new Error(deriveErrorMessage(captured.messages));
+        }
+
+        if (captured.error instanceof Error) {
+          throw captured.error;
+        }
+
+        throw new Error(deriveErrorMessage(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;
+    }
+  }
+}

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

@@ -0,0 +1,215 @@
+/**
+ * Plan Scaffold — scaffold を collect モードで実行し、書き込み予定を差分計画として返す。
+ * ディスクへの書き込みは一切行わない。
+ */
+
+import * as crypto from "crypto";
+import * as path from "path";
+import { scaffoldCommand } from "../../cli/commands/scaffold";
+import { getSwallowKitVersion } from "../../version";
+import { findArtifactRecord, loadArtifactLedger } from "../project/artifacts";
+import { savePlanState } from "../project/state";
+import {
+  ArtifactOwnership,
+  FileOperationSession,
+  hashFileIfExists,
+  runWithFileSession,
+} from "./file-session";
+import {
+  captureConsoleMessagesWithError,
+  deriveCapturedErrorMessage,
+  interceptProcessExit,
+  ProcessExitInterceptError,
+} from "./runtime";
+
+export interface PlanScaffoldOptions {
+  model: string;
+  functionsDir?: string;
+  apiDir?: string;
+  apiOnly?: boolean;
+}
+
+export type ScaffoldPlanAction = "create" | "update" | "overwrite" | "append" | "delete" | "skip";
+
+export interface ScaffoldPlanOperation {
+  path: string;
+  action: ScaffoldPlanAction;
+  ownership: ArtifactOwnership;
+  conflict: boolean;
+  conflictReason?: string;
+}
+
+export interface ScaffoldPlanData {
+  planId: string;
+  planType: "scaffold";
+  model: string;
+  options: {
+    functionsDir?: string;
+    apiDir?: string;
+    apiOnly?: boolean;
+  };
+  createdAt: string;
+  swallowkitVersion: string;
+  operations: ScaffoldPlanOperation[];
+  warnings: string[];
+  conflicts: ScaffoldPlanOperation[];
+  requiresApproval: boolean;
+  /** project-relative path -> pre-plan content hash (null = did not exist). Used for stale-plan detection. */
+  fingerprints: Record<string, string | null>;
+}
+
+function deriveScaffoldErrorMessage(messages: { errors: string[]; warnings: string[]; logs: string[] }): string {
+  return deriveCapturedErrorMessage(messages, "Scaffold plan failed.");
+}
+
+/**
+ * scaffold を collect セッションで実行し、記録された操作を返す。
+ */
+async function collectScaffoldOperations(options: PlanScaffoldOptions): 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 scaffoldCommand({
+            model: options.model,
+            functionsDir: options.functionsDir,
+            apiDir: options.apiDir,
+            apiOnly: options.apiOnly,
+          });
+        });
+      });
+    });
+
+    if (captured.error) {
+      if (captured.error instanceof ProcessExitInterceptError) {
+        throw new Error(deriveScaffoldErrorMessage(captured.messages));
+      }
+      if (captured.error instanceof Error) {
+        throw captured.error;
+      }
+      throw new Error(deriveScaffoldErrorMessage(captured.messages));
+    }
+
+    return session;
+  } finally {
+    if (originalMachineOutput === undefined) {
+      delete process.env.SWALLOWKIT_MACHINE_OUTPUT;
+    } else {
+      process.env.SWALLOWKIT_MACHINE_OUTPUT = originalMachineOutput;
+    }
+  }
+}
+
+export async function planScaffoldOperation(options: PlanScaffoldOptions): Promise<ScaffoldPlanData> {
+  const projectRoot = process.cwd();
+  const session = await collectScaffoldOperations(options);
+  const ledger = loadArtifactLedger(projectRoot);
+
+  const operations: ScaffoldPlanOperation[] = [];
+  const fingerprints: Record<string, string | null> = { ...session.inputFingerprints };
+  const warnings = [...session.warnings];
+
+  for (const op of session.operations) {
+    fingerprints[op.path] = op.previousHash;
+
+    let action: ScaffoldPlanAction;
+    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": {
+        const record = ledger ? findArtifactRecord(ledger, op.path) : undefined;
+        if (record && record.contentHash === op.previousHash) {
+          // 生成後に変更されていない managed ファイルの再生成 — 安全
+          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({
+        model: options.model,
+        options: { functionsDir: options.functionsDir, apiDir: options.apiDir, apiOnly: options.apiOnly },
+        operations: operations.map((op) => ({ path: op.path, action: op.action })),
+        fingerprints,
+      })
+    )
+    .digest("hex")
+    .slice(0, 12);
+
+  const plan: ScaffoldPlanData = {
+    planId,
+    planType: "scaffold",
+    model: options.model,
+    options: {
+      ...(options.functionsDir ? { functionsDir: options.functionsDir } : {}),
+      ...(options.apiDir ? { apiDir: options.apiDir } : {}),
+      ...(options.apiOnly !== undefined ? { apiOnly: options.apiOnly } : {}),
+    },
+    createdAt: new Date().toISOString(),
+    swallowkitVersion: getSwallowKitVersion(),
+    operations,
+    warnings,
+    conflicts,
+    requiresApproval: conflicts.length > 0,
+    fingerprints,
+  };
+
+  savePlanState(plan, projectRoot);
+  return plan;
+}
+
+export function verifyPlanFingerprints(
+  plan: ScaffoldPlanData,
+  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 };
+}