swallowkit 1.0.0-beta.19 → 1.0.0-beta.20

package/src/__tests__/machine.test.ts

@@ -0,0 +1,212 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { runMachineCli } from "../machine";
+
+const repoRoot = process.cwd();
+
+function writeFile(filePath: string, content: string): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, "utf-8");
+}
+
+function createModelSource(name: string): string {
+  return `import { z } from 'zod/v4';
+
+export const ${name} = z.object({
+  id: z.string(),
+  name: z.string().min(1),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+
+export type ${name} = z.infer<typeof ${name}>;
+
+export const displayName = '${name}';
+`;
+}
+
+function createProjectFixture(rootDir: string, options: { includeGeneratedArtifacts?: boolean; forbiddenBffDependency?: boolean } = {}): void {
+  writeFile(path.join(rootDir, "package.json"), JSON.stringify({ name: "sample-app" }, null, 2));
+  writeFile(
+    path.join(rootDir, "swallowkit.config.js"),
+    `module.exports = {
+  database: {
+    connectionString: 'AccountEndpoint=https://example.local;',
+  },
+  backend: {
+    language: 'typescript',
+  },
+  api: {
+    endpoint: '/api/_swallowkit',
+  },
+};
+`
+  );
+  writeFile(path.join(rootDir, "shared", "package.json"), JSON.stringify({ name: "@sample-app/shared" }, null, 2));
+  writeFile(path.join(rootDir, "shared", "index.ts"), "export {};\n");
+  writeFile(path.join(rootDir, "shared", "models", "todo.ts"), createModelSource("Todo"));
+  fs.mkdirSync(path.join(rootDir, "node_modules"), { recursive: true });
+  fs.symlinkSync(
+    path.join(repoRoot, "node_modules", "zod"),
+    path.join(rootDir, "node_modules", "zod"),
+    "junction"
+  );
+
+  if (options.includeGeneratedArtifacts) {
+    writeFile(path.join(rootDir, "lib", "api", "call-function.ts"), "export function callFunction() {}\n");
+    writeFile(path.join(rootDir, "functions", "src", "todo.ts"), "export {};\n");
+    writeFile(path.join(rootDir, "app", "api", "todo", "route.ts"), "export async function GET() { return Response.json([]); }\n");
+    writeFile(path.join(rootDir, "app", "api", "todo", "[id]", "route.ts"), "export async function GET() { return Response.json({}); }\n");
+  }
+
+  if (options.forbiddenBffDependency) {
+    writeFile(
+      path.join(rootDir, "app", "api", "forbidden", "route.ts"),
+      "import { CosmosClient } from '@azure/cosmos';\nexport async function GET() { return Response.json({ ok: Boolean(CosmosClient) }); }\n"
+    );
+  }
+}
+
+async function runMachine(argv: string[]): Promise<{ response: any; exitCode: number }> {
+  const writes: string[] = [];
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  const originalExitCode = process.exitCode;
+
+  (process.stdout.write as unknown as (chunk: string | Uint8Array) => boolean) = ((chunk: string | Uint8Array) => {
+    writes.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf-8"));
+    return true;
+  }) as typeof process.stdout.write;
+
+  process.exitCode = 0;
+
+  try {
+    await runMachineCli(argv);
+    return {
+      response: JSON.parse(writes.join("")),
+      exitCode: process.exitCode || 0,
+    };
+  } finally {
+    process.stdout.write = originalWrite;
+    process.exitCode = originalExitCode;
+  }
+}
+
+describe("machine CLI", () => {
+  const originalCwd = process.cwd();
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-machine-"));
+    process.chdir(tempDir);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("inspects SwallowKit project metadata as JSON", async () => {
+    createProjectFixture(tempDir, { includeGeneratedArtifacts: true });
+
+    const { response, exitCode } = await runMachine(["node", "swallowkit", "machine", "inspect", "project"]);
+
+    expect(exitCode).toBe(0);
+    expect(response.ok).toBe(true);
+    expect(response.command).toBe("inspect-project");
+    expect(response.data.manifest.entities[0].name).toBe("Todo");
+    expect(response.data.manifest.routes).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          name: "Todo-bff-list",
+          publicPath: "/api/todo",
+          exists: true,
+        }),
+      ])
+    );
+  });
+
+  it("validates forbidden BFF dependencies", async () => {
+    createProjectFixture(tempDir, {
+      includeGeneratedArtifacts: true,
+      forbiddenBffDependency: true,
+    });
+
+    const { response, exitCode } = await runMachine(["node", "swallowkit", "machine", "validate", "project"]);
+
+    expect(exitCode).toBe(0);
+    expect(response.ok).toBe(true);
+    expect(response.command).toBe("validate-project");
+    expect(response.data.violations).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: "forbidden-bff-dependency",
+          severity: "error",
+        }),
+      ])
+    );
+  });
+
+  it("generates model templates through the machine interface", async () => {
+    writeFile(path.join(tempDir, "package.json"), JSON.stringify({ name: "sample-app" }, null, 2));
+    writeFile(
+      path.join(tempDir, "swallowkit.config.js"),
+      `module.exports = {
+  backend: { language: 'typescript' },
+  api: { endpoint: '/api/_swallowkit' },
+};
+`
+    );
+    fs.mkdirSync(path.join(tempDir, "node_modules"), { recursive: true });
+    fs.symlinkSync(
+      path.join(repoRoot, "node_modules", "zod"),
+      path.join(tempDir, "node_modules", "zod"),
+      "junction"
+    );
+    writeFile(path.join(tempDir, "shared", "index.ts"), "export {};\n");
+
+    const { response, exitCode } = await runMachine([
+      "node",
+      "swallowkit",
+      "machine",
+      "generate",
+      "model",
+      "Task",
+      "--overwrite",
+      "never",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(response.ok).toBe(true);
+    expect(response.command).toBe("generate-model");
+    expect(response.data.createdFiles).toContain("shared/models/task.ts");
+    expect(fs.existsSync(path.join(tempDir, ".swallowkit", "project.json"))).toBe(true);
+  });
+
+  it("generates scaffold artifacts through the machine interface", async () => {
+    createProjectFixture(tempDir);
+
+    const { response, exitCode } = await runMachine([
+      "node",
+      "swallowkit",
+      "machine",
+      "generate",
+      "scaffold",
+      "todo",
+      "--api-only",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(response.ok).toBe(true);
+    expect(response.command).toBe("generate-scaffold");
+    expect(response.data.createdFiles).toEqual(
+      expect.arrayContaining([
+        "app/api/todo/route.ts",
+        "app/api/todo/[id]/route.ts",
+        "functions/src/todo.ts",
+        "lib/api/call-function.ts",
+      ])
+    );
+    expect(fs.existsSync(path.join(tempDir, ".swallowkit", "project.json"))).toBe(true);
+  });
+});

package/src/__tests__/mcp.test.ts

@@ -0,0 +1,56 @@
+import { buildSwallowKitToolDefinitions } from "../mcp";
+
+describe("SwallowKit MCP tool definitions", () => {
+  it("delegates inspect_project to the machine CLI", async () => {
+    const runner = jest.fn().mockResolvedValue({
+      stdout: JSON.stringify({
+        ok: true,
+        command: "inspect-project",
+        data: { manifestSource: "file" },
+      }),
+      stderr: "",
+      exitCode: 0,
+    });
+
+    const tool = buildSwallowKitToolDefinitions(runner).find((candidate) => candidate.name === "swallowkit_inspect_project");
+    expect(tool).toBeDefined();
+
+    const result = await tool!.handler({});
+    expect(runner).toHaveBeenCalledWith(["inspect", "project"]);
+    expect(JSON.parse(result.content[0].text)).toEqual({ manifestSource: "file" });
+  });
+
+  it("delegates scaffold_model with explicit args", async () => {
+    const runner = jest.fn().mockResolvedValue({
+      stdout: JSON.stringify({
+        ok: true,
+        command: "generate-scaffold",
+        data: { createdFiles: ["functions/src/todo.ts"] },
+      }),
+      stderr: "",
+      exitCode: 0,
+    });
+
+    const tool = buildSwallowKitToolDefinitions(runner).find((candidate) => candidate.name === "swallowkit_scaffold_model");
+    expect(tool).toBeDefined();
+
+    const result = await tool!.handler({
+      model: "todo",
+      functionsDir: "functions",
+      apiDir: "app/api",
+      apiOnly: true,
+    });
+
+    expect(runner).toHaveBeenCalledWith([
+      "generate",
+      "scaffold",
+      "todo",
+      "--functions-dir",
+      "functions",
+      "--api-dir",
+      "app/api",
+      "--api-only",
+    ]);
+    expect(JSON.parse(result.content[0].text)).toEqual({ createdFiles: ["functions/src/todo.ts"] });
+  });
+});

package/src/cli/commands/add-auth.ts

@@ -23,6 +23,7 @@ import {
   generateAuthContext,
   generateBFFCallFunctionWithAuth,
 } from "../../core/scaffold/auth-generator";
+import { syncProjectManifest } from "../../core/project/manifest";
 
 interface AddAuthOptions {
   provider?: string;
@@ -132,6 +133,7 @@ export async function addAuthCommand(options: AddAuthOptions) {
   // 10. Install dependencies
   console.log("\n Installing auth dependencies...");
   await installAuthDependencies(cwd, backendLanguage, rdbProvider);
+  await syncProjectManifest();
 
   console.log("\n Authentication setup complete!");
   console.log("\n Next steps:");

package/src/cli/commands/add-connector.ts

@@ -7,6 +7,7 @@ import * as fs from "fs";
 import * as path from "path";
 import { ensureSwallowKitProject } from "../../core/config";
 import { ApiConnectorConfig, ConnectorDefinition } from "../../types";
+import { syncProjectManifest } from "../../core/project/manifest";
 
 interface AddConnectorOptions {
   name: string;
@@ -33,6 +34,7 @@ export async function addConnectorCommand(options: AddConnectorOptions) {
 
   // Update config file
   updateConfigWithConnector(configPath, options.name, connectorDef);
+  await syncProjectManifest();
 
   console.log(`\n✅ Connector '${options.name}' added successfully!`);
   console.log("\n📝 Next steps:");

package/src/cli/commands/create-model.ts

@@ -1,13 +1,5 @@
-/**
- * SwallowKit Create-Model コマンド
- * Zod モデルの雛形を生成
- */
-
-import * as fs from "fs";
-import * as path from "path";
 import * as readline from "readline";
-import { toPascalCase } from "../../core/scaffold/model-parser";
-import { ensureSwallowKitProject, loadConfig } from "../../core/config";
+import { createModelOperation } from "../../core/operations/create-model";
 import { detectFromProject, getCommands } from "../../utils/package-manager";
 
 interface CreateModelOptions {
@@ -16,81 +8,6 @@ interface CreateModelOptions {
   connector?: string; // コネクタ名（例: "mysql", "backlog"）
 }
 
-/**
- * モデルテンプレートを生成
- */
-function generateModelTemplate(modelName: string): string {
-  const pascalName = toPascalCase(modelName);
-  
-  return `import { z } from 'zod/v4';
-
-// ${pascalName} model (Zod official pattern: same name for value and type)
-export const ${pascalName} = z.object({
-  id: z.string(),
-  name: z.string().min(1),
-  createdAt: z.string().optional(),
-  updatedAt: z.string().optional(),
-});
-
-export type ${pascalName} = z.infer<typeof ${pascalName}>;
-
-// Display name for UI
-export const displayName = '${pascalName}';
-`;
-}
-
-/**
- * コネクタ付きモデルテンプレートを生成
- */
-function generateConnectorModelTemplate(modelName: string, connectorName: string, connectorType: 'rdb' | 'api'): string {
-  const pascalName = toPascalCase(modelName);
-  const kebabName = modelName.toLowerCase().replace(/[^a-z0-9]+/g, '-');
-  const pluralName = kebabName.endsWith('s') ? kebabName : kebabName + 's';
-
-  const schema = `import { z } from 'zod/v4';
-
-// ${pascalName} model (Zod official pattern: same name for value and type)
-export const ${pascalName} = z.object({
-  id: z.string(),
-  name: z.string().min(1),
-  createdAt: z.string().optional(),
-  updatedAt: z.string().optional(),
-});
-
-export type ${pascalName} = z.infer<typeof ${pascalName}>;
-
-// Display name for UI
-export const displayName = '${pascalName}';
-`;
-
-  if (connectorType === 'rdb') {
-    return schema + `
-// SwallowKit Connector Metadata
-export const connectorConfig = {
-  connector: '${connectorName}',
-  operations: ['getAll', 'getById'] as const,
-  table: '${pluralName}',
-  idColumn: 'id',
-};
-`;
-  }
-
-  // API connector
-  return schema + `
-// SwallowKit Connector Metadata
-export const connectorConfig = {
-  connector: '${connectorName}',
-  operations: ['getAll', 'getById', 'create', 'update'] as const,
-  endpoints: {
-    getAll: 'GET /${pluralName}',
-    getById: 'GET /${pluralName}/{id}',
-    create: 'POST /${pluralName}',
-    update: 'PATCH /${pluralName}/{id}',
-  },
-};
-`;
-}
-
 /**
  * ユーザーに確認を求める
  */
@@ -112,100 +29,34 @@ function askConfirmation(question: string): Promise<boolean> {
  * create-model コマンド
  */
 export async function createModelCommand(options: CreateModelOptions) {
-  // SwallowKit プロジェクトディレクトリかどうかを検証
-  ensureSwallowKitProject("create-model");
-
   console.log("🏗️  SwallowKit Create-Model: Generating model templates...\n");
 
-  // コネクタ指定時はコネクタの存在を検証
-  let connectorType: 'rdb' | 'api' | undefined;
-  if (options.connector) {
-    const config = loadConfig();
-    const connectorDef = config.connectors?.[options.connector];
-    if (!connectorDef) {
-      console.error(`❌ Connector '${options.connector}' not found in swallowkit.config.js.`);
-      console.error(`   Available connectors: ${Object.keys(config.connectors || {}).join(', ') || '(none)'}`);
-      console.error(`   Run 'swallowkit add-connector ${options.connector} --type=<rdb|api>' first.`);
-      process.exit(1);
-    }
-    connectorType = connectorDef.type;
-    console.log(`🔌 Using connector: ${options.connector} (${connectorType})\n`);
-  }
-
-  const modelsDir = options.modelsDir || "shared/models";
-  
-  // shared/models ディレクトリが存在しなければ作成
-  if (!fs.existsSync(modelsDir)) {
-    console.log(`📁 Creating directory: ${modelsDir}`);
-    fs.mkdirSync(modelsDir, { recursive: true });
-  }
-
-  const created: string[] = [];
-  const skipped: string[] = [];
-
-  for (const name of options.names) {
-    const kebabName = name.toLowerCase().replace(/[^a-z0-9]+/g, '-');
-    const filePath = path.join(modelsDir, `${kebabName}.ts`);
-    const pascalName = toPascalCase(name);
-
-    // 既存ファイルチェック
-    if (fs.existsSync(filePath)) {
-      const shouldOverwrite = await askConfirmation(
-        `⚠️  File ${filePath} already exists. Overwrite? (y/N): `
-      );
-      
-      if (!shouldOverwrite) {
-        console.log(`⏭️  Skipped: ${kebabName}.ts`);
-        skipped.push(kebabName);
-        continue;
-      }
-    }
-
-    // モデルファイルを生成
-    const content = options.connector && connectorType
-      ? generateConnectorModelTemplate(name, options.connector, connectorType)
-      : generateModelTemplate(name);
-    fs.writeFileSync(filePath, content);
-    console.log(`✅ Created: ${filePath}`);
-    created.push(kebabName);
-
-    // shared/index.ts に re-export を追加
-    updateSharedIndex(kebabName, pascalName);
-  }
+  const result = await createModelOperation({
+    names: options.names,
+    modelsDir: options.modelsDir,
+    connector: options.connector,
+    overwriteMode: "prompt",
+    confirmOverwrite: async (filePath) => askConfirmation(`⚠️  File ${filePath} already exists. Overwrite? (y/N): `),
+  });
 
   // サマリー表示
   console.log("\n📋 Summary:");
-  if (created.length > 0) {
-    console.log(`  ✅ Created ${created.length} model(s): ${created.join(', ')}.ts`);
+  if (result.connectorType && options.connector) {
+    console.log(`  🔌 Connector: ${options.connector} (${result.connectorType})`);
+  }
+  if (result.createdFiles.length > 0) {
+    console.log(`  ✅ Created ${result.createdFiles.length} model(s): ${result.createdFiles.join(", ")}`);
   }
-  if (skipped.length > 0) {
-    console.log(`  ⏭️  Skipped ${skipped.length} model(s): ${skipped.join(', ')}.ts`);
+  if (result.skippedFiles.length > 0) {
+    console.log(`  ⏭️  Skipped ${result.skippedFiles.length} model(s): ${result.skippedFiles.join(", ")}`);
+  }
+  if (result.updatedIndex) {
+    console.log("  📦 Updated shared/index.ts");
   }
 
-  if (created.length > 0) {
+  if (result.createdFiles.length > 0) {
     console.log("\n📝 Next steps:");
     console.log("  1. Customize the generated model fields in shared/models/");
     console.log(`  2. Run '${getCommands(detectFromProject()).dlx} swallowkit scaffold <model>' to generate CRUD code`);
   }
 }
-
-/**
- * shared/index.ts に re-export エントリを追加
- */
-function updateSharedIndex(kebabName: string, pascalName: string): void {
-  const indexPath = path.join("shared", "index.ts");
-  
-  if (!fs.existsSync(indexPath)) {
-    return;
-  }
-  
-  const content = fs.readFileSync(indexPath, "utf-8");
-  const exportLine = `export { ${pascalName} } from './models/${kebabName}';`;
-  
-  // 既に存在する場合はスキップ
-  if (content.includes(exportLine)) {
-    return;
-  }
-  
-  fs.appendFileSync(indexPath, exportLine + "\n");
-}

package/src/cli/commands/init.ts

@@ -14,6 +14,7 @@ import {
   getFunctionsPrestart,
   getFunctionsStartScript,
 } from "../../utils/package-manager";
+import { syncProjectManifest } from "../../core/project/manifest";
 
 interface InitOptions {
   name: string;
@@ -197,6 +198,8 @@ export async function initCommand(options: InitOptions) {
       await createAzurePipelines(projectDir, pm, backendLanguage);
     }
 
+    await syncProjectManifest(projectDir);
+
     // Initialize Git repository and create initial commit
     try {
       // Try git init with -b main (Git 2.28+), fallback to git init

package/src/cli/commands/scaffold.ts

@@ -41,6 +41,7 @@ import {
   ModelAuthPolicy,
   AuthConfig,
 } from "../../types";
+import { syncProjectManifest } from "../../core/project/manifest";
 
 interface ScaffoldOptions {
   model: string; // モデルファイルのパス（例: "lib/models/todo.ts" or "todo"）
@@ -49,6 +50,26 @@ interface ScaffoldOptions {
   apiOnly?: boolean; // true の場合、UI を生成しない（デフォルト: false）
 }
 
+function getMachineAwareStdio(): "inherit" | "pipe" {
+  return process.env.SWALLOWKIT_MACHINE_OUTPUT === "1" ? "pipe" : "inherit";
+}
+
+function runSpawnSyncCommand(command: string, args: string[], cwd: string): void {
+  const result = spawnSync(command, args, {
+    cwd,
+    stdio: getMachineAwareStdio(),
+    shell: true,
+  });
+
+  if (typeof result.status === "number" && result.status !== 0) {
+    throw new Error(`${command} ${args.join(" ")} exited with code ${result.status}`);
+  }
+
+  if (result.error) {
+    throw result.error;
+  }
+}
+
 export async function scaffoldCommand(options: ScaffoldOptions) {
   // SwallowKit プロジェクトディレクトリかどうかを検証
   ensureSwallowKitProject("scaffold");
@@ -140,6 +161,8 @@ export async function scaffoldCommand(options: ScaffoldOptions) {
       await updateNavigationMenu(modelInfo);
     }
 
+    await syncProjectManifest();
+
     console.log("\n✅ Scaffold completed successfully!");
     console.log("\n📝 Next steps:");
     console.log(`  1. Review generated files in ${describeFunctionsOutputPath(functionsDir, backendLanguage)} and ${apiDir}/`);
@@ -508,14 +531,10 @@ async function installConnectorDriverDependencies(
     const cmds = getCommands(pm);
 
     if (entry.deps.length > 0) {
-      spawnSync(cmds.name, [pm === "pnpm" ? "add" : "install", ...entry.deps], {
-        cwd: functionsPath, stdio: "inherit", shell: true,
-      });
+      runSpawnSyncCommand(cmds.name, [pm === "pnpm" ? "add" : "install", ...entry.deps], functionsPath);
     }
     if (entry.devDeps.length > 0) {
-      spawnSync(cmds.name, [pm === "pnpm" ? "add" : "install", "-D", ...entry.devDeps], {
-        cwd: functionsPath, stdio: "inherit", shell: true,
-      });
+      runSpawnSyncCommand(cmds.name, [pm === "pnpm" ? "add" : "install", "-D", ...entry.devDeps], functionsPath);
     }
     console.log(`✅ ${rdbDef.provider} driver installed`);
     return;
@@ -530,9 +549,7 @@ async function installConnectorDriverDependencies(
     const pkg = nugetMap[rdbDef.provider];
     if (!pkg) return;
     console.log(`\n📦 Installing ${rdbDef.provider} NuGet package...`);
-    spawnSync("dotnet", ["add", path.join(functionsPath, "functions.csproj"), "package", pkg], {
-      cwd: functionsPath, stdio: "inherit", shell: true,
-    });
+    runSpawnSyncCommand("dotnet", ["add", path.join(functionsPath, "functions.csproj"), "package", pkg], functionsPath);
     console.log(`✅ ${pkg} installed`);
     return;
   }
@@ -697,7 +714,7 @@ async function runOpenApiGenerator(
     const child = spawn(command, args, {
       cwd: process.cwd(),
       shell: true,
-      stdio: "inherit",
+      stdio: getMachineAwareStdio(),
     });
 
     child.on("close", (code) => {

package/src/cli/index.ts

@@ -6,6 +6,7 @@ import { initCommand, devCommand, devSeedsCommand, scaffoldCommand, createModelC
 import { provisionCommand } from "./commands/provision";
 import { addConnectorCommand } from "./commands/add-connector";
 import { addAuthCommand } from "./commands/add-auth";
+import { isMachineCommand, runMachineCli } from "../machine";
 
 const DEV_OPTION_ARITY = new Map<string, 0 | 1>([
   ["-p", 1],
@@ -174,6 +175,11 @@ export function createProgram(devCommandOverride: Command = devCommand): Command
 
 export async function runCli(argv: string[] = process.argv): Promise<void> {
   ensureUtf8ConsoleOnWindows();
+  if (isMachineCommand(argv)) {
+    await runMachineCli(argv);
+    return;
+  }
+
   await createProgram().parseAsync(normalizeDevCommandArgv(argv));
 }