@getpara/cli 2.15.0

package/dist/commands/create.js

@@ -0,0 +1,587 @@
+import path from "node:path";
+import { spawn } from "node:child_process";
+import pc from "picocolors";
+import { getGlobalOptions, createFormatter, helpText } from "../cli.js";
+import { scaffold } from "../scaffolding/scaffolder.js";
+import { getStrategy, getAvailableTemplates, hasTemplate } from "../scaffolding/strategies/index.js";
+import { pathExists, removeDir, readFile, writeFile } from "../scaffolding/utils/fs.js";
+import { getWalletsForNetwork, EVM_WALLETS, SOLANA_WALLETS, COSMOS_WALLETS } from "../scaffolding/types.js";
+const ALL_VALID_WALLETS = /* @__PURE__ */ new Set([...EVM_WALLETS, ...SOLANA_WALLETS, ...COSMOS_WALLETS]);
+import {
+  detectPackageManager,
+  isValidPackageManager,
+  getInstallCommand,
+  getRunCommand
+} from "../scaffolding/utils/detect-package-manager.js";
+import { confirm, text, select, multiselect, p } from "../output/prompts.js";
+import { ensureAuthenticated } from "../auth/session-manager.js";
+import { resolveConfig } from "../config/config-manager.js";
+import { ParaApiClient } from "../api/client.js";
+import { maskSecret } from "../output/mask.js";
+function validateAppName(value) {
+  if (!value) {
+    return "App name is required";
+  }
+  if (!/^[a-z0-9-]+$/.test(value)) {
+    return "App name must be lowercase letters, numbers, and hyphens only";
+  }
+  if (value.startsWith("-") || value.endsWith("-")) {
+    return "App name cannot start or end with a hyphen";
+  }
+  return void 0;
+}
+function formatWalletName(wallet) {
+  const names = {
+    METAMASK: "MetaMask",
+    COINBASE: "Coinbase Wallet",
+    WALLETCONNECT: "WalletConnect",
+    RAINBOW: "Rainbow",
+    ZERION: "Zerion",
+    RABBY: "Rabby",
+    PHANTOM: "Phantom",
+    BACKPACK: "Backpack",
+    SOLFLARE: "Solflare",
+    GLOW: "Glow",
+    KEPLR: "Keplr",
+    LEAP: "Leap"
+  };
+  return names[wallet] || wallet;
+}
+async function runPrompts(providedName, providedTemplate, packageManager = "npm") {
+  let appName;
+  if (providedName) {
+    const err = validateAppName(providedName);
+    if (!err) {
+      appName = providedName;
+    } else {
+      appName = await text("What is your app name?", {
+        placeholder: "my-para-app",
+        initialValue: providedName,
+        validate: validateAppName
+      });
+    }
+  } else {
+    appName = await text("What is your app name?", {
+      placeholder: "my-para-app",
+      validate: validateAppName
+    });
+  }
+  let templateId;
+  if (providedTemplate && hasTemplate(providedTemplate)) {
+    templateId = providedTemplate;
+  } else {
+    const templates = getAvailableTemplates();
+    templateId = await select(
+      "Which framework?",
+      templates.map((t) => ({
+        value: t.id,
+        label: t.name,
+        hint: t.hint
+      }))
+    );
+  }
+  const networks = templateId === "expo" ? ["evm"] : await multiselect(
+    "Which networks do you want to support?",
+    [
+      { value: "evm", label: "EVM", hint: "Ethereum, Polygon, Base, etc." },
+      { value: "solana", label: "Solana" },
+      { value: "cosmos", label: "Cosmos", hint: "CosmosHub, Osmosis, etc." }
+    ],
+    { required: true, initialValues: ["evm"] }
+  );
+  const authMethodValues = await multiselect(
+    "Which authentication methods?",
+    [
+      { value: "email", label: "Email", hint: "recommended" },
+      { value: "phone", label: "Phone / SMS" },
+      { value: "oauth", label: "OAuth", hint: "Google, Apple, Twitter, etc." }
+    ],
+    { required: true, initialValues: ["email"] }
+  );
+  const authMethods = {
+    email: authMethodValues.includes("email"),
+    phone: authMethodValues.includes("phone"),
+    oauth: authMethodValues.includes("oauth")
+  };
+  const allOAuthOptions = [
+    { value: "GOOGLE", label: "Google", hint: "recommended" },
+    { value: "APPLE", label: "Apple" },
+    { value: "TWITTER", label: "Twitter / X" },
+    { value: "DISCORD", label: "Discord" },
+    { value: "FACEBOOK", label: "Facebook" },
+    { value: "FARCASTER", label: "Farcaster" }
+  ];
+  const expoOAuthProviders = /* @__PURE__ */ new Set(["GOOGLE", "APPLE"]);
+  const oauthOptions = templateId === "expo" ? allOAuthOptions.filter((o) => expoOAuthProviders.has(o.value)) : allOAuthOptions;
+  const oauthProviders = authMethods.oauth ? await multiselect("Which OAuth providers?", oauthOptions, { required: true, initialValues: ["GOOGLE"] }) : [];
+  let externalWallets = [];
+  if (templateId !== "expo") {
+    const availableWallets = networks.flatMap(getWalletsForNetwork);
+    if (availableWallets.length > 0) {
+      const walletOptions = availableWallets.map((wallet) => {
+        let hint = "";
+        if (["METAMASK", "COINBASE", "WALLETCONNECT", "RAINBOW", "ZERION", "RABBY"].includes(wallet)) {
+          hint = "EVM";
+        } else if (["PHANTOM", "BACKPACK", "SOLFLARE", "GLOW"].includes(wallet)) {
+          hint = "Solana";
+        } else if (["KEPLR", "LEAP"].includes(wallet)) {
+          hint = "Cosmos";
+        }
+        return { value: wallet, label: formatWalletName(wallet), hint };
+      });
+      externalWallets = await multiselect("Which external wallets? (optional)", walletOptions);
+    }
+  }
+  let templateSpecificConfig = {};
+  if (templateId === "expo") {
+    const sanitized = appName.toLowerCase().replace(/[^a-z0-9]/g, "");
+    const suggested = `com.mycompany.${sanitized}`;
+    const expoStrategy = getStrategy("expo");
+    const bundleId = await text("Bundle identifier (iOS & Android)?", {
+      placeholder: suggested,
+      initialValue: suggested,
+      validate: (v) => expoStrategy.validateBundleId(v)
+    });
+    templateSpecificConfig = { bundleId };
+  }
+  const baseConfig = {
+    appName,
+    template: templateId,
+    networks,
+    authMethods: {
+      ...authMethods,
+      oauthProviders
+    },
+    externalWallets,
+    packageManager
+  };
+  const config = { ...baseConfig, ...templateSpecificConfig };
+  const strategy = getStrategy(templateId);
+  const validationError = strategy.validateConfig(config);
+  if (validationError) {
+    throw new Error(`Configuration validation failed: ${validationError}`);
+  }
+  return config;
+}
+function buildConfigFromArgs(appName, opts, packageManager) {
+  const template = opts.template ?? "nextjs";
+  if (!hasTemplate(template)) {
+    throw new Error(`Unknown template: ${template}. Available: nextjs, expo`);
+  }
+  if (template === "expo") {
+    if (!opts.bundleId) {
+      throw new Error("--bundle-id is required for Expo template");
+    }
+    const expoStrategy = getStrategy("expo");
+    const bundleIdError = expoStrategy.validateBundleId(opts.bundleId);
+    if (bundleIdError) {
+      throw new Error(`Invalid bundle ID: ${bundleIdError}`);
+    }
+    if (opts.networks && opts.networks.split(",").some((n) => n !== "evm")) {
+      console.log(pc.yellow("Warning: Expo template only supports EVM. Other networks will be ignored."));
+    }
+    if (opts.wallets) {
+      console.log(pc.yellow("Warning: Expo template does not support external wallets. --wallets will be ignored."));
+    }
+  } else {
+    if (!opts.networks) {
+      throw new Error("--networks is required in non-interactive mode");
+    }
+  }
+  const parsedNetworks = template === "expo" ? ["evm"] : opts.networks?.split(",") ?? [];
+  const parsedOAuth = opts.oauth ? opts.oauth.split(",") : [];
+  let parsedWallets = [];
+  if (template !== "expo" && opts.wallets) {
+    const raw = opts.wallets.split(",").map((w) => w.trim().toUpperCase());
+    const invalid = raw.filter((w) => !ALL_VALID_WALLETS.has(w));
+    if (invalid.length > 0) {
+      throw new Error(`Invalid wallet(s): ${invalid.join(", ")}. Valid values: ${[...ALL_VALID_WALLETS].join(", ")}`);
+    }
+    parsedWallets = raw;
+  }
+  const hasEmail = opts.email ?? (!opts.phone && parsedOAuth.length === 0);
+  const hasPhone = opts.phone ?? false;
+  const hasOAuth = parsedOAuth.length > 0;
+  const baseConfig = {
+    appName,
+    template,
+    networks: parsedNetworks,
+    authMethods: {
+      email: hasEmail,
+      phone: hasPhone,
+      oauth: hasOAuth,
+      oauthProviders: parsedOAuth
+    },
+    externalWallets: parsedWallets,
+    packageManager
+  };
+  if (template === "expo") {
+    return {
+      ...baseConfig,
+      template: "expo",
+      bundleId: opts.bundleId
+    };
+  }
+  return {
+    ...baseConfig,
+    template: "nextjs"
+  };
+}
+function runCommand(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: "pipe",
+      shell: false
+    });
+    let stderr = "";
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Command failed with code ${code}: ${stderr}`));
+      }
+    });
+    child.on("error", (error) => {
+      reject(error);
+    });
+  });
+}
+async function runPostScaffold(config, silent) {
+  const projectDir = path.join(process.cwd(), config.appName);
+  const pm = config.packageManager;
+  const [installCmd, installArgs] = getInstallCommand(pm);
+  if (silent) {
+    console.log(pc.cyan("Installing dependencies..."));
+    try {
+      await runCommand(installCmd, installArgs, projectDir);
+      console.log(pc.green("\u2713"), "Dependencies installed!");
+    } catch {
+      console.log(pc.yellow("\u26A0"), `Could not install dependencies. Run \`${pm} install\` manually.`);
+    }
+    return;
+  }
+  const shouldInstall = await confirm("Install dependencies now?");
+  if (shouldInstall) {
+    const s = p.spinner();
+    s.start(`Installing dependencies with ${pm}...`);
+    try {
+      await runCommand(installCmd, installArgs, projectDir);
+      s.stop("Dependencies installed!");
+    } catch {
+      s.stop("Failed to install dependencies");
+      p.log.warn(`Could not install dependencies automatically. Please run \`${pm} install\` manually.`);
+    }
+  }
+}
+function getStartCommand(config) {
+  const script = config.template === "expo" ? "start" : "dev";
+  return getRunCommand(config.packageManager, script);
+}
+function getEnvVarName(config) {
+  return config.template === "expo" ? "EXPO_PUBLIC_PARA_API_KEY" : "NEXT_PUBLIC_PARA_API_KEY";
+}
+function isNonInteractive(appName, opts) {
+  if (!appName) return false;
+  const template = opts.template ?? "nextjs";
+  if (template === "expo") {
+    return !!opts.bundleId;
+  }
+  return !!opts.networks;
+}
+const CREATE_NEW = "__create_new__";
+async function connectProjectApiKey(targetDir, scaffoldConfig, opts, silent) {
+  try {
+    const session = await ensureAuthenticated(opts.environment);
+    if (!silent) {
+      const shouldConnect = await confirm(
+        `Signed in as ${session.email || session.userId}. Connect to a Para project to auto-configure your API key?`
+      );
+      if (!shouldConnect) return false;
+    }
+    const client = new ParaApiClient({
+      environment: opts.environment,
+      sessionId: session.sessionId
+    });
+    const config = await resolveConfig(opts);
+    let userId = session.userId;
+    if (!userId) {
+      const status = await client.getAuthStatus();
+      if (!status.userId) return false;
+      userId = status.userId;
+    }
+    const orgs = await client.getOrganizations(userId);
+    if (orgs.length === 0) return false;
+    let orgId;
+    if (orgs.length === 1) {
+      orgId = orgs[0].id;
+      if (!silent) p.log.info(`Using organization ${orgs[0].name}`);
+    } else if (silent) {
+      orgId = config.organizationId || orgs[0].id;
+    } else {
+      orgId = await select(
+        "Select organization:",
+        orgs.map((o) => ({
+          value: o.id,
+          label: o.name,
+          hint: o.id === config.organizationId ? "(active)" : void 0
+        }))
+      );
+    }
+    const projects = await client.getProjects(orgId);
+    const activeProjects = projects.filter((proj) => !proj.archived);
+    let projectId;
+    if (silent) {
+      projectId = config.projectId || activeProjects[0]?.id || "";
+      if (!projectId) return false;
+    } else {
+      const projectOptions = [
+        ...activeProjects.map((proj) => ({
+          value: proj.id,
+          label: proj.name,
+          hint: proj.id === config.projectId ? "(active)" : void 0
+        })),
+        { value: CREATE_NEW, label: "+ Create a new project", hint: void 0 }
+      ];
+      if (activeProjects.length === 0) {
+        projectId = CREATE_NEW;
+      } else if (activeProjects.length === 1) {
+        projectId = activeProjects[0].id;
+        p.log.info(`Using project ${activeProjects[0].name}`);
+      } else {
+        projectId = await select("Select project:", projectOptions);
+      }
+      if (projectId === CREATE_NEW) {
+        const projectName = await text("Project name:", {
+          placeholder: scaffoldConfig.appName,
+          initialValue: scaffoldConfig.appName,
+          validate: (v) => {
+            if (!v.trim()) return "Name is required.";
+          }
+        });
+        const newProject = await client.createProject(orgId, {
+          name: projectName,
+          framework: scaffoldConfig.template
+        });
+        projectId = newProject.id;
+        p.log.success(`Created project "${newProject.name}"`);
+      }
+    }
+    const keys = await client.getApiKeys(orgId, projectId, opts.environment);
+    const activeKeys = keys.filter((k) => !k.archived);
+    let apiKeyValue;
+    if (silent) {
+      if (activeKeys.length === 0) return false;
+      apiKeyValue = activeKeys[0].apiKey;
+    } else {
+      const keyOptions = [
+        ...activeKeys.map((k) => ({
+          value: k.apiKey,
+          label: k.displayName || k.name,
+          hint: maskSecret(k.apiKey)
+        })),
+        { value: CREATE_NEW, label: "+ Create a new key", hint: void 0 }
+      ];
+      if (activeKeys.length === 0) {
+        apiKeyValue = CREATE_NEW;
+      } else if (activeKeys.length === 1) {
+        apiKeyValue = activeKeys[0].apiKey;
+        p.log.info(`Using API key ${activeKeys[0].displayName || activeKeys[0].name}`);
+      } else {
+        apiKeyValue = await select("Select API key:", keyOptions);
+      }
+      if (apiKeyValue === CREATE_NEW) {
+        const keyName = await text("Key name:", {
+          placeholder: `${scaffoldConfig.appName}-key`,
+          initialValue: `${scaffoldConfig.appName}-key`,
+          validate: (v) => {
+            if (!v.trim()) return "Name is required.";
+          }
+        });
+        const newKey = await client.createApiKey(orgId, projectId, opts.environment, { name: keyName });
+        apiKeyValue = newKey.apiKey;
+        p.log.success(`Created API key "${keyName}"`);
+      }
+    }
+    const envExamplePath = path.join(targetDir, ".env.example");
+    const envPath = path.join(targetDir, ".env");
+    const envContent = await readFile(envExamplePath);
+    const envWithKey = envContent.replaceAll("your_api_key_here", apiKeyValue).replace(/PARA_ENVIRONMENT=\w+/, `PARA_ENVIRONMENT=${opts.environment}`);
+    await writeFile(envPath, envWithKey);
+    if (silent) {
+      console.log(pc.green("\u2713"), "API key written to .env");
+    } else {
+      p.log.success("API key written to .env");
+    }
+    return true;
+  } catch {
+    if (!silent) {
+      p.log.warn("Could not connect API key. You can add it manually to .env.");
+    }
+    return false;
+  }
+}
+function registerCreateCommand(program) {
+  program.command("create").description("Scaffold a new Para-powered application").argument("[app-name]", "Name of the application").option("-t, --template <template>", "Template to use (nextjs, expo)").option("--networks <networks>", "Comma-separated networks (evm, solana, cosmos)").option("--email", "Enable email authentication").option("--phone", "Enable phone authentication").option("--oauth <providers>", "Comma-separated OAuth providers").option("--wallets <wallets>", "Comma-separated wallet types").option("--bundle-id <id>", "Bundle ID (for Expo)").option("--package-manager <pm>", "Package manager to use (npm, yarn, pnpm, bun)").option("--skip-install", "Skip dependency installation").option("-y, --yes", "Accept all defaults (non-interactive)").addHelpText(
+    "after",
+    helpText(`Examples:
+  $ para create                               Walks you through template, networks, auth, and wallets
+  $ para create my-app                        Start interactive with a name pre-filled
+  $ para create my-app -t nextjs --networks evm --email  Fully non-interactive
+  $ para create my-app -t expo --bundle-id com.co.app    Expo app (bundle ID required)
+
+Generates a ready-to-run project with Para SDK, auth, and wallet support wired up.`)
+  ).action(async (appName, cmdOpts, cmd) => {
+    const opts = await getGlobalOptions(cmd);
+    const formatter = createFormatter(opts);
+    if (cmdOpts.packageManager && !isValidPackageManager(cmdOpts.packageManager)) {
+      formatter.error(`Invalid package manager: "${cmdOpts.packageManager}". Must be one of: npm, yarn, pnpm, bun`);
+      process.exit(1);
+    }
+    const packageManager = detectPackageManager(cmdOpts.packageManager);
+    let config;
+    if (isNonInteractive(appName, cmdOpts)) {
+      console.log(pc.cyan("@getpara/cli create"), pc.dim("(non-interactive mode)"));
+      console.log();
+      try {
+        config = buildConfigFromArgs(appName, cmdOpts, packageManager);
+      } catch (error) {
+        formatter.error(error.message);
+        console.log(pc.dim("Run with --help for usage information."));
+        process.exit(1);
+      }
+      console.log(pc.dim("Configuration:"));
+      console.log(pc.dim(`  Template: ${config.template}`));
+      console.log(pc.dim(`  App name: ${config.appName}`));
+      console.log(pc.dim(`  Package manager: ${config.packageManager}`));
+      if (config.template === "expo") {
+        console.log(pc.dim(`  Bundle ID: ${config.bundleId}`));
+      }
+      console.log(pc.dim(`  Networks: ${config.networks.join(", ")}`));
+      console.log(
+        pc.dim(
+          `  Auth: ${[
+            config.authMethods.email && "email",
+            config.authMethods.phone && "phone",
+            config.authMethods.oauth && `oauth(${config.authMethods.oauthProviders.join(",")})`
+          ].filter(Boolean).join(", ")}`
+        )
+      );
+      if (config.externalWallets.length > 0) {
+        console.log(pc.dim(`  Wallets: ${config.externalWallets.join(", ")}`));
+      }
+      console.log();
+    } else {
+      console.log();
+      p.intro(pc.bgCyan(pc.black(" @getpara/cli create ")));
+      try {
+        p.log.info(`Using ${pc.cyan(packageManager)} as package manager`);
+        config = await runPrompts(appName, cmdOpts.template, packageManager);
+      } catch (error) {
+        if (error instanceof Error && error.message === "cancelled") {
+          p.cancel("Operation cancelled.");
+          process.exit(0);
+        }
+        throw error;
+      }
+    }
+    const targetDir = path.join(process.cwd(), config.appName);
+    if (await pathExists(targetDir)) {
+      if (isNonInteractive(appName, cmdOpts)) {
+        if (cmdOpts.yes) {
+          console.log(pc.yellow(`Overwriting existing directory: ${config.appName}`));
+          await removeDir(targetDir);
+        } else {
+          formatter.error(`Directory ${config.appName} already exists.`);
+          console.log(pc.dim("Use --yes to overwrite."));
+          process.exit(1);
+        }
+      } else {
+        const shouldOverwrite = await confirm(`Directory ${pc.cyan(config.appName)} already exists. Overwrite?`);
+        if (!shouldOverwrite) {
+          p.cancel("Operation cancelled.");
+          process.exit(0);
+        }
+        const s = p.spinner();
+        s.start("Removing existing directory...");
+        await removeDir(targetDir);
+        s.stop("Removed existing directory");
+      }
+    }
+    if (isNonInteractive(appName, cmdOpts)) {
+      console.log(pc.cyan("Creating project..."));
+      await scaffold(config);
+      console.log(pc.green("\u2713"), "Project created!");
+      const envWritten = await connectProjectApiKey(targetDir, config, opts, true);
+      if (!cmdOpts.skipInstall) {
+        await runPostScaffold(config, true);
+      }
+      console.log();
+      console.log(pc.green("Done!"), `Your Para app is ready at ${pc.cyan(config.appName)}`);
+      console.log();
+      console.log(pc.dim("Next steps:"));
+      console.log(`  cd ${config.appName}`);
+      if (!envWritten) {
+        console.log("  cp .env.example .env");
+        console.log(`  # Add your ${getEnvVarName(config)} to .env`);
+      }
+      if (cmdOpts.skipInstall) {
+        console.log(`  ${config.packageManager} install`);
+      }
+      if (config.template === "expo") {
+        console.log("  npx expo prebuild");
+        console.log(
+          `  ${getRunCommand(config.packageManager, "ios")}  # or ${getRunCommand(config.packageManager, "android")}`
+        );
+      } else {
+        console.log(`  ${getStartCommand(config)}`);
+      }
+      console.log();
+    } else {
+      const s = p.spinner();
+      s.start("Creating your Para app...");
+      try {
+        await scaffold(config);
+        s.stop("Project created!");
+        const envWritten = await connectProjectApiKey(targetDir, config, opts, false);
+        if (!cmdOpts.skipInstall) {
+          await runPostScaffold(config, false);
+        }
+        console.log();
+        p.outro(pc.green("Your Para app is ready!"));
+        console.log();
+        console.log(pc.dim("  Next steps:"));
+        console.log();
+        console.log(`  ${pc.cyan("cd")} ${config.appName}`);
+        if (!envWritten) {
+          console.log(`  ${pc.cyan("cp")} .env.example .env`);
+          console.log(`  ${pc.dim(`# Add your ${getEnvVarName(config)} to .env`)}`);
+        }
+        if (config.template === "expo") {
+          console.log(`  ${pc.cyan("npx")} expo prebuild`);
+          const iosCmd = getRunCommand(config.packageManager, "ios");
+          const androidCmd = getRunCommand(config.packageManager, "android");
+          const iosParts = iosCmd.split(" ");
+          console.log(`  ${pc.cyan(iosParts[0])} ${iosParts.slice(1).join(" ")}  ${pc.dim(`# or ${androidCmd}`)}`);
+        } else {
+          const parts = getStartCommand(config).split(" ");
+          console.log(`  ${pc.cyan(parts[0])} ${parts.slice(1).join(" ")}`);
+        }
+        if (!envWritten) {
+          console.log();
+          console.log(pc.dim(`  Get your API key at ${pc.underline("https://developer.getpara.com")}`));
+        }
+        console.log();
+      } catch (error) {
+        s.stop("Failed to create project");
+        throw error;
+      }
+    }
+  });
+}
+export {
+  registerCreateCommand
+};

package/dist/commands/doctor.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function registerDoctorCommand(program: Command): void;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/commands/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../src/commands/doctor.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQzC,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA6E5D"}

package/dist/commands/doctor.js

@@ -0,0 +1,67 @@
+import { resolve } from "node:path";
+import pc from "picocolors";
+import { getGlobalOptions, createFormatter, helpText } from "../cli.js";
+import { createContext } from "../diagnostics/context.js";
+import { runChecks } from "../diagnostics/runner.js";
+import { allChecks } from "../diagnostics/checks/index.js";
+function registerDoctorCommand(program) {
+  program.command("doctor").description("Diagnose common Para SDK integration issues").argument("[path]", "Project path to diagnose", ".").option("--category <category>", "Filter checks by category").option("--severity <severity>", "Minimum severity (error, warning, info)").addHelpText(
+    "after",
+    helpText(`Examples:
+  $ para doctor                       Diagnose current directory
+  $ para doctor ./my-app              Diagnose a specific project
+  $ para doctor --category auth       Only run auth-related checks
+  $ para doctor --severity error      Only show errors`)
+  ).action(async (projectPath, cmdOpts, cmd) => {
+    const opts = await getGlobalOptions(cmd);
+    const formatter = createFormatter(opts);
+    const absolutePath = resolve(projectPath);
+    const context = await createContext(absolutePath);
+    const checkOptions = {};
+    if (cmdOpts.category) {
+      checkOptions.categories = [cmdOpts.category];
+    }
+    if (cmdOpts.severity) {
+      checkOptions.severity = cmdOpts.severity;
+    }
+    const runResult = await runChecks(allChecks, context, checkOptions);
+    if (opts.json) {
+      formatter.json({
+        projectInfo: {
+          framework: context.framework,
+          sdkType: context.sdkType,
+          sdkVersion: context.sdkVersion || "unknown",
+          packageManager: context.packageManager
+        },
+        results: runResult.results,
+        summary: {
+          total: runResult.total,
+          passed: runResult.passed,
+          failed: runResult.failed,
+          warnings: runResult.warnings
+        }
+      });
+      formatter.flush();
+    } else {
+      console.log("");
+      console.log(`Project: ${context.framework} + ${context.sdkType}`);
+      console.log("");
+      for (const result of runResult.results) {
+        const icon = result.passed ? pc.green("\u2713") : result.severity === "error" ? pc.red("\u2717") : pc.yellow("\u26A0");
+        console.log(`  ${icon} ${result.message}`);
+        if (!result.passed && result.recommendation) {
+          console.log(pc.dim(`    \u2192 ${result.recommendation}`));
+        }
+      }
+      console.log("");
+      console.log(
+        `${runResult.passed}/${runResult.total} checks passed` + (runResult.failed ? `, ${pc.red(`${runResult.failed} errors`)}` : "") + (runResult.warnings ? `, ${pc.yellow(`${runResult.warnings} warnings`)}` : "")
+      );
+    }
+    const hasFailures = runResult.results.some((r) => !r.passed && r.severity === "error");
+    if (hasFailures) process.exit(1);
+  });
+}
+export {
+  registerDoctorCommand
+};

package/dist/commands/init.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from 'commander';
+export declare function registerInitCommand(program: Command): void;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQzC,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA+C1D"}