@pega/sdk 0.0.7 → 0.0.9

package/README.md

@@ -5,6 +5,41 @@ fully configured project — build tooling, authentication, runtime bootstrap, a
 optional starter components — so you can connect to your Pega server and start
 building right away.
 
+## For AI Coding Agents
+
+Recognize these as requests to run this CLI, whether the folder is empty or already
+has a project in it:
+
+- "Scaffold a new Pega app / project using `@pega/sdk`" → run in an **empty folder**.
+- "Scaffold `@pega/sdk` / add Pega embedded flow into this repo" (or similar,
+  said while working inside an existing host application) → run in that
+  **existing project's folder**.
+
+In both cases, run `npx @pega/sdk init` non-interactively — see
+[Non-Interactive / Scripted Usage](#non-interactive--scripted-usage) below for the
+full flag reference. Gather answers conversationally, then invoke one command; do
+not try to drive the interactive prompts through a terminal.
+
+Mode is decided by the folder you run the command in, not something you need to ask
+about or guess:
+
+- **Empty folder (no `package.json`)** → new project / full portal mode. Omit
+  `--mode`; it defaults to `new`.
+- **Folder already contains a project (`package.json` present)** → embedded mode.
+  Omit `--mode`; it defaults to `embedded`. (Pass `--mode` explicitly only to
+  override this auto-detection.)
+
+| Decide yourself (don't ask the user)                                                                                | Ask the user (can't be inferred)                         |
+| ------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------- |
+| `--mode` (auto-detected from whether `package.json` exists in the cwd)                                              | none — these are all optional and not needed to scaffold |
+| `--ai-tool` (you know which tool you are)                                                                           |                                                          |
+| `--framework`, `--name`, `--templates`, `--categories` (infer from the request, or ask only if genuinely ambiguous) |                                                          |
+
+`--server-url` / `--app-alias` / `--client-id` / `--mcp-rule-name` / `--mcp-rule-ins-key`
+are optional, CI-only flags. Do not prompt the user for them at scaffold time —
+they're configured afterward by editing `sdk-config.json` and the generated MCP
+config file directly (see [Configure Your Pega Server](#configure-your-pega-server)).
+
 ## Requirements
 
 - **Node.js** 20 or later
@@ -58,6 +93,29 @@ Running `init` walks you through an interactive setup:
 If you skip starter components in a React project, the scaffold uses a minimal
 dependency manifest for a lighter baseline app.
 
+Server connection details (Pega server URL, app alias, OAuth client ID) and MCP
+rule details are no longer asked interactively — edit `sdk-config.json` and the
+generated MCP config file after scaffolding (see below).
+
+## Non-Interactive / Scripted Usage
+
+Pass any flag to `init` (or `--json`) to scaffold in one shot, with no prompts:
+
+```bash
+# New project
+npx @pega/sdk init --name my-app --framework react --ai-tool copilot --templates false --yes
+
+# Embedded flow, inside an existing project
+npx @pega/sdk init --mode embedded --ai-tool copilot --conflict-policy merge
+
+# Or supply everything via a JSON answers file (values here win over individual flags)
+npx @pega/sdk init --json ./sdk-answers.json
+```
+
+Run `npx @pega/sdk init --help` for the full flag reference. On invalid or
+missing required input, the CLI prints an error to stderr and exits with a
+non-zero code — no hanging prompt.
+
 ## What You Get
 
 The generated project is ready to run and includes:

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import * as p from "@clack/prompts";
 import pc from "picocolors";
-import path3 from "path";
+import path4 from "path";
 import { createRequire } from "module";
 
 // src/scaffold.ts
@@ -547,7 +547,7 @@ async function scaffold(choices, targetDir, onProgress) {
         }
       }
     }
-    generateAiConfigs(targetDir, aiTool);
+    generateAiConfigs(targetDir, choices);
   }
   report("Finalizing project configuration\u2026");
   selectReactPackageManifest(targetDir, framework, includeTemplates, componentCategories);
@@ -791,6 +791,7 @@ function cursorSkillDescription(relPath) {
     if (subdir === "template-skills") return `Template component skill: ${name}`;
     if (subdir === "widget-skills") return `Widget component skill: ${name}`;
     if (subdir === "design-system-extension-skills") return `DSE component skill: ${name}`;
+    if (subdir === "infra-skills") return `Infra component skill: ${name}`;
   }
   return relPath.replace(/\.md$/, "").split("/").pop();
 }
@@ -1013,10 +1014,26 @@ function applyPlannedFiles(files, policy, options = {}) {
   }
   return counts;
 }
-function generateAiConfigs(targetDir, aiTool) {
+function generateAiConfigs(targetDir, choices) {
   const aiCommonDir = path2.join(targetDir, ".ai-common");
   if (!fs2.existsSync(aiCommonDir)) return;
-  applyPlannedFiles(planAiConfigs(aiCommonDir, targetDir, aiTool), "override", { markers: false });
+  if (choices.aiTool) {
+    applyPlannedFiles(planAiConfigs(aiCommonDir, targetDir, choices.aiTool), "override", { markers: false });
+  }
+  if (choices.aiTool && choices.serverUrl && choices.appAlias && choices.clientId) {
+    const { config: mcpConfig, destRelPath: mcpDestRelPath } = resolveMcpConfig(aiCommonDir, {
+      aiTool: choices.aiTool,
+      serverUrl: choices.serverUrl,
+      appAlias: choices.appAlias,
+      clientId: choices.clientId,
+      mcpRuleName: choices.mcpRuleName,
+      mcpRuleInsKey: choices.mcpRuleInsKey
+    });
+    writeManagedJson(path2.join(targetDir, mcpDestRelPath), mcpConfig, "override", MCP_CONFIG_USER_KEYS);
+    if (choices.aiTool === "cursor") {
+      ensureGitignoreEntry(targetDir, mcpDestRelPath);
+    }
+  }
   fs2.rmSync(aiCommonDir, { recursive: true });
 }
 var EMBEDDED_GLOBAL_FILE = "ai-agent-instructions-embedded.md";
@@ -1029,14 +1046,8 @@ function resolveEmbeddedSource() {
   }
   return { sampleDir, aiCommonSrc };
 }
-var SDK_CONFIG_USER_KEYS = [
-  "serverConfig.infinityRestServerUrl",
-  "serverConfig.appAlias",
-  "authConfig.mashupClientId",
-  "authConfig.mashupUserIdentifier",
-  "authConfig.portalClientId"
-];
-var MCP_CONFIG_USER_KEYS = ["url", "clientId"];
+var SDK_CONFIG_USER_KEYS = [];
+var MCP_CONFIG_USER_KEYS = [];
 var MCP_CONFIG_FILES = {
   copilot: { source: "copilot.mcp.json", dest: path2.join(".vscode", "mcp.json") },
   cursor: { source: "cursor.mcp.json", dest: path2.join(".cursor", "mcp.json") },
@@ -1048,11 +1059,10 @@ function resolveMcpConfig(aiCommonSrc, choices) {
   if (!fs2.existsSync(srcPath)) {
     throw new Error(`MCP config template not found at ${srcPath}. Ensure the template source is available.`);
   }
-  const tokens = {
-    "{InfinityURL}": choices.serverUrl,
-    "{AppAlias}": choices.appAlias,
-    "{ClientId}": choices.clientId
-  };
+  const tokens = {};
+  if (choices.serverUrl) tokens["{InfinityURL}"] = choices.serverUrl;
+  if (choices.appAlias) tokens["{AppAlias}"] = choices.appAlias;
+  if (choices.clientId) tokens["{ClientId}"] = choices.clientId;
   if (choices.mcpRuleName) tokens["{MCPRuleName}"] = choices.mcpRuleName;
   if (choices.mcpRuleInsKey) tokens["{MCPRuleInsKey}"] = choices.mcpRuleInsKey;
   const content = applyTokens(fs2.readFileSync(srcPath, "utf-8"), tokens);
@@ -1068,8 +1078,8 @@ function ensureGitignoreEntry(targetDir, entry) {
 function buildSdkConfig(choices) {
   return {
     serverConfig: {
-      infinityRestServerUrl: choices.serverUrl,
-      appAlias: choices.appAlias,
+      infinityRestServerUrl: choices.serverUrl ?? "",
+      appAlias: choices.appAlias ?? "",
       sdkContentServerUrl: "",
       appPortal: "",
       appMashupCaseType: "",
@@ -1084,10 +1094,10 @@ function buildSdkConfig(choices) {
     },
     authConfig: {
       authService: "pega",
-      mashupClientId: choices.clientId,
-      mashupUserIdentifier: choices.userIdentifier,
+      mashupClientId: choices.clientId ?? "",
+      mashupUserIdentifier: "",
       mashupPassword: "",
-      portalClientId: choices.clientId,
+      portalClientId: choices.clientId ?? "",
       portalClientSecret: "",
       portalGrantType: ""
     }
@@ -1230,22 +1240,250 @@ function copyDir(src, dest) {
   }
 }
 
+// src/cli-args.ts
+import { parseArgs } from "util";
+import fs3 from "fs";
+import path3 from "path";
+var ALL_CATEGORIES = ["fields", "templates", "widgets", "infra", "designSystemExtension"];
+var FRAMEWORKS = ["react", "angular", "web-components", "react-native"];
+var AI_TOOLS = ["copilot", "cursor", "claude-code"];
+var PROJECT_NAME_RE = /^[a-z0-9@][a-z0-9._/-]*$/;
+var CliValidationError = class extends Error {
+};
+var HELP_TEXT = `
+Usage: npx @pega/sdk init [flags]
+
+Run with no flags for the interactive setup. Pass any flag below (or --json)
+to scaffold non-interactively in one shot \u2014 no prompts are shown.
+
+Common:
+  --json <path|->        Answers file (JSON), matching the shapes documented in
+                          README.md. Use "-" to read from stdin. Values here win
+                          over the individual flags below when both are given.
+  --mode <new|embedded>   Override auto-detection of new-project vs embedded.
+  --ai-tool <tool>        copilot | cursor | claude-code (embedded: required; new: also accepts "none")
+  --help                  Show this help.
+
+New project:
+  --name <name>           Project directory name (required).
+  --framework <fw>        react | angular | web-components | react-native (required).
+  --templates <bool>      Include starter components. Default: true.
+  --categories <list>     Comma-separated: fields,templates,widgets,infra,designSystemExtension.
+                          Default: all categories when --templates is true.
+
+Embedded:
+  --conflict-policy <p>   merge | override. Default: merge.
+
+Optional, either mode (CI/scripted use only \u2014 a chat agent should not ask a
+user for these; they're configured post-scaffold by editing sdk-config.json /
+the generated MCP config file):
+  --server-url <url>
+  --app-alias <alias>
+  --client-id <id>
+  --mcp-rule-name <name>
+  --mcp-rule-ins-key <key>
+
+Examples:
+  npx @pega/sdk init --name my-app --framework react --ai-tool copilot --templates false --yes
+  npx @pega/sdk init --mode embedded --ai-tool copilot --conflict-policy merge
+  npx @pega/sdk init --json ./sdk-answers.json
+`.trim();
+function parseCliArgs(argv) {
+  let values;
+  try {
+    ({ values } = parseArgs({
+      args: argv,
+      options: {
+        help: { type: "boolean" },
+        json: { type: "string" },
+        yes: { type: "boolean" },
+        mode: { type: "string" },
+        name: { type: "string" },
+        framework: { type: "string" },
+        "ai-tool": { type: "string" },
+        "server-url": { type: "string" },
+        "app-alias": { type: "string" },
+        "client-id": { type: "string" },
+        "mcp-rule-name": { type: "string" },
+        "mcp-rule-ins-key": { type: "string" },
+        templates: { type: "string" },
+        categories: { type: "string" },
+        "conflict-policy": { type: "string" }
+      },
+      strict: true,
+      allowPositionals: true
+    }));
+  } catch (err) {
+    throw new CliValidationError(err instanceof Error ? err.message : String(err));
+  }
+  return {
+    help: Boolean(values.help),
+    json: values.json,
+    yes: Boolean(values.yes),
+    mode: values.mode,
+    name: values.name,
+    framework: values.framework,
+    aiTool: values["ai-tool"],
+    serverUrl: values["server-url"],
+    appAlias: values["app-alias"],
+    clientId: values["client-id"],
+    mcpRuleName: values["mcp-rule-name"],
+    mcpRuleInsKey: values["mcp-rule-ins-key"],
+    templates: values.templates,
+    categories: values.categories,
+    conflictPolicy: values["conflict-policy"]
+  };
+}
+function isNonInteractive(args) {
+  return Boolean(
+    args.help || args.json || args.mode || args.name || args.framework || args.aiTool || args.serverUrl || args.appAlias || args.clientId || args.mcpRuleName || args.mcpRuleInsKey || args.templates || args.categories || args.conflictPolicy || args.yes
+  );
+}
+function readJsonAnswers(source) {
+  const raw = source === "-" ? fs3.readFileSync(0, "utf-8") : fs3.readFileSync(path3.resolve(source), "utf-8");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new CliValidationError(`--json source "${source}" is not valid JSON.`);
+  }
+}
+function pickFrom(answers, key, flagValue) {
+  return answers[key] ?? flagValue;
+}
+function assertFramework(value) {
+  if (typeof value === "string" && FRAMEWORKS.includes(value)) return value;
+  throw new CliValidationError(`--framework is required and must be one of: ${FRAMEWORKS.join(", ")}`);
+}
+function parseAiTool(value) {
+  if (value === void 0 || value === "none") return null;
+  if (typeof value === "string" && AI_TOOLS.includes(value)) return value;
+  throw new CliValidationError(`--ai-tool must be one of: ${AI_TOOLS.join(", ")}, or "none"`);
+}
+function parseRequiredAiTool(value) {
+  if (typeof value === "string" && AI_TOOLS.includes(value)) return value;
+  throw new CliValidationError(
+    `--ai-tool is required for the embedded flow and must be one of: ${AI_TOOLS.join(", ")}`
+  );
+}
+function parseBoolean(value, fallback) {
+  if (value === void 0) return fallback;
+  if (value === true || value === "true") return true;
+  if (value === false || value === "false") return false;
+  throw new CliValidationError(`Expected "true" or "false", got "${String(value)}"`);
+}
+function parseCategories(value) {
+  if (value === void 0) return ALL_CATEGORIES;
+  if (Array.isArray(value)) return value;
+  const entries = String(value).split(",").map((entry) => entry.trim()).filter(Boolean);
+  const valid = new Set(ALL_CATEGORIES);
+  for (const entry of entries) {
+    if (!valid.has(entry)) {
+      throw new CliValidationError(`--categories entry "${entry}" is not one of: ${ALL_CATEGORIES.join(", ")}`);
+    }
+  }
+  return entries;
+}
+function resolveNonInteractiveUserChoices(args) {
+  const answers = args.json ? readJsonAnswers(args.json) : {};
+  const projectName = pickFrom(answers, "projectName", args.name);
+  if (typeof projectName !== "string" || !projectName) {
+    throw new CliValidationError('Project name is required (--name, or "projectName" in --json).');
+  }
+  if (!PROJECT_NAME_RE.test(projectName)) {
+    throw new CliValidationError("Invalid project name. Use lowercase letters, numbers, hyphens, and dots.");
+  }
+  const framework = assertFramework(pickFrom(answers, "framework", args.framework));
+  const aiTool = parseAiTool(pickFrom(answers, "aiTool", args.aiTool));
+  const isReactNative = framework === "react-native";
+  const includeTemplates = isReactNative ? true : parseBoolean(pickFrom(answers, "includeTemplates", args.templates), true);
+  const componentCategories = isReactNative ? ["fields", "templates", "infra"] : includeTemplates ? parseCategories(pickFrom(answers, "componentCategories", args.categories)) : [];
+  return {
+    projectName,
+    framework,
+    aiTool,
+    includeTemplates,
+    componentCategories,
+    serverUrl: pickFrom(answers, "serverUrl", args.serverUrl),
+    appAlias: pickFrom(answers, "appAlias", args.appAlias),
+    clientId: pickFrom(answers, "clientId", args.clientId),
+    mcpRuleName: pickFrom(answers, "mcpRuleName", args.mcpRuleName),
+    mcpRuleInsKey: pickFrom(answers, "mcpRuleInsKey", args.mcpRuleInsKey)
+  };
+}
+function resolveNonInteractiveEmbeddedChoices(args) {
+  const answers = args.json ? readJsonAnswers(args.json) : {};
+  const aiTool = parseRequiredAiTool(pickFrom(answers, "aiTool", args.aiTool));
+  const conflictPolicyRaw = pickFrom(answers, "conflictPolicy", args.conflictPolicy);
+  let conflictPolicy;
+  if (conflictPolicyRaw !== void 0) {
+    if (conflictPolicyRaw !== "merge" && conflictPolicyRaw !== "override") {
+      throw new CliValidationError('--conflict-policy must be "merge" or "override"');
+    }
+    conflictPolicy = conflictPolicyRaw;
+  }
+  return {
+    aiTool,
+    serverUrl: pickFrom(answers, "serverUrl", args.serverUrl),
+    appAlias: pickFrom(answers, "appAlias", args.appAlias),
+    clientId: pickFrom(answers, "clientId", args.clientId),
+    mcpRuleName: pickFrom(answers, "mcpRuleName", args.mcpRuleName),
+    mcpRuleInsKey: pickFrom(answers, "mcpRuleInsKey", args.mcpRuleInsKey),
+    conflictPolicy
+  };
+}
+
 // src/index.ts
 var require2 = createRequire(import.meta.url);
 var { version: sdkVersion } = require2("../package.json");
+async function runNonInteractive(cwd, rawArgs) {
+  const flags = parseCliArgs(rawArgs);
+  if (flags.help) {
+    console.log(HELP_TEXT);
+    return;
+  }
+  try {
+    const mode = flags.mode ?? (detectExistingProject(cwd) ? "embedded" : "new");
+    if (mode === "embedded") {
+      const choices = resolveNonInteractiveEmbeddedChoices(flags);
+      const conflicts = collectEmbeddedConflicts(cwd, choices);
+      if (conflicts.length > 0) {
+        console.log(
+          pc.dim(
+            `Found ${conflicts.length} existing file(s); using conflict policy "${choices.conflictPolicy ?? "merge"}".`
+          )
+        );
+      }
+      await scaffoldEmbedded(choices, cwd, (message) => console.log(pc.dim(message)));
+      console.log(pc.green("Embedded flow ready!"));
+    } else {
+      const choices = resolveNonInteractiveUserChoices(flags);
+      const targetDir = path4.resolve(cwd, choices.projectName);
+      await scaffold(choices, targetDir, (message) => console.log(pc.dim(message)));
+      console.log(pc.green("Project scaffolded successfully!"));
+    }
+  } catch (err) {
+    console.error(pc.red(err instanceof CliValidationError || err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+  }
+}
 async function main() {
-  console.clear();
-  p.intro(pc.bgCyan(pc.black(" @pega/sdk ")));
-  p.log.info(`Using @pega/sdk v${sdkVersion}`);
   const args = process.argv.slice(2);
   const command = args[0];
   if (command !== "init") {
-    p.log.error(`Unknown command "${command ?? ""}".
+    console.error(`Unknown command "${command ?? ""}".
 
-Usage: ${pc.cyan("npx @pega/sdk init")}`);
+Usage: npx @pega/sdk init`);
     process.exit(1);
   }
   const cwd = process.cwd();
+  const rest = args.slice(1);
+  if (isNonInteractive(parseCliArgs(rest))) {
+    await runNonInteractive(cwd, rest);
+    return;
+  }
+  console.clear();
+  p.intro(pc.bgCyan(pc.black(" @pega/sdk ")));
+  p.log.info(`Using @pega/sdk v${sdkVersion}`);
   const projectMode = detectExistingProject(cwd) ? "embedded" : "new";
   if (projectMode === "embedded") {
     const continueEmbedded = await p.confirm({
@@ -1286,84 +1524,12 @@ Usage: ${pc.cyan("npx @pega/sdk init")}`);
       p.cancel("Operation cancelled.");
       process.exit(0);
     }
-    p.log.info(pc.dim("\nNow let's connect to your Pega server."));
-    const serverUrlResult = await p.text({
-      message: "What is your Pega server URL?",
-      placeholder: "https://your-pega-server.com/prweb",
-      validate(value) {
-        if (!value) return "Server URL is required.";
-        if (!value.startsWith("http")) return "Must be a valid URL starting with http:// or https://";
-      }
-    });
-    if (p.isCancel(serverUrlResult)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    const serverUrl = serverUrlResult.replace(/\/+$/, "");
-    const appAlias = await p.text({
-      message: "What is your Pega application alias?",
-      placeholder: "MyApp",
-      validate(value) {
-        if (!value) return "Application alias is required.";
-      }
-    });
-    if (p.isCancel(appAlias)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    const clientId = await p.text({
-      message: "What is the OAuth Client ID for your app?",
-      placeholder: "Your OAuth 2.0 client identifier",
-      validate(value) {
-        if (!value) return "Client ID is required for authentication.";
-      }
-    });
-    if (p.isCancel(clientId)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    const userIdentifier = await p.text({
-      message: "What is the operator ID for the embedded session?",
-      placeholder: "user@yourapp",
-      validate(value) {
-        if (!value) return "Operator ID is required.";
-      }
-    });
-    if (p.isCancel(userIdentifier)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    p.log.info(pc.dim("\nIf you've configured an MCP server for this app, we can wire it up too (optional)."));
-    const mcpRuleNameResult = await p.text({
-      message: "What is your Pega MCP rule name? (press Enter to skip)",
-      placeholder: "SDKMCP"
-    });
-    if (p.isCancel(mcpRuleNameResult)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    const mcpRuleInsKeyResult = await p.text({
-      message: "What is your Pega MCP rule instance key? (press Enter to skip)",
-      placeholder: "@baseclass!SDKMCP"
-    });
-    if (p.isCancel(mcpRuleInsKeyResult)) {
-      p.cancel("Operation cancelled.");
-      process.exit(0);
-    }
-    const mcpRuleName = mcpRuleNameResult || void 0;
-    const mcpRuleInsKey = mcpRuleInsKeyResult || void 0;
     const embeddedTargetDir = cwd;
     p.note(
       [
         `${pc.bold("Mode")}:          Embed Pega flow`,
         `${pc.bold("Directory")}:     ${embeddedTargetDir}`,
-        `${pc.bold("AI Tool")}:       ${embeddedAiTool}`,
-        `${pc.bold("Server")}:        ${serverUrl}`,
-        `${pc.bold("App Alias")}:     ${appAlias}`,
-        `${pc.bold("Client ID")}:     ${clientId}`,
-        `${pc.bold("Operator")}:      ${userIdentifier}`,
-        `${pc.bold("MCP Rule")}:      ${mcpRuleName ?? pc.dim("(not configured \u2014 markers left in generated file)")}`,
-        `${pc.bold("MCP Ins Key")}:   ${mcpRuleInsKey ?? pc.dim("(not configured \u2014 markers left in generated file)")}`
+        `${pc.bold("AI Tool")}:       ${embeddedAiTool}`
       ].join("\n"),
       "Configuration"
     );
@@ -1376,13 +1542,7 @@ Usage: ${pc.cyan("npx @pega/sdk init")}`);
       process.exit(0);
     }
     const embeddedChoices = {
-      aiTool: embeddedAiTool,
-      serverUrl,
-      appAlias,
-      clientId,
-      userIdentifier,
-      mcpRuleName,
-      mcpRuleInsKey
+      aiTool: embeddedAiTool
     };
     let conflicts = [];
     try {
@@ -1471,6 +1631,11 @@ Usage: ${pc.cyan("npx @pega/sdk init")}`);
     process.exit(0);
   }
   let aiTool = null;
+  let serverUrl;
+  let appAlias;
+  let clientId;
+  let mcpRuleName;
+  let mcpRuleInsKey;
   if (aiIntegration) {
     const aiToolResult = await p.select({
       message: "Which AI coding tool will you use?",
@@ -1581,7 +1746,7 @@ Usage: ${pc.cyan("npx @pega/sdk init")}`);
       componentCategories = categories;
     }
   }
-  const targetDir = path3.resolve(process.cwd(), projectName);
+  const targetDir = path4.resolve(process.cwd(), projectName);
   p.note(
     [
       `${pc.bold("Project")}:       ${projectName}`,
@@ -1605,7 +1770,12 @@ Usage: ${pc.cyan("npx @pega/sdk init")}`);
     framework,
     aiTool,
     includeTemplates,
-    componentCategories
+    componentCategories,
+    serverUrl,
+    appAlias,
+    clientId,
+    mcpRuleName,
+    mcpRuleInsKey
   };
   const spinner2 = p.spinner();
   spinner2.start("Scaffolding your project\u2026");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pega/sdk",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "description": "Scaffold a Pega SDK application project",
   "type": "module",
   "bin": {