@pega/sdk 0.0.4 → 0.0.6

package/dist/index.js

@@ -3,11 +3,12 @@
 // src/index.ts
 import * as p from "@clack/prompts";
 import pc from "picocolors";
-import path2 from "path";
+import path3 from "path";
+import { createRequire } from "module";
 
 // src/scaffold.ts
-import fs from "fs";
-import path from "path";
+import fs2 from "fs";
+import path2 from "path";
 import { fileURLToPath } from "url";
 import { spawn } from "child_process";
 
@@ -301,15 +302,134 @@ export function registerSampleComponents(registry: ComponentRegistry<React.Compo
   return body;
 }
 
+// src/merge.ts
+import fs from "fs";
+import path from "path";
+var PEGA_BEGIN = "<!-- BEGIN PEGA SDK \u2014 generated by @pega/sdk. Do not edit inside this block. -->";
+var PEGA_END = "<!-- END PEGA SDK -->";
+var PEGA_BLOCK_RE = new RegExp(`${escapeRegExp(PEGA_BEGIN)}[\\s\\S]*?${escapeRegExp(PEGA_END)}`);
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function hasPegaBlock(content) {
+  return PEGA_BLOCK_RE.test(content);
+}
+function wrapPegaBlock(body) {
+  return `${PEGA_BEGIN}
+${body.replace(/\s+$/, "")}
+${PEGA_END}
+`;
+}
+function splitFrontmatter(content) {
+  const match = content.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n/);
+  if (!match) return { frontmatter: "", body: content };
+  return { frontmatter: match[0], body: content.slice(match[0].length) };
+}
+function writeManagedMarkdown(destPath, input) {
+  const { frontmatter, body, policy, markers = true } = input;
+  fs.mkdirSync(path.dirname(destPath), { recursive: true });
+  if (!markers) {
+    const existed = fs.existsSync(destPath);
+    fs.writeFileSync(destPath, frontmatter + body);
+    return existed ? "overwritten" : "created";
+  }
+  const block = wrapPegaBlock(body);
+  if (!fs.existsSync(destPath)) {
+    fs.writeFileSync(destPath, frontmatter + block);
+    return "created";
+  }
+  const existing = fs.readFileSync(destPath, "utf-8");
+  if (hasPegaBlock(existing)) {
+    const outside = existing.replace(PEGA_BLOCK_RE, "");
+    const { body: outsideBody } = splitFrontmatter(outside);
+    if (outsideBody.trim() === "") {
+      fs.writeFileSync(destPath, frontmatter + block);
+      return "block-replaced";
+    }
+    fs.writeFileSync(destPath, existing.replace(PEGA_BLOCK_RE, block.replace(/\n$/, "")));
+    return "block-replaced";
+  }
+  if (policy === "override") {
+    fs.writeFileSync(destPath, frontmatter + block);
+    return "overwritten";
+  }
+  const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+  fs.writeFileSync(destPath, existing + separator + block);
+  return "appended";
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function deepMergeJson(existing, incoming, incomingWins = [], basePath = "") {
+  if (!isPlainObject(existing) || !isPlainObject(incoming)) {
+    return existing === void 0 ? incoming : existing;
+  }
+  const result = { ...existing };
+  for (const [key, incomingValue] of Object.entries(incoming)) {
+    const keyPath = basePath ? `${basePath}.${key}` : key;
+    if (!(key in result)) {
+      result[key] = incomingValue;
+      continue;
+    }
+    const existingValue = result[key];
+    if (isPlainObject(existingValue) && isPlainObject(incomingValue)) {
+      result[key] = deepMergeJson(existingValue, incomingValue, incomingWins, keyPath);
+      continue;
+    }
+    if (incomingWins.includes(keyPath) || incomingWins.includes(key)) {
+      result[key] = incomingValue;
+    }
+  }
+  return result;
+}
+function writeManagedJson(destPath, incoming, policy, incomingWins = []) {
+  fs.mkdirSync(path.dirname(destPath), { recursive: true });
+  if (!fs.existsSync(destPath)) {
+    fs.writeFileSync(destPath, JSON.stringify(incoming, null, 2) + "\n");
+    return "created";
+  }
+  if (policy === "merge") {
+    try {
+      const existing = JSON.parse(fs.readFileSync(destPath, "utf-8"));
+      const merged = deepMergeJson(existing, incoming, incomingWins);
+      fs.writeFileSync(destPath, JSON.stringify(merged, null, 2) + "\n");
+      return "appended";
+    } catch {
+    }
+  }
+  fs.writeFileSync(destPath, JSON.stringify(incoming, null, 2) + "\n");
+  return "overwritten";
+}
+function isConflict(destPath, incomingJson, incomingWins = []) {
+  if (!fs.existsSync(destPath)) return false;
+  let existing;
+  try {
+    existing = fs.readFileSync(destPath, "utf-8");
+  } catch {
+    return true;
+  }
+  if (/\.json$/i.test(destPath)) {
+    if (incomingJson === void 0) return true;
+    try {
+      const parsed = JSON.parse(existing);
+      const merged = deepMergeJson(parsed, incomingJson, incomingWins);
+      return JSON.stringify(merged) !== JSON.stringify(parsed);
+    } catch {
+      return true;
+    }
+  }
+  return !hasPegaBlock(existing);
+}
+
 // src/scaffold.ts
-var __dirname = path.dirname(fileURLToPath(import.meta.url));
-var MONOREPO_SAMPLES_DIR = path.resolve(__dirname, "..", "..", "..", "samples");
-var PACKAGED_TEMPLATES_DIR = path.resolve(__dirname, "..", "templates");
+var __dirname = path2.dirname(fileURLToPath(import.meta.url));
+var MONOREPO_SAMPLES_DIR = path2.resolve(__dirname, "..", "..", "..", "samples");
+var PACKAGED_TEMPLATES_DIR = path2.resolve(__dirname, "..", "templates");
 function resolveTemplateSourceRoot() {
-  if (fs.existsSync(MONOREPO_SAMPLES_DIR)) {
+  if (fs2.existsSync(MONOREPO_SAMPLES_DIR)) {
     return MONOREPO_SAMPLES_DIR;
   }
-  if (fs.existsSync(PACKAGED_TEMPLATES_DIR)) {
+  if (fs2.existsSync(PACKAGED_TEMPLATES_DIR)) {
     return PACKAGED_TEMPLATES_DIR;
   }
   throw new Error(
@@ -329,57 +449,86 @@ var CATEGORY_DIR_MAP = {
   infra: "infra",
   designSystemExtension: "designSystemExtension"
 };
-var SKIP_ENTRIES = /* @__PURE__ */ new Set(["node_modules", "dist", ".DS_Store", ".next", ".expo", ".angular"]);
+var SKIP_ENTRIES = /* @__PURE__ */ new Set([
+  "node_modules",
+  "dist",
+  ".DS_Store",
+  ".next",
+  ".expo",
+  ".angular",
+  "build",
+  ".pnpm-store"
+]);
 async function scaffold(choices, targetDir, onProgress) {
   const report = (message) => onProgress?.(message);
-  const { framework, aiTool, includeTemplates, componentCategories, projectName } = choices;
+  let { framework, aiTool, includeTemplates, componentCategories, projectName } = choices;
+  if (framework === "react-native") {
+    includeTemplates = true;
+    componentCategories = ["fields", "templates", "infra"];
+  }
   report("Preparing project directory\u2026");
-  if (fs.existsSync(targetDir)) {
-    const files = fs.readdirSync(targetDir);
+  if (fs2.existsSync(targetDir)) {
+    const files = fs2.readdirSync(targetDir);
     if (files.length > 0) {
       throw new Error(`Directory "${targetDir}" is not empty.`);
     }
   } else {
-    fs.mkdirSync(targetDir, { recursive: true });
+    fs2.mkdirSync(targetDir, { recursive: true });
   }
   const templateSourceRoot = resolveTemplateSourceRoot();
   const sampleName = FRAMEWORK_SAMPLE_MAP[framework];
-  const sampleDir = path.join(templateSourceRoot, sampleName);
-  if (!fs.existsSync(sampleDir)) {
+  const sampleDir = path2.join(templateSourceRoot, sampleName);
+  if (!fs2.existsSync(sampleDir)) {
     throw new Error(`Template "${sampleName}" not found at ${sampleDir}.`);
   }
   report(`Copying ${sampleName} reference app\u2026`);
   copyDir(sampleDir, targetDir);
   report("Configuring component set\u2026");
-  const componentsDir = path.join(targetDir, "src", "components");
-  if (fs.existsSync(componentsDir)) {
+  const componentsDir = path2.join(targetDir, "src", "components");
+  if (fs2.existsSync(componentsDir)) {
+    const allowedCategories = framework === "react-native" ? ["fields", "templates", "infra"] : ["fields", "templates", "widgets", "infra", "designSystemExtension"];
     if (!includeTemplates || componentCategories.length === 0) {
       for (const cat of Object.values(CATEGORY_DIR_MAP)) {
-        const catDir = path.join(componentsDir, cat);
-        if (fs.existsSync(catDir)) {
-          fs.rmSync(catDir, { recursive: true });
+        const catDir = path2.join(componentsDir, cat);
+        if (fs2.existsSync(catDir)) {
+          fs2.rmSync(catDir, { recursive: true });
+        }
+      }
+      fs2.writeFileSync(path2.join(componentsDir, "component-map.ts"), generateMinimalComponentMap(framework));
+      if (framework === "react") {
+        fs2.writeFileSync(path2.join(targetDir, "src", "AppProviders.tsx"), generateMinimalReactProviders());
+        const muiThemeAugmentation = path2.join(targetDir, "src", "mui-theme-augmentation.d.ts");
+        if (fs2.existsSync(muiThemeAugmentation)) {
+          fs2.rmSync(muiThemeAugmentation);
         }
       }
-      fs.writeFileSync(path.join(componentsDir, "component-map.ts"), generateMinimalComponentMap());
     } else {
-      const allCategories = ["fields", "templates", "widgets", "infra", "designSystemExtension"];
-      for (const cat of allCategories) {
+      for (const cat of allowedCategories) {
         if (!componentCategories.includes(cat)) {
-          const catDir = path.join(componentsDir, CATEGORY_DIR_MAP[cat]);
-          if (fs.existsSync(catDir)) {
-            fs.rmSync(catDir, { recursive: true });
+          const catDir = path2.join(componentsDir, CATEGORY_DIR_MAP[cat]);
+          if (fs2.existsSync(catDir)) {
+            fs2.rmSync(catDir, { recursive: true });
+          }
+        }
+      }
+      if (framework === "react-native") {
+        const unsupportedCats = ["widgets", "designSystemExtension"];
+        for (const cat of unsupportedCats) {
+          const catDir = path2.join(componentsDir, CATEGORY_DIR_MAP[cat]);
+          if (fs2.existsSync(catDir)) {
+            fs2.rmSync(catDir, { recursive: true });
           }
         }
       }
       const componentMapContent = generateComponentMap(componentCategories, framework);
-      fs.writeFileSync(path.join(componentsDir, "component-map.ts"), componentMapContent);
+      fs2.writeFileSync(path2.join(componentsDir, "component-map.ts"), componentMapContent);
     }
   }
   if (!aiTool) {
-    for (const dir of [".github", ".cursor", "AGENTS.md", ".claude"]) {
-      const target = path.join(targetDir, dir);
-      if (fs.existsSync(target)) {
-        fs.rmSync(target, { recursive: true });
+    for (const dir of [".github", ".cursor", "AGENTS.md", ".claude", ".ai-common"]) {
+      const target = path2.join(targetDir, dir);
+      if (fs2.existsSync(target)) {
+        fs2.rmSync(target, { recursive: true });
       }
     }
   } else {
@@ -392,16 +541,22 @@ async function scaffold(choices, targetDir, onProgress) {
     const keepPaths = AI_TOOL_PATHS[aiTool];
     for (const dir of allAiPaths) {
       if (!keepPaths.includes(dir)) {
-        const target = path.join(targetDir, dir);
-        if (fs.existsSync(target)) {
-          fs.rmSync(target, { recursive: true });
+        const target = path2.join(targetDir, dir);
+        if (fs2.existsSync(target)) {
+          fs2.rmSync(target, { recursive: true });
         }
       }
     }
+    generateAiConfigs(targetDir, aiTool);
   }
   report("Finalizing project configuration\u2026");
-  transformPackageJson(path.join(targetDir, "package.json"), projectName);
-  transformTsConfig(path.join(targetDir, "tsconfig.json"));
+  selectReactPackageManifest(targetDir, framework, includeTemplates, componentCategories);
+  transformPackageJson(path2.join(targetDir, "package.json"), projectName);
+  transformTsConfig(path2.join(targetDir, "tsconfig.json"));
+  transformSdkConfig(path2.join(targetDir, "sdk-config.json"));
+  if (framework === "react-native") {
+    transformExpoConfig(path2.join(targetDir, "app.json"), projectName);
+  }
   report("Installing dependencies (this may take a minute)\u2026");
   try {
     await runInstall(targetDir);
@@ -423,15 +578,27 @@ function runInstall(cwd) {
   });
 }
 function transformPackageJson(pkgJsonPath, projectName) {
-  if (!fs.existsSync(pkgJsonPath)) return;
-  const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+  if (!fs2.existsSync(pkgJsonPath)) return;
+  const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
   pkgJson.name = projectName;
   delete pkgJson.private;
-  fs.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
+  fs2.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
+}
+function selectReactPackageManifest(targetDir, framework, includeTemplates, componentCategories) {
+  if (framework !== "react") return;
+  const pkgJsonPath = path2.join(targetDir, "package.json");
+  const minimalPkgJsonPath = path2.join(targetDir, "package.minimal.json");
+  const hasSampleComponents = includeTemplates && componentCategories.length > 0;
+  if (!hasSampleComponents && fs2.existsSync(minimalPkgJsonPath)) {
+    fs2.copyFileSync(minimalPkgJsonPath, pkgJsonPath);
+  }
+  if (fs2.existsSync(minimalPkgJsonPath)) {
+    fs2.rmSync(minimalPkgJsonPath);
+  }
 }
 function transformTsConfig(tsconfigPath) {
-  if (!fs.existsSync(tsconfigPath)) return;
-  const tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, "utf-8"));
+  if (!fs2.existsSync(tsconfigPath)) return;
+  const tsconfig = JSON.parse(fs2.readFileSync(tsconfigPath, "utf-8"));
   if (tsconfig.compilerOptions) {
     if (tsconfig.compilerOptions.paths) {
       const cleanedPaths = {};
@@ -451,9 +618,60 @@ function transformTsConfig(tsconfigPath) {
       tsconfig.compilerOptions.typeRoots = ["./node_modules/@types", "./node_modules/@pega"];
     }
   }
-  fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
+  fs2.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2) + "\n");
+}
+function transformSdkConfig(sdkConfigPath) {
+  if (!fs2.existsSync(sdkConfigPath)) return;
+  const sdkConfig = JSON.parse(fs2.readFileSync(sdkConfigPath, "utf-8"));
+  if (sdkConfig.serverConfig) {
+    if ("infinityRestServerUrl" in sdkConfig.serverConfig) sdkConfig.serverConfig.infinityRestServerUrl = "";
+    if ("appAlias" in sdkConfig.serverConfig) sdkConfig.serverConfig.appAlias = "";
+    if ("appMashupCaseType" in sdkConfig.serverConfig) sdkConfig.serverConfig.appMashupCaseType = "";
+  }
+  if (sdkConfig.authConfig) {
+    if ("mashupClientId" in sdkConfig.authConfig) sdkConfig.authConfig.mashupClientId = "";
+    if ("mashupUserIdentifier" in sdkConfig.authConfig) sdkConfig.authConfig.mashupUserIdentifier = "";
+    if ("portalClientId" in sdkConfig.authConfig) sdkConfig.authConfig.portalClientId = "";
+  }
+  fs2.writeFileSync(sdkConfigPath, JSON.stringify(sdkConfig, null, 2) + "\n");
+}
+function transformExpoConfig(appJsonPath, projectName) {
+  if (!fs2.existsSync(appJsonPath)) return;
+  const appJson = JSON.parse(fs2.readFileSync(appJsonPath, "utf-8"));
+  if (appJson.expo) {
+    appJson.expo.name = projectName;
+    appJson.expo.slug = projectName.toLowerCase().replace(/\s+/g, "-").replace(/[^a-z0-9-]/g, "");
+  }
+  fs2.writeFileSync(appJsonPath, JSON.stringify(appJson, null, 2) + "\n");
+}
+function generateMinimalComponentMap(framework) {
+  if (framework === "react-native") {
+    return `import { sdkComponents } from '@pega/sdk-react';
+import type { ComponentRegistry } from '@pega/sdk-types';
+
+/**
+ * Returns a map of Pega component names \u2192 React Native components.
+ * Add your own components here as you build them.
+ */
+function getSampleComponentMap(): Record<string, React.ComponentType<Record<string, unknown>>> {
+  return {
+    ...sdkComponents,
+  };
 }
-function generateMinimalComponentMap() {
+
+/**
+ * Registers all components into the given registry.
+ */
+export function registerComponents(
+  registry: ComponentRegistry<React.ComponentType<Record<string, unknown>>>,
+) {
+  const map = getSampleComponentMap();
+  for (const [name, component] of Object.entries(map)) {
+    registry.register(name, component);
+  }
+}
+`;
+  }
   return `import { sdkComponents } from '@pega/sdk-react';
 import type { ComponentRegistry } from '@pega/sdk-types';
 
@@ -480,24 +698,505 @@ export function registerSampleComponents(
 }
 `;
 }
+function generateMinimalReactProviders() {
+  return `import type { PropsWithChildren } from 'react';
+
+export function AppProviders({ children }: PropsWithChildren) {
+  return <>{children}</>;
+}
+`;
+}
+var AI_GEN_CONFIGS = {
+  copilot: {
+    skillDir: ".github/skills",
+    promptDir: ".github/prompts",
+    instructionsDir: ".github/instructions",
+    agentsDir: ".github/agents",
+    skillExt: "md",
+    promptExt: "prompt.md",
+    instructionsExt: "instructions.md",
+    agentExt: "agent.md",
+    tokens: {
+      "{{PROMPT_DIR}}": ".github/prompts",
+      "{{SKILL_DIR}}": ".github/skills",
+      "{{INSTRUCTIONS_DIR}}": ".github/instructions",
+      "{{PROMPT_EXT}}": ".prompt.md",
+      "{{SKILL_EXT}}": ".md",
+      "{{AI_FILE_EXT}}": ".instructions.md"
+    }
+  },
+  "claude-code": {
+    skillDir: ".claude/skills",
+    promptDir: ".claude/prompts",
+    instructionsDir: ".claude/instructions",
+    agentsDir: ".claude/agents",
+    skillExt: "md",
+    promptExt: "md",
+    instructionsExt: "md",
+    agentExt: "md",
+    tokens: {
+      "{{PROMPT_DIR}}": ".claude/prompts",
+      "{{SKILL_DIR}}": ".claude/skills",
+      "{{INSTRUCTIONS_DIR}}": ".claude/instructions",
+      "{{PROMPT_EXT}}": ".md",
+      "{{SKILL_EXT}}": ".md",
+      "{{AI_FILE_EXT}}": ".md"
+    }
+  },
+  cursor: {
+    skillDir: ".cursor/rules/skills",
+    promptDir: ".cursor/rules/prompts",
+    instructionsDir: ".cursor/rules",
+    agentsDir: ".cursor/rules/agents",
+    skillExt: "mdrules",
+    promptExt: "mdrules",
+    instructionsExt: "mdrules",
+    agentExt: "mdrules",
+    tokens: {
+      "{{PROMPT_DIR}}": ".cursor/rules/prompts",
+      "{{SKILL_DIR}}": ".cursor/rules/skills",
+      "{{INSTRUCTIONS_DIR}}": ".cursor/rules",
+      "{{PROMPT_EXT}}": ".mdrules",
+      "{{SKILL_EXT}}": ".mdrules",
+      "{{AI_FILE_EXT}}": ".mdrules"
+    }
+  }
+};
+function parseAiMeta(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n\n?/);
+  if (!match) return { meta: {}, body: content };
+  const meta = {};
+  for (const line of match[1].split("\n")) {
+    const colonIdx = line.indexOf(":");
+    if (colonIdx === -1) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const val = line.slice(colonIdx + 1).trim().replace(/^"|"$/g, "");
+    if (key.startsWith("ai-")) meta[key.slice(3)] = val;
+  }
+  return { meta, body: content.slice(match[0].length) };
+}
+function applyTokens(content, tokens) {
+  let result = content;
+  for (const [token, value] of Object.entries(tokens)) {
+    result = result.split(token).join(value);
+  }
+  return result;
+}
+function cursorSkillDescription(relPath) {
+  const parts = relPath.split("/");
+  if (parts.length >= 2) {
+    const subdir = parts[parts.length - 2];
+    const name = parts[parts.length - 1].replace(/\.md$/, "");
+    if (subdir === "field-skills") return `Field component skill: ${name}`;
+    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}`;
+  }
+  return relPath.replace(/\.md$/, "").split("/").pop();
+}
+function planAiConfigs(aiCommonDir, targetDir, aiTool, options = {}) {
+  if (!fs2.existsSync(aiCommonDir)) return [];
+  const cfg = AI_GEN_CONFIGS[aiTool];
+  const { tokens } = cfg;
+  const planned = [];
+  const skillsSrc = path2.join(aiCommonDir, "skills");
+  if (fs2.existsSync(skillsSrc)) {
+    const walkSkills = (srcDir, relDir = "") => {
+      for (const entry of fs2.readdirSync(srcDir, { withFileTypes: true })) {
+        const relPath = relDir ? `${relDir}/${entry.name}` : entry.name;
+        const srcPath = path2.join(srcDir, entry.name);
+        if (entry.isDirectory()) {
+          walkSkills(srcPath, relPath);
+        } else if (entry.name.endsWith(".md")) {
+          const { body } = parseAiMeta(fs2.readFileSync(srcPath, "utf-8"));
+          let frontmatter = "";
+          if (aiTool === "cursor") {
+            const desc = cursorSkillDescription(relPath);
+            frontmatter = `---
+description: ${desc}
+alwaysApply: false
+---
+
+`;
+          }
+          const outName = `${entry.name.replace(/\.md$/, "")}.${cfg.skillExt}`;
+          planned.push({
+            destPath: path2.join(targetDir, cfg.skillDir, relDir, outName),
+            frontmatter,
+            body: applyTokens(body, tokens),
+            kind: "md"
+          });
+        }
+      }
+    };
+    walkSkills(skillsSrc);
+  }
+  const promptsSrc = path2.join(aiCommonDir, "prompts");
+  if (fs2.existsSync(promptsSrc)) {
+    const promptsDest = path2.join(targetDir, cfg.promptDir);
+    for (const entry of fs2.readdirSync(promptsSrc, { withFileTypes: true })) {
+      const srcPath = path2.join(promptsSrc, entry.name);
+      if (entry.name === "component-manifest.json") {
+        planned.push({
+          destPath: path2.join(promptsDest, entry.name),
+          frontmatter: "",
+          body: fs2.readFileSync(srcPath, "utf-8"),
+          kind: "json"
+        });
+      } else if (entry.name.endsWith(".md")) {
+        const { meta, body } = parseAiMeta(fs2.readFileSync(srcPath, "utf-8"));
+        const basename = entry.name.replace(/\.md$/, "");
+        let frontmatter = "";
+        if (aiTool === "copilot") {
+          frontmatter = `---
+agent: agent
+description: ${meta.description || basename}
+---
+
+`;
+        } else if (aiTool === "cursor") {
+          frontmatter = `---
+description: Workflow prompt: ${basename}
+alwaysApply: false
+---
+
+`;
+        }
+        planned.push({
+          destPath: path2.join(promptsDest, `${basename}.${cfg.promptExt}`),
+          frontmatter,
+          body: applyTokens(body, tokens),
+          kind: "md"
+        });
+      }
+    }
+  }
+  const instructionsSrc = path2.join(aiCommonDir, "instructions");
+  if (fs2.existsSync(instructionsSrc)) {
+    const instructionsDest = path2.join(targetDir, cfg.instructionsDir);
+    for (const entry of fs2.readdirSync(instructionsSrc, { withFileTypes: true })) {
+      if (!entry.name.endsWith(".md")) continue;
+      const { meta, body } = parseAiMeta(fs2.readFileSync(path2.join(instructionsSrc, entry.name), "utf-8"));
+      const basename = entry.name.replace(/\.md$/, "");
+      let frontmatter = "";
+      if (aiTool === "cursor") {
+        frontmatter = meta.globs ? `---
+globs: ["${meta.globs}"]
+---
+
+` : `---
+alwaysApply: false
+---
+
+`;
+      } else if (aiTool === "copilot") {
+        if (meta.globs) frontmatter = `---
+applyTo: '${meta.globs}'
+---
+
+`;
+      }
+      planned.push({
+        destPath: path2.join(instructionsDest, `${basename}.${cfg.instructionsExt}`),
+        frontmatter,
+        body: applyTokens(body, tokens),
+        kind: "md"
+      });
+    }
+  }
+  const agentsSrc = path2.join(aiCommonDir, "agents");
+  if (fs2.existsSync(agentsSrc)) {
+    const agentsDest = path2.join(targetDir, cfg.agentsDir);
+    for (const entry of fs2.readdirSync(agentsSrc, { withFileTypes: true })) {
+      if (!entry.name.endsWith(".md")) continue;
+      const basename = entry.name.replace(/\.md$/, "");
+      const { meta, body } = parseAiMeta(fs2.readFileSync(path2.join(agentsSrc, entry.name), "utf-8"));
+      let frontmatter = "";
+      if (aiTool === "copilot") {
+        const description = applyTokens(meta.description || "", tokens);
+        const name = meta.name || basename.replace(/-/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+        frontmatter = `---
+description: "${description}"
+name: '${name}'
+user-invocable: true
+disable-model-invocation: false
+---
+
+`;
+      } else if (aiTool === "cursor") {
+        const description = applyTokens(meta.description || `Agent config: ${basename}`, tokens);
+        frontmatter = `---
+description: ${description}
+alwaysApply: false
+---
+
+`;
+      } else if (aiTool === "claude-code") {
+        const description = applyTokens(meta.description || `Agent config: ${basename}`, tokens);
+        frontmatter = `---
+name: ${basename}
+description: "${description}"
+---
+
+`;
+      }
+      planned.push({
+        destPath: path2.join(agentsDest, `${basename}.${cfg.agentExt}`),
+        frontmatter,
+        body: applyTokens(body, tokens),
+        kind: "md"
+      });
+    }
+  }
+  const globalSrc = path2.join(aiCommonDir, "global", options.globalFile ?? "ai-agent-instructions.md");
+  if (fs2.existsSync(globalSrc)) {
+    const body = applyTokens(fs2.readFileSync(globalSrc, "utf-8"), tokens);
+    if (aiTool === "copilot") {
+      planned.push({
+        destPath: path2.join(targetDir, ".github", "copilot-instructions.md"),
+        frontmatter: "",
+        body,
+        kind: "md"
+      });
+    } else if (aiTool === "cursor") {
+      planned.push({
+        destPath: path2.join(targetDir, ".cursor", "rules", "pega-sdk.mdrules"),
+        frontmatter: "---\ndescription: Core rules for working with Pega SDK components\nalwaysApply: true\n---\n\n",
+        body,
+        kind: "md"
+      });
+    } else if (aiTool === "claude-code") {
+      planned.push({
+        destPath: path2.join(targetDir, "AGENTS.md"),
+        frontmatter: "",
+        body,
+        kind: "md"
+      });
+    }
+  }
+  return planned;
+}
+function applyPlannedFiles(files, policy, options = {}) {
+  const { markers = true } = options;
+  const counts = {
+    created: 0,
+    "block-replaced": 0,
+    appended: 0,
+    overwritten: 0
+  };
+  for (const file of files) {
+    let outcome;
+    if (file.kind === "json") {
+      let parsed;
+      try {
+        parsed = markers ? JSON.parse(file.body) : void 0;
+      } catch {
+        parsed = void 0;
+      }
+      if (parsed === void 0) {
+        fs2.mkdirSync(path2.dirname(file.destPath), { recursive: true });
+        const existed = fs2.existsSync(file.destPath);
+        fs2.writeFileSync(file.destPath, file.body);
+        counts[existed ? "overwritten" : "created"] += 1;
+        continue;
+      }
+      outcome = writeManagedJson(file.destPath, parsed, policy);
+    } else {
+      outcome = writeManagedMarkdown(file.destPath, {
+        frontmatter: file.frontmatter,
+        body: file.body,
+        policy,
+        markers
+      });
+    }
+    counts[outcome] += 1;
+  }
+  return counts;
+}
+function generateAiConfigs(targetDir, aiTool) {
+  const aiCommonDir = path2.join(targetDir, ".ai-common");
+  if (!fs2.existsSync(aiCommonDir)) return;
+  applyPlannedFiles(planAiConfigs(aiCommonDir, targetDir, aiTool), "override", { markers: false });
+  fs2.rmSync(aiCommonDir, { recursive: true });
+}
+var EMBEDDED_GLOBAL_FILE = "ai-agent-instructions-embedded.md";
+function resolveEmbeddedSource() {
+  const templateSourceRoot = resolveTemplateSourceRoot();
+  const sampleDir = path2.join(templateSourceRoot, FRAMEWORK_SAMPLE_MAP.react);
+  const aiCommonSrc = path2.join(sampleDir, ".ai-common");
+  if (!fs2.existsSync(aiCommonSrc)) {
+    throw new Error(`AI common source not found at ${aiCommonSrc}. Ensure the template source is available.`);
+  }
+  return { sampleDir, aiCommonSrc };
+}
+var SDK_CONFIG_USER_KEYS = [
+  "serverConfig.infinityRestServerUrl",
+  "serverConfig.appAlias",
+  "authConfig.mashupClientId",
+  "authConfig.mashupUserIdentifier",
+  "authConfig.portalClientId"
+];
+function buildSdkConfig(choices) {
+  return {
+    serverConfig: {
+      infinityRestServerUrl: choices.serverUrl,
+      appAlias: choices.appAlias,
+      sdkContentServerUrl: "",
+      appPortal: "",
+      appMashupCaseType: "",
+      excludePortals: [
+        "pxExpress",
+        "Developer",
+        "pxPredictionStudio",
+        "pxAdminStudio",
+        "pyCaseWorker",
+        "pyCaseManager7"
+      ]
+    },
+    authConfig: {
+      authService: "pega",
+      mashupClientId: choices.clientId,
+      mashupUserIdentifier: choices.userIdentifier,
+      mashupPassword: "",
+      portalClientId: choices.clientId,
+      portalClientSecret: "",
+      portalGrantType: ""
+    }
+  };
+}
+function collectEmbeddedConflicts(targetDir, choices) {
+  const { aiCommonSrc } = resolveEmbeddedSource();
+  const planned = planAiConfigs(aiCommonSrc, targetDir, choices.aiTool, { globalFile: EMBEDDED_GLOBAL_FILE });
+  const conflicts = planned.filter((file) => {
+    if (file.kind !== "json") return isConflict(file.destPath);
+    try {
+      return isConflict(file.destPath, JSON.parse(file.body));
+    } catch {
+      return isConflict(file.destPath);
+    }
+  }).map((file) => file.destPath);
+  const sdkConfigPath = path2.join(resolveStaticDir(targetDir), "sdk-config.json");
+  if (isConflict(sdkConfigPath, buildSdkConfig(choices), SDK_CONFIG_USER_KEYS)) {
+    conflicts.push(sdkConfigPath);
+  }
+  return conflicts.map((filePath) => path2.relative(targetDir, filePath));
+}
+async function scaffoldEmbedded(choices, targetDir, onProgress) {
+  const report = (message) => onProgress?.(message);
+  const { aiTool } = choices;
+  const policy = choices.conflictPolicy ?? "merge";
+  report("Locating embedded flow skills\u2026");
+  const { sampleDir, aiCommonSrc } = resolveEmbeddedSource();
+  report(`Generating ${aiTool} configuration\u2026`);
+  const planned = planAiConfigs(aiCommonSrc, targetDir, aiTool, { globalFile: EMBEDDED_GLOBAL_FILE });
+  const counts = applyPlannedFiles(planned, policy);
+  report(
+    `Wrote ${planned.length} file(s): ${counts.created} new, ${counts["block-replaced"]} updated, ${counts.appended} merged, ${counts.overwritten} replaced.`
+  );
+  report("Copying SDK packages\u2026");
+  const tgzFiles = fs2.readdirSync(sampleDir).filter((f) => f.endsWith(".tgz"));
+  for (const tgz of tgzFiles) {
+    const src = path2.join(sampleDir, tgz);
+    const dest = path2.join(targetDir, tgz);
+    fs2.copyFileSync(src, dest);
+  }
+  report("Adding SDK dependencies\u2026");
+  const pkgJsonPath = path2.join(targetDir, "package.json");
+  if (fs2.existsSync(pkgJsonPath)) {
+    const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+    if (!pkgJson.dependencies) pkgJson.dependencies = {};
+    const TGZ_PACKAGE_MAP = {
+      "pega-auth": "@pega/auth",
+      "pega-constellationjs": "@pega/constellationjs",
+      "pega-sdk-react": "@pega/sdk-react",
+      "pega-sdk-types": "@pega/sdk-types"
+    };
+    for (const tgz of tgzFiles) {
+      const match = tgz.match(/^(pega-[\w-]+?)-\d/);
+      if (match) {
+        const pkgName = TGZ_PACKAGE_MAP[match[1]];
+        if (pkgName) {
+          pkgJson.dependencies[pkgName] = `file:${tgz}`;
+        }
+      }
+    }
+    fs2.writeFileSync(pkgJsonPath, JSON.stringify(pkgJson, null, 2) + "\n");
+  }
+  report("Creating SDK configuration\u2026");
+  const staticDir = ensureStaticDir(targetDir);
+  const sdkConfigPath = path2.join(staticDir, "sdk-config.json");
+  writeManagedJson(sdkConfigPath, buildSdkConfig(choices), policy, SDK_CONFIG_USER_KEYS);
+  if (staticDir !== targetDir && fs2.existsSync(path2.join(targetDir, "sdk-config.json"))) {
+    report(`\u26A0\uFE0F  A sdk-config.json also exists at the project root. The active one is ${sdkConfigPath}.`);
+  }
+  report("Installing dependencies (this may take a minute)\u2026");
+  let installSucceeded = true;
+  try {
+    await runInstall(targetDir);
+  } catch {
+    installSucceeded = false;
+    report(
+      "\u26A0\uFE0F  Dependency installation failed. Run your package manager manually, then copy OAuth callback assets (see below)."
+    );
+  }
+  if (installSucceeded) {
+    report("Copying OAuth callback assets\u2026");
+    const authOAuthDir = path2.join(targetDir, "node_modules", "@pega", "auth", "lib", "oauth-client");
+    if (fs2.existsSync(authOAuthDir)) {
+      const authHtmlSrc = path2.join(authOAuthDir, "authDone.html");
+      const authJsSrc = path2.join(authOAuthDir, "authDone.js");
+      const lockSvgSrc = path2.join(authOAuthDir, "lock-closed-solid.svg");
+      if (fs2.existsSync(authHtmlSrc)) fs2.copyFileSync(authHtmlSrc, path2.join(staticDir, "auth.html"));
+      if (fs2.existsSync(authJsSrc)) fs2.copyFileSync(authJsSrc, path2.join(staticDir, "authDone.js"));
+      if (fs2.existsSync(lockSvgSrc)) fs2.copyFileSync(lockSvgSrc, path2.join(staticDir, "lock-closed-solid.svg"));
+    } else {
+      report(
+        "\u26A0\uFE0F  Auth OAuth assets not found after install. Copy auth.html, authDone.js, and lock-closed-solid.svg manually to the served static directory."
+      );
+    }
+  }
+  report("Done!");
+}
+function detectExistingProject(dir) {
+  return fs2.existsSync(path2.join(dir, "package.json"));
+}
+function resolveStaticDir(targetDir) {
+  const pkgJsonPath = path2.join(targetDir, "package.json");
+  if (fs2.existsSync(pkgJsonPath)) {
+    const pkgJson = JSON.parse(fs2.readFileSync(pkgJsonPath, "utf-8"));
+    const allDeps = { ...pkgJson.dependencies, ...pkgJson.devDependencies };
+    if (allDeps["next"] || allDeps["vite"] || allDeps["react-scripts"]) {
+      return path2.join(targetDir, "public");
+    }
+  }
+  return targetDir;
+}
+function ensureStaticDir(targetDir) {
+  const staticDir = resolveStaticDir(targetDir);
+  fs2.mkdirSync(staticDir, { recursive: true });
+  return staticDir;
+}
 function copyDir(src, dest) {
-  fs.mkdirSync(dest, { recursive: true });
-  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+  fs2.mkdirSync(dest, { recursive: true });
+  for (const entry of fs2.readdirSync(src, { withFileTypes: true })) {
     if (SKIP_ENTRIES.has(entry.name)) continue;
-    const srcPath = path.join(src, entry.name);
-    const destPath = path.join(dest, entry.name);
+    const srcPath = path2.join(src, entry.name);
+    const destPath = path2.join(dest, entry.name);
     if (entry.isDirectory()) {
       copyDir(srcPath, destPath);
     } else {
-      fs.copyFileSync(srcPath, destPath);
+      fs2.copyFileSync(srcPath, destPath);
     }
   }
 }
 
 // src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version: sdkVersion } = require2("../package.json");
 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") {
@@ -506,6 +1205,185 @@ async function main() {
 Usage: ${pc.cyan("npx @pega/sdk init")}`);
     process.exit(1);
   }
+  const cwd = process.cwd();
+  const projectMode = detectExistingProject(cwd) ? "embedded" : "new";
+  if (projectMode === "embedded") {
+    const continueEmbedded = await p.confirm({
+      message: "An existing project was detected in this folder (package.json found). Would you like to continue and integrate the embedded flow into it?",
+      initialValue: true
+    });
+    if (p.isCancel(continueEmbedded) || !continueEmbedded) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+  } else {
+    p.log.info(pc.dim("No existing project detected in this folder \u2014 continuing with the new-project flow."));
+  }
+  if (projectMode === "embedded") {
+    p.log.info(pc.dim("Let's set up Pega embedded flow in your existing project."));
+    const aiAssisted = await p.confirm({
+      message: "Would you like AI assistance to set up the embedded flow?",
+      initialValue: true
+    });
+    if (p.isCancel(aiAssisted)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    if (!aiAssisted) {
+      p.log.info("Non-AI embedded flow is still under development. Stay tuned!");
+      p.outro(pc.dim("No changes were made."));
+      process.exit(0);
+    }
+    const embeddedAiTool = await p.select({
+      message: "Which AI coding assistant do you use?",
+      options: [
+        { value: "copilot", label: "GitHub Copilot" },
+        { value: "cursor", label: "Cursor" },
+        { value: "claude-code", label: "Claude Code" }
+      ]
+    });
+    if (p.isCancel(embeddedAiTool)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    p.log.info(pc.dim("\nNow let's connect to your Pega server."));
+    const serverUrl = 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(serverUrl)) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    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);
+    }
+    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}`
+      ].join("\n"),
+      "Configuration"
+    );
+    const embeddedConfirmed = await p.confirm({
+      message: "Looks good? Let's set it up.",
+      initialValue: true
+    });
+    if (p.isCancel(embeddedConfirmed) || !embeddedConfirmed) {
+      p.cancel("Operation cancelled.");
+      process.exit(0);
+    }
+    const embeddedChoices = {
+      aiTool: embeddedAiTool,
+      serverUrl,
+      appAlias,
+      clientId,
+      userIdentifier
+    };
+    let conflicts = [];
+    try {
+      conflicts = collectEmbeddedConflicts(embeddedTargetDir, embeddedChoices);
+    } catch (err) {
+      p.log.error(String(err));
+      process.exit(1);
+    }
+    if (conflicts.length > 0) {
+      const MAX_LISTED = 15;
+      const listed = conflicts.slice(0, MAX_LISTED);
+      const remaining = conflicts.length - listed.length;
+      p.note(
+        [...listed, ...remaining > 0 ? [pc.dim(`\u2026and ${remaining} more`)] : []].join("\n"),
+        `Found ${conflicts.length} existing file(s)`
+      );
+      const policyResult = await p.select({
+        message: "These files already exist. How should we handle them?",
+        options: [
+          {
+            value: "merge",
+            label: "Merge",
+            hint: "keep your content and add Pega content in a marked block"
+          },
+          {
+            value: "override",
+            label: "Override",
+            hint: "replace these files with the Pega versions"
+          }
+        ],
+        initialValue: "merge"
+      });
+      if (p.isCancel(policyResult)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      embeddedChoices.conflictPolicy = policyResult;
+    }
+    const spinner3 = p.spinner();
+    spinner3.start("Setting up embedded flow\u2026");
+    try {
+      await scaffoldEmbedded(embeddedChoices, embeddedTargetDir, (message) => {
+        spinner3.message(message);
+      });
+      spinner3.stop("Embedded flow ready!");
+    } catch (err) {
+      spinner3.stop("Failed to set up embedded flow.");
+      p.log.error(String(err));
+      process.exit(1);
+    }
+    p.note(
+      [
+        "# Open your AI coding assistant and say:",
+        '"Embed case [YOUR-CASE-TYPE] on click of [your button]"',
+        "",
+        "# The assistant will:",
+        "1. Scan your codebase to understand your design system",
+        "2. Generate Pega components matching your app's style",
+        "3. Wire everything together so the case flow just works"
+      ].join("\n"),
+      "Next Steps"
+    );
+    p.outro(pc.green("You're all set! Open your AI assistant and start embedding."));
+    process.exit(0);
+  }
   const nameResult = await p.text({
     message: "What is the name of your project?",
     placeholder: "my-pega-app",
@@ -562,12 +1440,12 @@ Usage: ${pc.cyan("npx @pega/sdk init")}`);
       {
         value: "react",
         label: "React",
-        hint: "Vite + React 18 + @pega/sdk-react"
+        hint: "Vite + React 19 + @pega/sdk-react"
       },
       {
         value: "angular",
         label: "Angular",
-        hint: "Angular 18 + @pega/sdk-angular"
+        hint: "Angular 21 + @pega/sdk-angular"
       },
       {
         value: "web-components",
@@ -585,54 +1463,61 @@ Usage: ${pc.cyan("npx @pega/sdk init")}`);
     p.cancel("Operation cancelled.");
     process.exit(0);
   }
-  const includeTemplates = await p.confirm({
-    message: "Include starter component implementations? (scaffolds working component files you can customize)",
-    initialValue: true
-  });
-  if (p.isCancel(includeTemplates)) {
-    p.cancel("Operation cancelled.");
-    process.exit(0);
-  }
+  let includeTemplates;
   let componentCategories = [];
-  if (includeTemplates) {
-    const categories = await p.multiselect({
-      message: "Which component types do you want scaffolded?",
-      options: [
-        {
-          value: "fields",
-          label: "Fields",
-          hint: "TextInput, Dropdown, Checkbox, Date, etc."
-        },
-        {
-          value: "templates",
-          label: "Templates",
-          hint: "OneColumn, TwoColumn, CaseView, DefaultForm, etc."
-        },
-        {
-          value: "widgets",
-          label: "Widgets",
-          hint: "Attachment, CaseHistory, ToDo, etc."
-        },
-        {
-          value: "infra",
-          label: "Infrastructure",
-          hint: "NavBar, ActionButtons, Stages, etc."
-        },
-        {
-          value: "designSystemExtension",
-          label: "Design System Extensions",
-          hint: "AlertBanner, FieldGroup, Pulse, etc."
-        }
-      ],
-      required: true
+  if (framework === "react-native") {
+    includeTemplates = true;
+    componentCategories = ["fields", "templates", "infra"];
+  } else {
+    const includeTemplatesResult = await p.confirm({
+      message: "Include starter component implementations? (scaffolds working component files you can customize)",
+      initialValue: true
     });
-    if (p.isCancel(categories)) {
+    if (p.isCancel(includeTemplatesResult)) {
       p.cancel("Operation cancelled.");
       process.exit(0);
     }
-    componentCategories = categories;
+    includeTemplates = includeTemplatesResult;
+    if (includeTemplates) {
+      const categories = await p.multiselect({
+        message: "Which component types do you want scaffolded?",
+        options: [
+          {
+            value: "fields",
+            label: "Fields",
+            hint: "TextInput, Dropdown, Checkbox, Date, etc."
+          },
+          {
+            value: "templates",
+            label: "Templates",
+            hint: "OneColumn, TwoColumn, CaseView, DefaultForm, etc."
+          },
+          {
+            value: "widgets",
+            label: "Widgets",
+            hint: "Attachment, CaseHistory, ToDo, etc."
+          },
+          {
+            value: "infra",
+            label: "Infrastructure",
+            hint: "NavBar, ActionButtons, Stages, etc."
+          },
+          {
+            value: "designSystemExtension",
+            label: "Design System Extensions",
+            hint: "AlertBanner, FieldGroup, Pulse, etc."
+          }
+        ],
+        required: true
+      });
+      if (p.isCancel(categories)) {
+        p.cancel("Operation cancelled.");
+        process.exit(0);
+      }
+      componentCategories = categories;
+    }
   }
-  const targetDir = path2.resolve(process.cwd(), projectName);
+  const targetDir = path3.resolve(process.cwd(), projectName);
   p.note(
     [
       `${pc.bold("Project")}:       ${projectName}`,