@primeuicom/agent-setup 0.1.0

package/dist/index.js

@@ -0,0 +1,1002 @@
+// src/ai-presets.ts
+var PRIMEUI_AI_PRESET_VALUES = ["codex", "claude", "cursor"];
+var DEFAULT_PRIMEUI_AI_PRESET = "codex";
+var PRIMEUI_AI_SETUP_CHOICE_VALUES = [
+  ...PRIMEUI_AI_PRESET_VALUES,
+  "nothing"
+];
+var PRIMEUI_AI_PRESET_OPTIONS = [
+  {
+    value: "codex",
+    label: "Codex",
+    hint: "Write project-local Codex config and install the shared PrimeUI AI toolchain."
+  },
+  {
+    value: "claude",
+    label: "Claude Code",
+    hint: "Write project-local Claude settings and install the shared PrimeUI AI toolchain."
+  },
+  {
+    value: "cursor",
+    label: "Cursor",
+    hint: "Write project-local Cursor config and install the shared PrimeUI AI toolchain."
+  }
+];
+var PRIMEUI_AI_SETUP_CHOICE_OPTIONS = [
+  ...PRIMEUI_AI_PRESET_OPTIONS,
+  {
+    value: "nothing",
+    label: "Nothing",
+    hint: "Skip project-local AI setup for now and leave the project unconfigured."
+  }
+];
+function isPrimeUiAiPreset(value) {
+  return PRIMEUI_AI_PRESET_VALUES.includes(value);
+}
+function isPrimeUiAiSetupChoice(value) {
+  return PRIMEUI_AI_SETUP_CHOICE_VALUES.includes(value);
+}
+
+// src/agent-presets.ts
+import { readdir } from "fs/promises";
+import path from "path";
+import { fileURLToPath } from "url";
+var PRIMEUI_SUPPORTED_AGENT_VALUES = [
+  "claude-code",
+  "codex",
+  "cursor",
+  "gemini-cli",
+  "opencode",
+  "vscode",
+  "zed",
+  "mcporter"
+];
+var PRESET_ROOT_DIRECTORY = fileURLToPath(
+  new URL("../presets", import.meta.url)
+);
+var SUPPORTED_AGENT_PRESETS = {
+  "claude-code": {
+    agent: "claude-code",
+    supportLevel: "full",
+    presetDirName: "claude-code",
+    mcpFiles: [".mcp.json", ".claude/settings.json"],
+    detectionPaths: [".claude/settings.json", ".claude"],
+    presetInferencePaths: [".claude/settings.json"],
+    skillsDirectory: ".claude/skills",
+    skillsLockFile: "skills-lock.json",
+    aiPreset: "claude"
+  },
+  codex: {
+    agent: "codex",
+    supportLevel: "full",
+    presetDirName: "codex",
+    mcpFiles: [".codex/config.toml"],
+    detectionPaths: [".codex/config.toml", ".codex"],
+    presetInferencePaths: [".codex/config.toml"],
+    skillsDirectory: ".agents/skills",
+    skillsLockFile: "skills-lock.json",
+    aiPreset: "codex"
+  },
+  cursor: {
+    agent: "cursor",
+    supportLevel: "full",
+    presetDirName: "cursor",
+    mcpFiles: [".mcp.json", ".cursor/cli.json", ".cursor/mcp.json"],
+    detectionPaths: [".cursor/cli.json", ".cursor/mcp.json", ".cursor"],
+    presetInferencePaths: [".cursor/cli.json"],
+    skillsDirectory: ".agents/skills",
+    skillsLockFile: "skills-lock.json",
+    aiPreset: "cursor"
+  },
+  "gemini-cli": {
+    agent: "gemini-cli",
+    supportLevel: "full",
+    presetDirName: "gemini-cli",
+    mcpFiles: [".gemini/settings.json"],
+    detectionPaths: [".gemini/settings.json", ".gemini"],
+    skillsDirectory: ".agents/skills",
+    skillsLockFile: "skills-lock.json"
+  },
+  opencode: {
+    agent: "opencode",
+    supportLevel: "full",
+    presetDirName: "opencode",
+    mcpFiles: ["opencode.json"],
+    detectionPaths: ["opencode.json", ".opencode"],
+    skillsDirectory: ".agents/skills",
+    skillsLockFile: "skills-lock.json"
+  },
+  vscode: {
+    agent: "vscode",
+    supportLevel: "mcp-only",
+    presetDirName: "vscode",
+    mcpFiles: [".vscode/mcp.json"],
+    detectionPaths: [".vscode/mcp.json", ".vscode"]
+  },
+  zed: {
+    agent: "zed",
+    supportLevel: "mcp-only",
+    presetDirName: "zed",
+    mcpFiles: [".zed/settings.json"],
+    detectionPaths: [".zed/settings.json", ".zed"]
+  },
+  mcporter: {
+    agent: "mcporter",
+    supportLevel: "mcp-only",
+    presetDirName: "mcporter",
+    mcpFiles: ["config/mcporter.json"],
+    detectionPaths: ["config/mcporter.json"]
+  }
+};
+function listPrimeUiSupportedAgents() {
+  return [...PRIMEUI_SUPPORTED_AGENT_VALUES];
+}
+function listPrimeUiSupportedAgentPresets() {
+  return PRIMEUI_SUPPORTED_AGENT_VALUES.map((agent) => ({
+    ...SUPPORTED_AGENT_PRESETS[agent]
+  }));
+}
+function getPrimeUiSupportedAgentPreset(agent) {
+  return {
+    ...SUPPORTED_AGENT_PRESETS[agent]
+  };
+}
+function getPrimeUiAgentPresetDirectory(agent) {
+  return path.join(
+    PRESET_ROOT_DIRECTORY,
+    SUPPORTED_AGENT_PRESETS[agent].presetDirName
+  );
+}
+async function walkFiles(rootDirectory, currentDirectory) {
+  const entries = await readdir(currentDirectory, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const absolutePath = path.join(currentDirectory, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await walkFiles(rootDirectory, absolutePath));
+      continue;
+    }
+    if (entry.isFile()) {
+      files.push(
+        path.relative(rootDirectory, absolutePath).replaceAll(path.sep, "/")
+      );
+    }
+  }
+  return files;
+}
+async function listPrimeUiAgentPresetFiles(agent) {
+  const presetDirectory = getPrimeUiAgentPresetDirectory(agent);
+  const files = await walkFiles(presetDirectory, presetDirectory);
+  return files.sort();
+}
+
+// src/ai-setup-config.ts
+var ROOT_AGENTS_PATH = "AGENTS.md";
+var CLAUDE_INSTRUCTIONS_PATH = "CLAUDE.md";
+var CURSOR_CLI_CONFIG_PATH = ".cursor/cli.json";
+var CLAUDE_SETTINGS_PATH = ".claude/settings.json";
+var CODEX_CONFIG_PATH = ".codex/config.toml";
+var SHARED_MCP_CONFIG = {
+  mcpServers: {
+    primeui: {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "@primeuicom/mcp@latest"]
+    },
+    "chrome-devtools": {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "chrome-devtools-mcp@latest"]
+    },
+    "next-devtools": {
+      type: "stdio",
+      command: "npx",
+      args: ["-y", "next-devtools-mcp@latest"]
+    }
+  }
+};
+var SHARED_MCP_OVERRIDES = {
+  mcpServers: {
+    primeui: {
+      env: {
+        PRIMEUI_API_BASE_URL: {
+          from: "runtime-env",
+          envName: "PRIMEUI_API_BASE_URL",
+          optional: true
+        }
+      }
+    }
+  }
+};
+var SHARED_SKILL_COLLECTIONS = [
+  {
+    source: "github/awesome-copilot",
+    skills: ["git-commit"]
+  },
+  {
+    source: "vercel-labs/next-skills",
+    skills: ["next-best-practices"]
+  },
+  {
+    source: "pproenca/dot-skills",
+    skills: ["vitest"]
+  },
+  {
+    source: "wshobson/agents",
+    skills: ["tailwind-design-system"]
+  }
+];
+var SHARED_PERMISSION_PROFILE = {
+  shellCommands: ["pnpm", "git", "node", "npx"],
+  allowReadAll: true,
+  allowWriteAll: true,
+  allowMcpServers: Object.keys(SHARED_MCP_CONFIG.mcpServers),
+  enableNetworkAccess: true
+};
+var PRESET_DEFINITIONS = {
+  codex: {
+    agent: "codex",
+    configFiles: [CODEX_CONFIG_PATH],
+    instructionFiles: [ROOT_AGENTS_PATH]
+  },
+  claude: {
+    agent: "claude-code",
+    configFiles: [CLAUDE_SETTINGS_PATH],
+    instructionFiles: [CLAUDE_INSTRUCTIONS_PATH]
+  },
+  cursor: {
+    agent: "cursor",
+    configFiles: [CURSOR_CLI_CONFIG_PATH],
+    instructionFiles: [ROOT_AGENTS_PATH]
+  }
+};
+var PRIMEUI_SHARED_MCP_CONFIG_PATH = ".mcp.json";
+var PRIMEUI_SHARED_SKILLS_LOCK_PATH = "skills-lock.json";
+var PRIMEUI_SHARED_VERIFICATION_SCRIPTS = [
+  "format",
+  "lint",
+  "typecheck",
+  "build"
+];
+var PRIMEUI_LOCAL_AI_ARTIFACT_PATHS = [
+  ".codex",
+  ".claude",
+  ".cursor",
+  ".agents",
+  PRIMEUI_SHARED_MCP_CONFIG_PATH,
+  PRIMEUI_SHARED_SKILLS_LOCK_PATH
+];
+var PRIMEUI_MANAGED_AI_CLEANUP_PATHS = [
+  ".codex",
+  ".claude",
+  ".cursor",
+  PRIMEUI_SHARED_MCP_CONFIG_PATH
+];
+var PRIMEUI_INSTRUCTION_FILE_PATHS = [
+  ROOT_AGENTS_PATH,
+  CLAUDE_INSTRUCTIONS_PATH
+];
+var SHARED_WORKFLOW_LINES = [
+  "- Use `pnpm` for installs and scripts.",
+  "- Use the checked-in project scripts before finishing code changes:",
+  "  - `pnpm format`",
+  "  - `pnpm lint`",
+  "  - `pnpm typecheck`",
+  "  - `pnpm build`",
+  "- Start the local preview with `pnpm dev`."
+];
+var SHARED_PRIMEUI_LINES = [
+  "- PrimeUI project linkage lives in `.primeui/project.json`.",
+  "- PrimeUI CLI configures project-local AI tooling with `npx @primeuicom/cli ai-setup --ai-preset <codex|claude|cursor>`.",
+  "- Codex stores PrimeUI MCP server entries in `.codex/config.toml`; Claude and Cursor also keep shared MCP definitions in `.mcp.json`.",
+  "- Keep agent configuration project-local and reversible. Do not modify user-global config from this repository."
+];
+function readRuntimeEnvBinding(binding, env) {
+  if (binding.from !== "runtime-env") {
+    return void 0;
+  }
+  const value = env[binding.envName]?.trim();
+  if (!value) {
+    return void 0;
+  }
+  return value;
+}
+function buildCodexPermissionConfigLines() {
+  return [
+    'approval_policy = "never"',
+    'sandbox_mode = "workspace-write"',
+    "",
+    "[sandbox_workspace_write]",
+    `network_access = ${SHARED_PERMISSION_PROFILE.enableNetworkAccess ? "true" : "false"}`
+  ];
+}
+function buildClaudeAllowedPermissions() {
+  const mcpPermissions = SHARED_PERMISSION_PROFILE.allowMcpServers.map(
+    (serverName) => `mcp__${serverName}__*`
+  );
+  return [
+    ...SHARED_PERMISSION_PROFILE.shellCommands.map(
+      (command) => `Bash(${command}:*)`
+    ),
+    "Bash(sleep:*)",
+    "Bash(kill:*)",
+    "Bash(wait:*)",
+    ...SHARED_PERMISSION_PROFILE.allowReadAll ? ["Read"] : [],
+    ...SHARED_PERMISSION_PROFILE.allowWriteAll ? ["Edit"] : [],
+    ...mcpPermissions
+  ];
+}
+function buildCursorAllowedPermissions() {
+  const mcpPermissions = SHARED_PERMISSION_PROFILE.allowMcpServers.map(
+    (serverName) => `Mcp(${serverName}:*)`
+  );
+  return [
+    ...SHARED_PERMISSION_PROFILE.shellCommands.map(
+      (command) => `Shell(${command}:*)`
+    ),
+    ...SHARED_PERMISSION_PROFILE.allowReadAll ? ["Read(**/*)"] : [],
+    ...SHARED_PERMISSION_PROFILE.allowWriteAll ? ["Write(**/*)"] : [],
+    ...mcpPermissions
+  ];
+}
+function buildSharedWorkflowSectionLines() {
+  return ["## Workflow", "", ...SHARED_WORKFLOW_LINES];
+}
+function buildSharedPrimeUiSectionLines() {
+  return ["## PrimeUI Integration", "", ...SHARED_PRIMEUI_LINES];
+}
+function buildSharedAgentsInstructionsContent() {
+  return [
+    "# PrimeUI Exported Project",
+    "",
+    ...buildSharedWorkflowSectionLines(),
+    "",
+    ...buildSharedPrimeUiSectionLines(),
+    "",
+    "## Codex and Cursor Notes",
+    "",
+    "- Codex and Cursor both read repository instructions from `AGENTS.md`.",
+    "- Project-local Codex settings live in `.codex/config.toml` after CLI AI setup.",
+    "- Project-local Cursor settings live in `.cursor/cli.json` after CLI AI setup.",
+    "- PrimeUI CLI installs shared MCP servers and public skills project-locally during AI setup.",
+    "- The user still needs a local agent install/login for Codex or Cursor."
+  ].join("\n");
+}
+function buildClaudeInstructionsContent() {
+  return [
+    "# PrimeUI Exported Project",
+    "",
+    ...buildSharedWorkflowSectionLines(),
+    "",
+    ...buildSharedPrimeUiSectionLines(),
+    "",
+    "## Claude Code Notes",
+    "",
+    "- Claude Code reads repository instructions from `CLAUDE.md`.",
+    "- Project-local Claude settings live in `.claude/settings.json` after CLI AI setup.",
+    "- PrimeUI CLI installs shared MCP servers and public skills project-locally during AI setup.",
+    "- The user still needs a local Claude Code install/login."
+  ].join("\n");
+}
+function getPrimeUiAiAgent(aiPreset) {
+  return PRESET_DEFINITIONS[aiPreset].agent;
+}
+function getPrimeUiManagedConfigFiles(aiPreset) {
+  return [...PRESET_DEFINITIONS[aiPreset].configFiles];
+}
+function getPrimeUiManagedInstructionFiles(aiPreset) {
+  return [...PRESET_DEFINITIONS[aiPreset].instructionFiles];
+}
+function getPrimeUiManagedConfigFileContents(aiPreset) {
+  switch (aiPreset) {
+    case "codex":
+      return {
+        [CODEX_CONFIG_PATH]: buildPrimeUiCodexConfigToml()
+      };
+    case "claude":
+      return {
+        [CLAUDE_SETTINGS_PATH]: buildPrimeUiClaudeSettingsFileContent()
+      };
+    case "cursor":
+      return {
+        [CURSOR_CLI_CONFIG_PATH]: buildPrimeUiCursorCliConfigFileContent()
+      };
+  }
+}
+function getPrimeUiManagedInstructionFileContents(aiPreset) {
+  switch (aiPreset) {
+    case "codex":
+    case "cursor":
+      return {
+        [ROOT_AGENTS_PATH]: `${buildSharedAgentsInstructionsContent()}
+`
+      };
+    case "claude":
+      return {
+        [CLAUDE_INSTRUCTIONS_PATH]: `${buildClaudeInstructionsContent()}
+`
+      };
+  }
+}
+function listPrimeUiAiSkillRefs() {
+  return SHARED_SKILL_COLLECTIONS.flatMap(
+    (collection) => collection.skills.map((skill) => `${collection.source}@${skill}`)
+  );
+}
+function listPrimeUiAiSkillCollections() {
+  return SHARED_SKILL_COLLECTIONS.map((collection) => ({
+    source: collection.source,
+    skills: [...collection.skills]
+  }));
+}
+function getPrimeUiInstalledSkillsDirectory(aiPreset) {
+  return aiPreset === "claude" ? ".claude/skills" : ".agents/skills";
+}
+function listPrimeUiAllowedShellCommands() {
+  return [...SHARED_PERMISSION_PROFILE.shellCommands];
+}
+function listPrimeUiAllowedMcpServers() {
+  return [...SHARED_PERMISSION_PROFILE.allowMcpServers];
+}
+function listPrimeUiClaudeAllowedPermissions() {
+  return buildClaudeAllowedPermissions();
+}
+function listPrimeUiCursorAllowedPermissions() {
+  return buildCursorAllowedPermissions();
+}
+function listPrimeUiInstructionFilePaths() {
+  return [...PRIMEUI_INSTRUCTION_FILE_PATHS];
+}
+function listPrimeUiVerificationScripts() {
+  return [...PRIMEUI_SHARED_VERIFICATION_SCRIPTS];
+}
+function shouldWritePrimeUiSharedMcpConfig(aiPreset) {
+  return aiPreset !== "codex";
+}
+function resolvePrimeUiMcpConfig(env = process.env) {
+  const mcpServers = Object.fromEntries(
+    Object.entries(SHARED_MCP_CONFIG.mcpServers).map(
+      ([serverName, serverConfig]) => {
+        const overrideEnv = SHARED_MCP_OVERRIDES.mcpServers[serverName]?.env;
+        const resolvedEnvEntries = Object.entries(overrideEnv ?? {}).map(([envName, binding]) => {
+          const value = readRuntimeEnvBinding(binding, env);
+          if (!value) {
+            return void 0;
+          }
+          return [envName, value];
+        }).filter(
+          (entry) => Boolean(entry)
+        );
+        return [
+          serverName,
+          {
+            ...serverConfig,
+            ...resolvedEnvEntries.length > 0 ? { env: Object.fromEntries(resolvedEnvEntries) } : {}
+          }
+        ];
+      }
+    )
+  );
+  return { mcpServers };
+}
+function createPrimeUiAiSetupEnv(env = process.env, primeUiApiBaseUrl) {
+  if (!primeUiApiBaseUrl?.trim()) {
+    return env;
+  }
+  return {
+    ...env,
+    PRIMEUI_API_BASE_URL: primeUiApiBaseUrl.trim()
+  };
+}
+function buildPrimeUiCodexConfigToml() {
+  return [
+    "# Project-scoped Codex config for this PrimeUI project.",
+    "# PrimeUI CLI manages this file and add-mcp appends MCP server entries.",
+    ...buildCodexPermissionConfigLines(),
+    ""
+  ].join("\n");
+}
+function buildPrimeUiClaudeSettings() {
+  return {
+    enableAllProjectMcpServers: true,
+    enabledMcpjsonServers: SHARED_PERMISSION_PROFILE.allowMcpServers,
+    permissions: {
+      allow: buildClaudeAllowedPermissions(),
+      deny: []
+    }
+  };
+}
+function buildPrimeUiClaudeSettingsFileContent() {
+  return `${JSON.stringify(buildPrimeUiClaudeSettings(), null, 2)}
+`;
+}
+function buildPrimeUiCursorCliConfig() {
+  return {
+    version: 1,
+    permissions: {
+      allow: buildCursorAllowedPermissions(),
+      deny: []
+    }
+  };
+}
+function buildPrimeUiCursorCliConfigFileContent() {
+  return `${JSON.stringify(buildPrimeUiCursorCliConfig(), null, 2)}
+`;
+}
+
+// src/ai-setup.ts
+import {
+  access,
+  cp,
+  mkdir,
+  mkdtemp,
+  readFile,
+  rm,
+  writeFile
+} from "fs/promises";
+import os from "os";
+import path2 from "path";
+import { execa } from "execa";
+
+// src/errors.ts
+var PRIMEUI_AGENT_SETUP_ERROR_CODES = {
+  AI_SETUP_FAILED: "AI_SETUP_FAILED",
+  UNKNOWN: "UNKNOWN"
+};
+var PrimeUiAgentSetupError = class extends Error {
+  code;
+  hint;
+  constructor(message, options = {}) {
+    super(message, { cause: options.cause });
+    this.name = "PrimeUiAgentSetupError";
+    this.code = options.code ?? PRIMEUI_AGENT_SETUP_ERROR_CODES.UNKNOWN;
+    this.hint = options.hint;
+  }
+};
+function toPrimeUiAgentSetupError(error) {
+  if (error instanceof PrimeUiAgentSetupError) {
+    return error;
+  }
+  return new PrimeUiAgentSetupError(
+    error instanceof Error ? error.message : String(error),
+    {
+      cause: error
+    }
+  );
+}
+
+// src/ai-setup.ts
+function formatCommandHint(command, args) {
+  return [command, ...args].join(" ");
+}
+function createCommandFailure(message, command, args, result) {
+  const stderr = result.stderr.trim();
+  const stdout = result.stdout.trim();
+  return new PrimeUiAgentSetupError(message, {
+    code: PRIMEUI_AGENT_SETUP_ERROR_CODES.AI_SETUP_FAILED,
+    hint: stderr || stdout || `Retry from the project directory with: ${formatCommandHint(command, args)}`
+  });
+}
+function resolveAddMcpInstallTarget(serverName, serverConfig) {
+  if (serverConfig.type === "stdio" && serverConfig.command === "npx" && serverConfig.args.length === 2 && serverConfig.args[0] === "-y") {
+    return serverConfig.args[1];
+  }
+  throw new PrimeUiAgentSetupError(
+    `PrimeUI AI setup cannot install MCP server "${serverName}" from this config shape automatically.`,
+    {
+      code: PRIMEUI_AGENT_SETUP_ERROR_CODES.AI_SETUP_FAILED,
+      hint: "Only stdio MCP entries shaped like `npx -y <package>` are supported for automated setup right now."
+    }
+  );
+}
+function collapseStringArrayBlocks(json) {
+  return json.replace(
+    /\[\n(\s+)((?:"(?:\\.|[^"\n])*"(?:,\n\1"(?:\\.|[^"\n])*")*))\n(\s*)\]/g,
+    (_match, _indent, items) => {
+      const collapsedItems = items.split("\n").map((line) => line.trim()).join(" ");
+      return `[${collapsedItems}]`;
+    }
+  );
+}
+function formatSharedMcpConfigFileContent(config) {
+  return `${collapseStringArrayBlocks(JSON.stringify(config, null, 2))}
+`;
+}
+async function pathExists(targetPath) {
+  try {
+    await access(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function writeManagedFile(projectDirectory, relativePath, content) {
+  const filePath = path2.join(projectDirectory, relativePath);
+  await mkdir(path2.dirname(filePath), { recursive: true });
+  await writeFile(filePath, content, "utf-8");
+}
+async function cleanupManagedAiFiles(projectDirectory) {
+  for (const relativePath of PRIMEUI_MANAGED_AI_CLEANUP_PATHS) {
+    await rm(path2.join(projectDirectory, relativePath), {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+  }
+}
+function listAiSetupBackupPaths() {
+  return [
+    ...PRIMEUI_LOCAL_AI_ARTIFACT_PATHS,
+    ...listPrimeUiInstructionFilePaths()
+  ];
+}
+async function createAiSetupBackup(projectDirectory) {
+  const backupDir = await mkdtemp(
+    path2.join(os.tmpdir(), "primeui-agent-setup-backup-")
+  );
+  for (const relativePath of listAiSetupBackupPaths()) {
+    const sourcePath = path2.join(projectDirectory, relativePath);
+    if (!await pathExists(sourcePath)) {
+      continue;
+    }
+    const backupPath = path2.join(backupDir, relativePath);
+    await mkdir(path2.dirname(backupPath), { recursive: true });
+    await cp(sourcePath, backupPath, {
+      force: true,
+      recursive: true
+    });
+  }
+  return backupDir;
+}
+async function removeLocalAiArtifacts(projectDirectory) {
+  for (const relativePath of listAiSetupBackupPaths()) {
+    await rm(path2.join(projectDirectory, relativePath), {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+  }
+}
+async function restoreAiSetupBackup(projectDirectory, backupDir) {
+  await removeLocalAiArtifacts(projectDirectory);
+  for (const relativePath of listAiSetupBackupPaths()) {
+    const backupPath = path2.join(backupDir, relativePath);
+    if (!await pathExists(backupPath)) {
+      continue;
+    }
+    const targetPath = path2.join(projectDirectory, relativePath);
+    await mkdir(path2.dirname(targetPath), { recursive: true });
+    await cp(backupPath, targetPath, {
+      force: true,
+      recursive: true
+    });
+  }
+}
+async function writeManagedPresetFiles(projectDirectory, aiPreset) {
+  const managedFiles = getPrimeUiManagedConfigFileContents(aiPreset);
+  for (const [relativePath, content] of Object.entries(managedFiles)) {
+    await writeManagedFile(projectDirectory, relativePath, content);
+  }
+}
+async function writeManagedInstructionFiles(projectDirectory, aiPreset) {
+  const managedFiles = getPrimeUiManagedInstructionFileContents(aiPreset);
+  for (const [relativePath, content] of Object.entries(managedFiles)) {
+    await writeManagedFile(projectDirectory, relativePath, content);
+  }
+}
+async function writeSharedMcpConfig(projectDirectory, config) {
+  await writeManagedFile(
+    projectDirectory,
+    PRIMEUI_SHARED_MCP_CONFIG_PATH,
+    formatSharedMcpConfigFileContent(config)
+  );
+}
+async function installMcpServer(params) {
+  const installTarget = resolveAddMcpInstallTarget(
+    params.serverName,
+    params.serverConfig
+  );
+  const args = [
+    "-y",
+    "add-mcp@latest",
+    "-a",
+    params.agent,
+    "-n",
+    params.serverName,
+    installTarget,
+    "--yes"
+  ];
+  for (const [envName, value] of Object.entries(
+    params.serverConfig.env ?? {}
+  )) {
+    args.push("--env", `${envName}=${value}`);
+  }
+  const result = await params.execaFn("npx", args, {
+    cwd: params.cwd,
+    reject: false,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (result.exitCode !== 0) {
+    throw createCommandFailure(
+      `Failed to install MCP server "${params.serverName}" for ${params.agent}.`,
+      "npx",
+      args,
+      result
+    );
+  }
+}
+async function cleanupUnmanagedInstructionFiles(projectDirectory, aiPreset) {
+  const managedInstructionFiles = new Set(
+    getPrimeUiManagedInstructionFiles(aiPreset)
+  );
+  for (const relativePath of listPrimeUiInstructionFilePaths()) {
+    if (managedInstructionFiles.has(relativePath)) {
+      continue;
+    }
+    await rm(path2.join(projectDirectory, relativePath), {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+  }
+}
+function getTopLevelArtifactPath(relativePath) {
+  const [topLevelPath] = relativePath.split("/", 1);
+  return topLevelPath || relativePath;
+}
+async function cleanupUnmanagedLocalArtifacts(projectDirectory, aiPreset) {
+  const managedArtifactPaths = /* @__PURE__ */ new Set([
+    PRIMEUI_SHARED_SKILLS_LOCK_PATH,
+    ...getPrimeUiManagedConfigFiles(aiPreset).map(getTopLevelArtifactPath)
+  ]);
+  managedArtifactPaths.add(
+    getTopLevelArtifactPath(getPrimeUiInstalledSkillsDirectory(aiPreset))
+  );
+  if (shouldWritePrimeUiSharedMcpConfig(aiPreset)) {
+    managedArtifactPaths.add(PRIMEUI_SHARED_MCP_CONFIG_PATH);
+  }
+  for (const relativePath of PRIMEUI_LOCAL_AI_ARTIFACT_PATHS) {
+    if (managedArtifactPaths.has(relativePath)) {
+      continue;
+    }
+    await rm(path2.join(projectDirectory, relativePath), {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+  }
+}
+async function normalizeInstalledSkillsDirectory(projectDirectory, aiPreset) {
+  const expectedSkillsDirectory = path2.join(
+    projectDirectory,
+    getPrimeUiInstalledSkillsDirectory(aiPreset)
+  );
+  const sharedSkillsDirectory = path2.join(
+    projectDirectory,
+    ".agents",
+    "skills"
+  );
+  if (aiPreset === "claude") {
+    if (!await pathExists(expectedSkillsDirectory) && await pathExists(sharedSkillsDirectory)) {
+      await mkdir(path2.dirname(expectedSkillsDirectory), { recursive: true });
+      await cp(sharedSkillsDirectory, expectedSkillsDirectory, {
+        force: true,
+        recursive: true
+      });
+    }
+    await rm(path2.join(projectDirectory, ".agents"), {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+  }
+}
+async function normalizeCodexConfigFormatting(projectDirectory, aiPreset) {
+  if (aiPreset !== "codex") {
+    return;
+  }
+  const codexConfigPath = path2.join(projectDirectory, ".codex", "config.toml");
+  if (!await pathExists(codexConfigPath)) {
+    return;
+  }
+  const rawConfig = await readFile(codexConfigPath, "utf-8");
+  const normalizedConfig = rawConfig.split("\n").map((line) => line.trimStart()).join("\n");
+  if (normalizedConfig !== rawConfig) {
+    await writeFile(codexConfigPath, normalizedConfig, "utf-8");
+  }
+}
+async function installSkill(params) {
+  const args = [
+    "-y",
+    "skills@latest",
+    "add",
+    params.skillRef,
+    "--copy",
+    "--agent",
+    params.agent,
+    "-y"
+  ];
+  const result = await params.execaFn("npx", args, {
+    cwd: params.cwd,
+    reject: false,
+    stdout: "pipe",
+    stderr: "pipe"
+  });
+  if (result.exitCode !== 0) {
+    throw createCommandFailure(
+      `Failed to install skill "${params.skillRef}".`,
+      "npx",
+      args,
+      result
+    );
+  }
+}
+async function applyPrimeUiAiSetup(projectDirectory, options) {
+  const execaFn = options.execaFn ?? execa;
+  const aiPreset = options.aiPreset;
+  const agent = getPrimeUiAiAgent(aiPreset);
+  const resolvedMcpConfig = resolvePrimeUiMcpConfig(options.env);
+  const backupDir = await createAiSetupBackup(projectDirectory);
+  try {
+    await cleanupManagedAiFiles(projectDirectory);
+    await writeManagedPresetFiles(projectDirectory, aiPreset);
+    await writeManagedInstructionFiles(projectDirectory, aiPreset);
+    const installedMcpServers = [];
+    for (const [serverName, serverConfig] of Object.entries(
+      resolvedMcpConfig.mcpServers
+    )) {
+      await installMcpServer({
+        agent,
+        cwd: projectDirectory,
+        execaFn,
+        serverName,
+        serverConfig
+      });
+      installedMcpServers.push(serverName);
+    }
+    const installedSkillRefs = [];
+    for (const skillRef of listPrimeUiAiSkillRefs()) {
+      await installSkill({
+        agent,
+        cwd: projectDirectory,
+        execaFn,
+        skillRef
+      });
+      installedSkillRefs.push(skillRef);
+    }
+    await normalizeInstalledSkillsDirectory(projectDirectory, aiPreset);
+    await normalizeCodexConfigFormatting(projectDirectory, aiPreset);
+    if (shouldWritePrimeUiSharedMcpConfig(aiPreset)) {
+      await writeSharedMcpConfig(projectDirectory, resolvedMcpConfig);
+    }
+    await cleanupUnmanagedLocalArtifacts(projectDirectory, aiPreset);
+    await cleanupUnmanagedInstructionFiles(projectDirectory, aiPreset);
+    return {
+      status: "applied",
+      aiPreset,
+      agent,
+      installedMcpServers,
+      installedSkillRefs
+    };
+  } catch (error) {
+    try {
+      await restoreAiSetupBackup(projectDirectory, backupDir);
+    } catch (restoreError) {
+      throw new PrimeUiAgentSetupError(
+        "PrimeUI AI setup failed and the previous local AI setup could not be restored cleanly.",
+        {
+          code: PRIMEUI_AGENT_SETUP_ERROR_CODES.AI_SETUP_FAILED,
+          hint: restoreError instanceof Error ? restoreError.message : String(restoreError),
+          cause: error
+        }
+      );
+    }
+    throw error;
+  } finally {
+    await rm(backupDir, {
+      force: true,
+      recursive: true
+    }).catch(() => void 0);
+  }
+}
+
+// src/detect-agent-setup.ts
+import { access as access2 } from "fs/promises";
+import path3 from "path";
+async function pathExists2(targetPath) {
+  try {
+    await access2(targetPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getDetectionPaths(preset) {
+  return preset.detectionPaths;
+}
+async function detectPrimeUiLocalAgentSetup(projectDirectory) {
+  const detectedAgents = [];
+  for (const preset of listPrimeUiSupportedAgentPresets()) {
+    const matchedPaths = [];
+    for (const relativePath of getDetectionPaths(preset)) {
+      if (await pathExists2(path3.join(projectDirectory, relativePath))) {
+        matchedPaths.push(relativePath);
+      }
+    }
+    if (matchedPaths.length === 0) {
+      continue;
+    }
+    detectedAgents.push({
+      agent: preset.agent,
+      supportLevel: preset.supportLevel,
+      matchedPaths
+    });
+  }
+  detectedAgents.sort((left, right) => left.agent.localeCompare(right.agent));
+  return {
+    detectedAgents
+  };
+}
+
+// src/infer-ai-preset.ts
+async function detectPrimeUiAiPresetCandidates(projectDirectory) {
+  const detection = await detectPrimeUiLocalAgentSetup(projectDirectory);
+  const candidates = detection.detectedAgents.filter((signal) => {
+    const preset = getPrimeUiSupportedAgentPreset(signal.agent);
+    const strongPaths = preset.presetInferencePaths ?? [];
+    return strongPaths.some(
+      (inferencePath) => signal.matchedPaths.includes(inferencePath)
+    );
+  }).map((signal) => getPrimeUiSupportedAgentPreset(signal.agent).aiPreset).filter((preset) => Boolean(preset));
+  return Array.from(new Set(candidates));
+}
+async function inferPrimeUiAiPreset(projectDirectory) {
+  const candidates = await detectPrimeUiAiPresetCandidates(projectDirectory);
+  return candidates.length === 1 ? candidates[0] : void 0;
+}
+export {
+  DEFAULT_PRIMEUI_AI_PRESET,
+  PRIMEUI_AGENT_SETUP_ERROR_CODES,
+  PRIMEUI_AI_PRESET_OPTIONS,
+  PRIMEUI_AI_PRESET_VALUES,
+  PRIMEUI_AI_SETUP_CHOICE_OPTIONS,
+  PRIMEUI_AI_SETUP_CHOICE_VALUES,
+  PRIMEUI_LOCAL_AI_ARTIFACT_PATHS,
+  PRIMEUI_MANAGED_AI_CLEANUP_PATHS,
+  PRIMEUI_SHARED_MCP_CONFIG_PATH,
+  PRIMEUI_SHARED_SKILLS_LOCK_PATH,
+  PRIMEUI_SHARED_VERIFICATION_SCRIPTS,
+  PRIMEUI_SUPPORTED_AGENT_VALUES,
+  PrimeUiAgentSetupError,
+  applyPrimeUiAiSetup,
+  buildPrimeUiClaudeSettings,
+  buildPrimeUiClaudeSettingsFileContent,
+  buildPrimeUiCodexConfigToml,
+  buildPrimeUiCursorCliConfig,
+  buildPrimeUiCursorCliConfigFileContent,
+  createPrimeUiAiSetupEnv,
+  detectPrimeUiAiPresetCandidates,
+  detectPrimeUiLocalAgentSetup,
+  getPrimeUiAgentPresetDirectory,
+  getPrimeUiAiAgent,
+  getPrimeUiInstalledSkillsDirectory,
+  getPrimeUiManagedConfigFileContents,
+  getPrimeUiManagedConfigFiles,
+  getPrimeUiManagedInstructionFileContents,
+  getPrimeUiManagedInstructionFiles,
+  getPrimeUiSupportedAgentPreset,
+  inferPrimeUiAiPreset,
+  isPrimeUiAiPreset,
+  isPrimeUiAiSetupChoice,
+  listPrimeUiAgentPresetFiles,
+  listPrimeUiAiSkillCollections,
+  listPrimeUiAiSkillRefs,
+  listPrimeUiAllowedMcpServers,
+  listPrimeUiAllowedShellCommands,
+  listPrimeUiClaudeAllowedPermissions,
+  listPrimeUiCursorAllowedPermissions,
+  listPrimeUiInstructionFilePaths,
+  listPrimeUiSupportedAgentPresets,
+  listPrimeUiSupportedAgents,
+  listPrimeUiVerificationScripts,
+  resolvePrimeUiMcpConfig,
+  shouldWritePrimeUiSharedMcpConfig,
+  toPrimeUiAgentSetupError
+};
+//# sourceMappingURL=index.js.map