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

package/src/cli/index.ts

@@ -0,0 +1,352 @@
+#!/usr/bin/env node
+
+import { execSync } from "child_process";
+import { readFileSync } from "fs";
+import * as path from "path";
+import { Command } from "commander";
+import { initCommand, devCommand, devSeedsCommand, scaffoldCommand, createModelCommand } from "./commands";
+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");
+export const CLI_VERSION = JSON.parse(readFileSync(packageJsonPath, "utf8")).version as string;
+
+const DEV_OPTION_ARITY = new Map<string, 0 | 1>([
+  ["-p", 1],
+  ["--port", 1],
+  ["-f", 1],
+  ["--functions-port", 1],
+  ["--host", 1],
+  ["--seed-env", 1],
+  ["-o", 0],
+  ["--open", 0],
+  ["-v", 0],
+  ["--verbose", 0],
+  ["--no-functions", 0],
+  ["--mock-connectors", 0],
+  ["--swa-port", 1],
+  ["--no-swa", 0],
+]);
+
+function ensureUtf8ConsoleOnWindows(): void {
+  if (process.platform === 'win32') {
+    try {
+      execSync('chcp 65001', { stdio: 'ignore' });
+    } catch {
+      // ignore — non-critical
+    }
+  }
+}
+
+function isDevOptionSequence(tokens: string[]): boolean {
+  if (tokens.length === 0) {
+    return false;
+  }
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    const arity = DEV_OPTION_ARITY.get(token);
+
+    if (arity === undefined) {
+      return false;
+    }
+
+    if (arity === 1) {
+      const value = tokens[index + 1];
+      if (value === undefined || value === "dev") {
+        return false;
+      }
+      index += 1;
+    }
+  }
+
+  return true;
+}
+
+export function normalizeDevCommandArgv(argv: string[]): string[] {
+  if (argv.length <= 3) {
+    return argv;
+  }
+
+  const prefix = argv.slice(0, 2);
+  const args = argv.slice(2);
+  const devIndex = args.indexOf("dev");
+
+  if (devIndex <= 0) {
+    return argv;
+  }
+
+  const leadingTokens = args.slice(0, devIndex);
+  if (!isDevOptionSequence(leadingTokens)) {
+    return argv;
+  }
+
+  return [
+    ...prefix,
+    "dev",
+    ...leadingTokens,
+    ...args.slice(devIndex + 1),
+  ];
+}
+
+export function createProgram(devCommandOverride: Command = devCommand): Command {
+  const program = new Command();
+
+  program
+    .name("swallowkit")
+    .description("Next.js framework optimized for Azure deployment - Automatically splits SSR into individual Azure Functions")
+    .version(CLI_VERSION);
+
+  // Register commands
+  program
+    .command("init [project-name]")
+    .description("Initialize a new SwallowKit project")
+    .option("--template <template>", "Template to use", "default")
+    .option("--next-version <version>", "Next.js version to install (e.g., 16.0.7, latest)", "latest")
+    .option("--package-manager <manager>", "Package manager: npm | pnpm (defaults to invocation context)")
+    .option("--cicd <provider>", "CI/CD provider: github | azure | skip")
+    .option("--backend-language <language>", "Azure Functions backend language: typescript | csharp | python")
+    .option("--cosmos-db-mode <mode>", "Cosmos DB mode: freetier | serverless")
+    .option("--vnet <option>", "Network security: outbound | none")
+    .option("--swa-plan <plan>", "Azure Static Web Apps plan: free | standard")
+    .action((projectName, options) => {
+      initCommand({
+        name: projectName || "swallowkit-app",
+        template: options.template,
+        nextVersion: options.nextVersion,
+        packageManager: options.packageManager,
+        cicd: options.cicd,
+        backendLanguage: options.backendLanguage,
+        cosmosDbMode: options.cosmosDbMode,
+        vnet: options.vnet,
+        swaPlan: options.swaPlan,
+      });
+    });
+
+  program.addCommand(devCommandOverride);
+  program.addCommand(devSeedsCommand);
+
+  program.addCommand(provisionCommand);
+
+  program
+    .command("create-model <names...>")
+    .description("Create model template files with id, createdAt, and updatedAt fields")
+    .option("--models-dir <dir>", "Models directory", "shared/models")
+    .option("--connector <name>", "Associate model with a connector defined in swallowkit.config.js")
+    .action((names, options) => {
+      createModelCommand({
+        names,
+        modelsDir: options.modelsDir,
+        connector: options.connector,
+      });
+    });
+
+  program
+    .command("scaffold <model>")
+    .description("Generate CRUD code for Azure Functions and Next.js BFF from Zod models")
+    .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)
+    .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,
+        apiOnly: options.apiOnly,
+      });
+    });
+
+  program
+    .command("add-connector <name>")
+    .description("Add an external data source connector configuration")
+    .requiredOption("--type <type>", "Connector type: rdb | api")
+    .option("--provider <provider>", "RDB provider: mysql | postgres | sqlserver", "mysql")
+    .action((name, options) => {
+      addConnectorCommand({
+        name,
+        type: options.type,
+        provider: options.provider,
+      });
+    });
+
+  program
+    .command("add-auth")
+    .description("Add authentication and authorization to the project")
+    .option("--provider <provider>", "Auth provider: custom-jwt | swa | external-token | swa-custom | none", "custom-jwt")
+    .option("--scheme <name>", "Add a named authentication scheme")
+    .option("--allowed-providers <list>", "Comma-separated SWA identity providers to allow (e.g. github,aad); defaults to aad")
+    .action((options) => {
+      addAuthCommand({
+        provider: options.provider,
+        scheme: options.scheme,
+        allowedProviders: options.allowedProviders ? String(options.allowedProviders).split(",") : undefined,
+      });
+    });
+
+  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)) {
+    await runMachineCli(argv);
+    return;
+  }
+
+  await createProgram().parseAsync(normalizeDevCommandArgv(argv));
+}
+
+if (require.main === module) {
+  void runCli().catch((error) => {
+    console.error(error);
+    process.exitCode = 1;
+  });
+}