swallowkit 1.0.0-beta.2 → 1.0.0-beta.21

package/src/mcp/index.ts

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+
+import * as path from "path";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio";
+import * as z from "zod/v4";
+import type { MachineResponse } from "../machine/contracts";
+
+interface MachineSuccessPayload<TData> {
+  ok: true;
+  command: string;
+  data: TData;
+}
+
+type MachineCliRunner = (args: string[]) => Promise<{ stdout: string; stderr: string; exitCode: number }>;
+type ToolContentResult = { content: Array<{ type: "text"; text: string }> };
+type ToolDefinition = {
+  name: string;
+  description: string;
+  inputSchema: z.ZodTypeAny;
+  handler: (input: any) => Promise<ToolContentResult>;
+};
+
+function resolveMachineCliEntrypoint(): string {
+  return path.resolve(__dirname, "..", "cli", "index.js");
+}
+
+async function defaultMachineCliRunner(args: string[]): Promise<{ stdout: string; stderr: string; exitCode: number }> {
+  const { execa } = await import("execa");
+  const result = await execa(process.execPath, [resolveMachineCliEntrypoint(), "machine", ...args], {
+    reject: false,
+  });
+
+  return {
+    stdout: result.stdout,
+    stderr: result.stderr,
+    exitCode: result.exitCode ?? 0,
+  };
+}
+
+async function executeMachineCommand<TData>(
+  args: string[],
+  runMachineCli: MachineCliRunner
+): Promise<MachineSuccessPayload<TData>> {
+  const result = await runMachineCli(args);
+
+  let parsed: MachineResponse<TData>;
+  try {
+    parsed = JSON.parse(result.stdout) as MachineResponse<TData>;
+  } catch {
+    throw new Error(result.stderr || result.stdout || "Machine CLI returned invalid JSON.");
+  }
+
+  if (!parsed.ok) {
+    throw new Error(parsed.error.message);
+  }
+
+  return parsed;
+}
+
+function jsonTextContent(value: unknown): { content: Array<{ type: "text"; text: string }> } {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(value, null, 2),
+      },
+    ],
+  };
+}
+
+export function buildSwallowKitToolDefinitions(
+  runMachineCli: MachineCliRunner = defaultMachineCliRunner
+): ToolDefinition[] {
+  return [
+    {
+      name: "swallowkit_inspect_project",
+      description: "Return framework-owned SwallowKit project metadata.",
+      inputSchema: z.object({}),
+      handler: async () => {
+      const response = await executeMachineCommand(["inspect", "project"], runMachineCli);
+      return jsonTextContent(response.data);
+      },
+    },
+    {
+      name: "swallowkit_inspect_entities",
+      description: "Return SwallowKit entities, schema metadata, and connector/auth annotations.",
+      inputSchema: z.object({}),
+      handler: async () => {
+      const response = await executeMachineCommand(["inspect", "entities"], runMachineCli);
+      return jsonTextContent(response.data);
+      },
+    },
+    {
+      name: "swallowkit_inspect_routes",
+      description: "Return BFF and Functions route metadata understood by SwallowKit.",
+      inputSchema: z.object({}),
+      handler: async () => {
+      const response = await executeMachineCommand(["inspect", "routes"], runMachineCli);
+      return jsonTextContent(response.data);
+      },
+    },
+    {
+      name: "swallowkit_validate_project",
+      description: "Validate project metadata, generated artifacts, and framework conventions.",
+      inputSchema: z.object({}),
+      handler: async () => {
+      const response = await executeMachineCommand(["validate", "project"], runMachineCli);
+      return jsonTextContent(response.data);
+      },
+    },
+    {
+      name: "swallowkit_generate_model",
+      description: "Generate SwallowKit model templates through the official generator.",
+      inputSchema: z.object({
+        names: z.array(z.string()).min(1),
+        modelsDir: z.string().optional(),
+        connector: z.string().optional(),
+        overwrite: z.enum(["always", "never"]).optional(),
+      }),
+      handler: async ({ names, modelsDir, connector, overwrite }: { names: string[]; modelsDir?: string; connector?: string; overwrite?: "always" | "never" }) => {
+      const response = await executeMachineCommand(["generate", "model", ...names, ...(modelsDir ? ["--models-dir", modelsDir] : []), ...(connector ? ["--connector", connector] : []), "--overwrite", overwrite || "never"], runMachineCli);
+      return jsonTextContent(response.data);
+      },
+    },
+    {
+      name: "swallowkit_scaffold_model",
+      description: "Generate SwallowKit scaffold artifacts through the official generator.",
+      inputSchema: z.object({
+        model: z.string(),
+        functionsDir: z.string().optional(),
+        apiDir: z.string().optional(),
+        apiOnly: z.boolean().optional(),
+      }),
+      handler: async ({ model, functionsDir, apiDir, apiOnly }: { model: string; functionsDir?: string; apiDir?: string; apiOnly?: boolean }) => {
+      const args = ["generate", "scaffold", model];
+      if (functionsDir) {
+        args.push("--functions-dir", functionsDir);
+      }
+      if (apiDir) {
+        args.push("--api-dir", apiDir);
+      }
+      if (apiOnly) {
+        args.push("--api-only");
+      }
+
+      const response = await executeMachineCommand(args, runMachineCli);
+      return jsonTextContent(response.data);
+      },
+    },
+  ];
+}
+
+export function createSwallowKitMcpServer(runMachineCli: MachineCliRunner = defaultMachineCliRunner): McpServer {
+  const server = new McpServer({
+    name: "swallowkit-mcp",
+    version: process.env.npm_package_version || "0.0.0",
+  });
+
+  for (const tool of buildSwallowKitToolDefinitions(runMachineCli)) {
+    server.registerTool(
+      tool.name,
+      {
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+      },
+      tool.handler
+    );
+  }
+
+  return server;
+}
+
+export async function runMcpServer(): Promise<void> {
+  const server = createSwallowKitMcpServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+if (require.main === module) {
+  void runMcpServer().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+  });
+}

package/src/types/index.ts

@@ -0,0 +1,134 @@
+/**
+ * SwallowKit の基本型定義
+ */
+
+// サーバー関数の実行モード
+export type ServerFnMode = "auto" | "force-server" | "force-client";
+
+export type BackendLanguage = "typescript" | "csharp" | "python";
+
+// useServerFn のオプション
+export interface UseServerFnOptions {
+  mode?: ServerFnMode;
+  refetchOnMount?: boolean;
+  enabled?: boolean;
+  // Next.js キャッシュオプション（内部で使用）
+  cache?: boolean;
+  revalidate?: number | false;
+  tags?: string[];
+}
+
+// useServerFn の戻り値
+export interface UseServerFnResult<TResult> {
+  data: TResult | null;
+  loading: boolean;
+  error: any;
+  refetch: () => void;
+}
+
+// コネクタの操作種別
+export type ConnectorOperation = "getAll" | "getById" | "create" | "update" | "delete";
+
+// RDB コネクタ設定
+export interface RdbConnectorConfig {
+  type: "rdb";
+  provider: "mysql" | "postgres" | "sqlserver";
+  connectionEnvVar: string;
+}
+
+// API コネクタの認証設定
+export interface ApiConnectorAuth {
+  type: "apiKey" | "bearer" | "oauth2";
+  envVar: string;
+  placement?: "query" | "header";
+  paramName?: string;
+}
+
+// API コネクタ設定
+export interface ApiConnectorConfig {
+  type: "api";
+  baseUrlEnvVar: string;
+  auth?: ApiConnectorAuth;
+}
+
+// コネクタ設定の共用型
+export type ConnectorDefinition = RdbConnectorConfig | ApiConnectorConfig;
+
+// モデルに付与するコネクタメタデータ（RDB用）
+export interface RdbModelConnectorConfig {
+  connector: string;
+  operations: readonly ConnectorOperation[];
+  table: string;
+  idColumn?: string;
+}
+
+// モデルに付与するコネクタメタデータ（API用）
+export interface ApiModelConnectorConfig {
+  connector: string;
+  operations: readonly ConnectorOperation[];
+  endpoints?: Partial<Record<ConnectorOperation, string>>;
+}
+
+// モデルに付与するコネクタメタデータの共用型
+export type ModelConnectorConfig = RdbModelConnectorConfig | ApiModelConnectorConfig;
+
+// 認証プロバイダー種別
+export type AuthProvider = "custom-jwt" | "swa" | "swa-custom" | "none";
+
+// custom-jwt プロバイダー設定
+export interface CustomJwtConfig {
+  userConnector: string;
+  userTable: string;
+  loginIdColumn: string;
+  passwordHashColumn: string;
+  rolesColumn: string;
+  jwtSecretEnv?: string;
+  tokenExpiry?: string;
+}
+
+// SWA 認証設定（将来用）
+export interface SwaAuthConfig {
+  allowedProviders?: string[];
+  roleSource?: "swa-roles" | "connector";
+  roleConnector?: string;
+}
+
+// 認可設定
+export interface AuthorizationConfig {
+  defaultPolicy?: "authenticated" | "anonymous";
+}
+
+// 認証設定
+export interface AuthConfig {
+  provider: AuthProvider;
+  customJwt?: CustomJwtConfig;
+  swa?: SwaAuthConfig;
+  authorization?: AuthorizationConfig;
+}
+
+// モデルに付与する認可ポリシー
+export interface ModelAuthPolicy {
+  roles?: string[];
+  read?: string[];
+  write?: string[];
+}
+
+// CLI設定の型
+export interface SwallowKitConfig {
+  database?: {
+    connectionString?: string;
+    databaseName?: string;
+  };
+  backend?: {
+    language?: BackendLanguage;
+  };
+  api?: {
+    endpoint?: string;
+    cors?: {
+      origin?: string | string[];
+      credentials?: boolean;
+    };
+  };
+  connectors?: Record<string, ConnectorDefinition>;
+  auth?: AuthConfig;
+}

package/src/utils/package-manager.ts

@@ -0,0 +1,229 @@
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+import { BackendLanguage } from "../types";
+
+/**
+ * Supported package managers
+ */
+export type PackageManager = "npm" | "pnpm";
+
+/**
+ * Package manager command mappings
+ */
+export interface PackageManagerCommands {
+  /** The binary name: "npm" or "pnpm" */
+  name: PackageManager;
+  /** Install all dependencies: "pnpm install" / "npm install" */
+  install: string;
+  /** Install with lockfile: "pnpm install --frozen-lockfile" / "npm ci" */
+  ci: string;
+  /** Add a dependency: "pnpm add" / "npm install" */
+  add: string;
+  /** Add a dev dependency: "pnpm add -D" / "npm install -D" */
+  addDev: string;
+  /** Add a global dependency: "pnpm add -g" / "npm install -g" */
+  addGlobal: string;
+  /** Execute a package binary: "pnpm exec" / "npx" */
+  exec: string;
+  /** Download & execute: "pnpm dlx" / "npx" */
+  dlx: string;
+  /** Run a script: "pnpm run" / "npm run" */
+  run: string;
+  /** Run a script with filter: "pnpm run --filter <ws>" / "npm run --workspace=<ws>" */
+  runFilter: (workspace: string) => string;
+  /** Start script: "pnpm start" / "npm start" */
+  start: string;
+  /** Install production only (in temp dir for CI): "pnpm install --prod" / "npm install --omit=dev" */
+  installProd: string;
+  /** create-next-app flag: "--use-pnpm" / (none for npm) */
+  createNextAppFlag: string | null;
+}
+
+/**
+ * Get the full command mapping for the given package manager
+ */
+export function getCommands(pm: PackageManager): PackageManagerCommands {
+  if (pm === "pnpm") {
+    return {
+      name: "pnpm",
+      install: "pnpm install",
+      ci: "pnpm install --frozen-lockfile",
+      add: "pnpm add",
+      addDev: "pnpm add -D",
+      addGlobal: "pnpm add -g",
+      exec: "pnpm exec",
+      dlx: "pnpm dlx",
+      run: "pnpm run",
+      runFilter: (ws) => `pnpm run --filter ${ws}`,
+      start: "pnpm start",
+      installProd: "pnpm install --prod",
+      createNextAppFlag: "--use-pnpm",
+    };
+  }
+
+  // npm
+  return {
+    name: "npm",
+    install: "npm install",
+    ci: "npm ci",
+    add: "npm install",
+    addDev: "npm install -D",
+    addGlobal: "npm install -g",
+    exec: "npx",
+    dlx: "npx",
+    run: "npm run",
+    runFilter: (ws) => `npm run --workspace=${ws}`,
+    start: "npm start",
+    installProd: "npm install --omit=dev",
+    createNextAppFlag: null,
+  };
+}
+
+/**
+ * Detect the preferred package manager for new project initialisation.
+ *
+ * Strategy (pnpm-preferred):
+ *   1. If pnpm is installed on the system → always use pnpm
+ *      (even when invoked via `npx`, since `npx` is often used out of habit)
+ *   2. Otherwise → npm
+ *
+ * This is intentionally independent of `npm_config_user_agent` so that
+ * `npx swallowkit init` still creates a pnpm project when pnpm is available.
+ */
+export function detectFromUserAgent(): PackageManager {
+  return isPnpmInstalled() ? "pnpm" : "npm";
+}
+
+/**
+ * Check whether pnpm is available on the system PATH.
+ */
+function isPnpmInstalled(): boolean {
+  try {
+    execSync("pnpm --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Detect the package manager used in an existing project directory
+ * by checking for lockfiles.
+ *
+ * Priority: pnpm-lock.yaml > package-lock.json > fallback to detectFromUserAgent()
+ */
+export function detectFromProject(projectDir?: string): PackageManager {
+  const dir = projectDir || process.cwd();
+
+  if (fs.existsSync(path.join(dir, "pnpm-lock.yaml"))) {
+    return "pnpm";
+  }
+  if (fs.existsSync(path.join(dir, "package-lock.json"))) {
+    return "npm";
+  }
+
+  // No lockfile found — fall back to user agent detection
+  return detectFromUserAgent();
+}
+
+/**
+ * Get spawn arguments (command + args array) for the package manager.
+ * Useful when calling spawn() directly.
+ *
+ * Examples:
+ *   spawnArgs("pnpm", ["add", "next@latest"]) => { cmd: "pnpm", args: ["add", "next@latest"] }
+ *   spawnArgs("npm", ["add", "next@latest"])   => { cmd: "npm", args: ["install", "next@latest"] }
+ */
+export function spawnArgs(
+  pm: PackageManager,
+  args: string[]
+): { cmd: string; args: string[] } {
+  return { cmd: pm, args };
+}
+
+/**
+ * Workspace configuration helpers
+ */
+export function getWorkspaceConfig(pm: PackageManager, workspaces: string[]) {
+  if (pm === "pnpm") {
+    return {
+      /** pnpm uses pnpm-workspace.yaml */
+      type: "file" as const,
+      filename: "pnpm-workspace.yaml",
+      content: `packages:\n${workspaces.map((w) => `  - ${w}`).join("\n")}\n`,
+    };
+  }
+
+  // npm uses "workspaces" field in package.json
+  return {
+    type: "packageJson" as const,
+    field: "workspaces",
+    value: workspaces,
+  };
+}
+
+/**
+ * CI/CD setup step for GitHub Actions
+ */
+export function getCiSetupStep(pm: PackageManager): string {
+  if (pm === "pnpm") {
+    return `      - name: Setup pnpm
+        uses: pnpm/action-setup@v4`;
+  }
+  // npm: no extra setup needed (comes with Node.js)
+  return "";
+}
+
+/**
+ * CI/CD setup steps for Azure Pipelines
+ */
+export function getAzurePipelinesSetup(pm: PackageManager): string {
+  if (pm === "pnpm") {
+    return `  - script: |
+      corepack enable
+      corepack prepare pnpm@latest --activate
+    displayName: 'Setup pnpm'`;
+  }
+  // npm: no extra step needed
+  return "";
+}
+
+/**
+ * Build script for generated package.json (depends on workspace command syntax)
+ */
+export function getBuildScript(pm: PackageManager): string {
+  const copyStandaloneAssets = `node -e "const fs=require('fs');fs.mkdirSync('.next/standalone/.next',{recursive:true});if(fs.existsSync('.next/static'))fs.cpSync('.next/static','.next/standalone/.next/static',{recursive:true});if(fs.existsSync('public'))fs.cpSync('public','.next/standalone/public',{recursive:true});"`;
+
+  if (pm === "pnpm") {
+    return `pnpm run --filter shared build && next build --webpack && ${copyStandaloneAssets}`;
+  }
+  return `npm run --workspace=shared build && next build --webpack && ${copyStandaloneAssets}`;
+}
+
+/**
+ * Functions prestart script
+ */
+export function getFunctionsPrestart(pm: PackageManager): string {
+  if (pm === "pnpm") {
+    return "pnpm run build";
+  }
+  return "npm run build";
+}
+
+/**
+ * Functions:start script for root package.json
+ */
+export function getFunctionsStartScript(
+  pm: PackageManager,
+  backendLanguage: BackendLanguage = "typescript"
+): string {
+  if (backendLanguage === "typescript") {
+    if (pm === "pnpm") {
+      return "cd functions && pnpm start";
+    }
+    return "cd functions && npm start";
+  }
+
+  return "cd functions && func start";
+}