prjct-cli 1.22.0 → 1.23.0

package/dist/core/infrastructure/command-installer.js

@@ -1,1141 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// core/schemas/model.ts
-function compareSemver(a, b) {
-  const pa = a.split(".").map(Number);
-  const pb = b.split(".").map(Number);
-  for (let i = 0; i < 3; i++) {
-    const va = pa[i] ?? 0;
-    const vb = pb[i] ?? 0;
-    if (va < vb) return -1;
-    if (va > vb) return 1;
-  }
-  return 0;
-}
-var import_zod, ClaudeModelSchema, GeminiModelSchema, AIModelSchema, ModelMetadataSchema, ModelPreferenceSchema;
-var init_model = __esm({
-  "core/schemas/model.ts"() {
-    "use strict";
-    import_zod = require("zod");
-    ClaudeModelSchema = import_zod.z.enum(["opus", "sonnet", "haiku"]);
-    GeminiModelSchema = import_zod.z.enum(["2.5-pro", "2.5-flash", "2.0-flash"]);
-    AIModelSchema = import_zod.z.string().min(1);
-    ModelMetadataSchema = import_zod.z.object({
-      /** Provider name (e.g., 'claude', 'gemini') */
-      provider: import_zod.z.string(),
-      /** Model identifier (e.g., 'opus', 'sonnet', '2.5-pro') */
-      model: import_zod.z.string(),
-      /** CLI version used */
-      cliVersion: import_zod.z.string().optional(),
-      /** When this was recorded */
-      recordedAt: import_zod.z.string()
-    });
-    ModelPreferenceSchema = import_zod.z.object({
-      /** Preferred model for this project */
-      preferredModel: import_zod.z.string().optional(),
-      /** Model used for last analysis (for mismatch detection) */
-      lastAnalysisModel: ModelMetadataSchema.optional()
-    });
-    __name(compareSemver, "compareSemver");
-  }
-});
-
-// core/utils/fs-helpers.ts
-async function fileExists(filePath) {
-  try {
-    await import_promises.default.access(filePath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-var import_promises;
-var init_fs_helpers = __esm({
-  "core/utils/fs-helpers.ts"() {
-    "use strict";
-    import_promises = __toESM(require("node:fs/promises"));
-    __name(fileExists, "fileExists");
-  }
-});
-
-// core/utils/provider-cache.ts
-async function readProviderCache() {
-  try {
-    const raw = await import_promises2.default.readFile(CACHE_FILE, "utf-8");
-    const cache = JSON.parse(raw);
-    if (!cache.timestamp || !cache.detection) return null;
-    const age = Date.now() - new Date(cache.timestamp).getTime();
-    if (age > TTL_MS) return null;
-    return cache.detection;
-  } catch {
-    return null;
-  }
-}
-async function writeProviderCache(detection) {
-  const cache = {
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    detection
-  };
-  await import_promises2.default.mkdir(CACHE_DIR, { recursive: true });
-  await import_promises2.default.writeFile(CACHE_FILE, JSON.stringify(cache, null, 2));
-}
-var import_promises2, import_node_os, import_node_path2, CACHE_DIR, CACHE_FILE, TTL_MS;
-var init_provider_cache = __esm({
-  "core/utils/provider-cache.ts"() {
-    "use strict";
-    import_promises2 = __toESM(require("node:fs/promises"));
-    import_node_os = __toESM(require("node:os"));
-    import_node_path2 = __toESM(require("node:path"));
-    CACHE_DIR = import_node_path2.default.join(import_node_os.default.homedir(), ".prjct-cli", "cache");
-    CACHE_FILE = import_node_path2.default.join(CACHE_DIR, "providers.json");
-    TTL_MS = 10 * 60 * 1e3;
-    __name(readProviderCache, "readProviderCache");
-    __name(writeProviderCache, "writeProviderCache");
-  }
-});
-
-// core/infrastructure/ai-provider.ts
-var ai_provider_exports = {};
-__export(ai_provider_exports, {
-  AntigravityProvider: () => AntigravityProvider,
-  ClaudeProvider: () => ClaudeProvider,
-  CursorProvider: () => CursorProvider,
-  GeminiProvider: () => GeminiProvider,
-  Providers: () => Providers,
-  WindsurfProvider: () => WindsurfProvider,
-  detectAllProviders: () => detectAllProviders,
-  detectAntigravity: () => detectAntigravity,
-  detectCursorProject: () => detectCursorProject,
-  detectProvider: () => detectProvider,
-  detectWindsurfProject: () => detectWindsurfProject,
-  getActiveProvider: () => getActiveProvider,
-  getCommandsDir: () => getCommandsDir,
-  getGlobalContextPath: () => getGlobalContextPath,
-  getGlobalSettingsPath: () => getGlobalSettingsPath,
-  getProjectCommandsPath: () => getProjectCommandsPath,
-  getProviderBranding: () => getProviderBranding,
-  getSkillsPath: () => getSkillsPath,
-  hasProviderConfig: () => hasProviderConfig,
-  needsCursorRouterRegeneration: () => needsCursorRouterRegeneration,
-  needsWindsurfRouterRegeneration: () => needsWindsurfRouterRegeneration,
-  selectProvider: () => selectProvider,
-  validateCliVersion: () => validateCliVersion
-});
-async function whichCommand(command) {
-  try {
-    const { stdout } = await execAsync(`which ${command}`, { timeout: SPAWN_TIMEOUT_MS });
-    return stdout.trim();
-  } catch {
-    return null;
-  }
-}
-async function getCliVersion(command) {
-  try {
-    const { stdout } = await execAsync(`${command} --version`, { timeout: SPAWN_TIMEOUT_MS });
-    const match = stdout.match(/\d+\.\d+\.\d+/);
-    return match ? match[0] : stdout.trim();
-  } catch {
-    return null;
-  }
-}
-async function detectProvider(provider) {
-  const config = Providers[provider];
-  if (!config.cliCommand) {
-    return { installed: false };
-  }
-  const cliPath = await whichCommand(config.cliCommand);
-  if (!cliPath) {
-    return { installed: false };
-  }
-  const version = await getCliVersion(config.cliCommand);
-  const versionWarning = validateCliVersion(provider, version || void 0);
-  return {
-    installed: true,
-    version: version || void 0,
-    path: cliPath,
-    versionWarning: versionWarning || void 0
-  };
-}
-function validateCliVersion(provider, version) {
-  const config = Providers[provider];
-  if (!config.minCliVersion || !version) return null;
-  if (compareSemver(version, config.minCliVersion) < 0) {
-    return `\u26A0\uFE0F ${config.displayName} v${version} is below minimum v${config.minCliVersion}. Some features may not work correctly.`;
-  }
-  return null;
-}
-async function detectAllProviders(refresh = false) {
-  if (!refresh) {
-    const cached = await readProviderCache();
-    if (cached) return cached;
-  }
-  const [claude, gemini] = await Promise.all([detectProvider("claude"), detectProvider("gemini")]);
-  const detection = { claude, gemini };
-  await writeProviderCache(detection).catch(() => {
-  });
-  return detection;
-}
-async function getActiveProvider(projectProvider) {
-  if (projectProvider && Providers[projectProvider]) {
-    return Providers[projectProvider];
-  }
-  const detection = await detectAllProviders();
-  if (detection.claude.installed && !detection.gemini.installed) {
-    return ClaudeProvider;
-  }
-  if (detection.gemini.installed && !detection.claude.installed) {
-    return GeminiProvider;
-  }
-  return ClaudeProvider;
-}
-async function hasProviderConfig(provider) {
-  const config = Providers[provider];
-  if (!config.configDir) {
-    return false;
-  }
-  return fileExists(config.configDir);
-}
-function getProviderBranding(provider) {
-  const commitFooter = `Generated with [p/](https://www.prjct.app/)`;
-  const signatures = {
-    claude: "\u26A1 prjct + Claude",
-    gemini: "\u26A1 prjct + Gemini",
-    cursor: "\u26A1 prjct + Cursor",
-    antigravity: "\u26A1 prjct + Antigravity",
-    windsurf: "\u26A1 prjct + Windsurf"
-  };
-  return {
-    commitFooter,
-    signature: signatures[provider] || "\u26A1 prjct"
-  };
-}
-async function detectCursorProject(projectRoot) {
-  const cursorDir = import_node_path3.default.join(projectRoot, ".cursor");
-  const rulesDir = import_node_path3.default.join(cursorDir, "rules");
-  const routerPath = import_node_path3.default.join(rulesDir, "prjct.mdc");
-  const [detected, routerInstalled] = await Promise.all([
-    fileExists(cursorDir),
-    fileExists(routerPath)
-  ]);
-  return {
-    detected,
-    routerInstalled,
-    projectRoot: detected ? projectRoot : void 0
-  };
-}
-async function needsCursorRouterRegeneration(projectRoot) {
-  const detection = await detectCursorProject(projectRoot);
-  return detection.detected && !detection.routerInstalled;
-}
-async function detectWindsurfProject(projectRoot) {
-  const windsurfDir = import_node_path3.default.join(projectRoot, ".windsurf");
-  const rulesDir = import_node_path3.default.join(windsurfDir, "rules");
-  const routerPath = import_node_path3.default.join(rulesDir, "prjct.md");
-  const [detected, routerInstalled] = await Promise.all([
-    fileExists(windsurfDir),
-    fileExists(routerPath)
-  ]);
-  return {
-    detected,
-    routerInstalled,
-    projectRoot: detected ? projectRoot : void 0
-  };
-}
-async function needsWindsurfRouterRegeneration(projectRoot) {
-  const detection = await detectWindsurfProject(projectRoot);
-  return detection.detected && !detection.routerInstalled;
-}
-async function detectAntigravity() {
-  const configPath = AntigravityProvider.configDir;
-  if (!configPath) {
-    return { installed: false, skillInstalled: false };
-  }
-  const skillPath = import_node_path3.default.join(configPath, "skills", "prjct", "SKILL.md");
-  const [installed, skillInstalled] = await Promise.all([
-    fileExists(configPath),
-    fileExists(skillPath)
-  ]);
-  return {
-    installed,
-    skillInstalled,
-    configPath: installed ? configPath : void 0
-  };
-}
-function getGlobalContextPath(provider) {
-  const config = Providers[provider];
-  if (!config.configDir) {
-    return null;
-  }
-  return import_node_path3.default.join(config.configDir, config.contextFile);
-}
-function getGlobalSettingsPath(provider) {
-  const config = Providers[provider];
-  if (!config.configDir || !config.settingsFile) {
-    return null;
-  }
-  return import_node_path3.default.join(config.configDir, config.settingsFile);
-}
-function getSkillsPath(provider) {
-  return Providers[provider].skillsDir;
-}
-function getCommandsDir(provider) {
-  return Providers[provider].commandsDir;
-}
-function getProjectCommandsPath(provider, projectRoot) {
-  const config = Providers[provider];
-  return import_node_path3.default.join(projectRoot, config.commandsDir);
-}
-async function selectProvider() {
-  const detection = await detectAllProviders();
-  const claudeInstalled = detection.claude.installed;
-  const geminiInstalled = detection.gemini.installed;
-  if (!claudeInstalled && !geminiInstalled) {
-    return {
-      provider: "claude",
-      userSelected: false,
-      detection
-    };
-  }
-  if (claudeInstalled && !geminiInstalled) {
-    return {
-      provider: "claude",
-      userSelected: false,
-      detection
-    };
-  }
-  if (geminiInstalled && !claudeInstalled) {
-    return {
-      provider: "gemini",
-      userSelected: false,
-      detection
-    };
-  }
-  return {
-    provider: "claude",
-    userSelected: true,
-    // Indicates user should be prompted
-    detection
-  };
-}
-var import_node_child_process, import_node_os2, import_node_path3, import_node_util, execAsync, SPAWN_TIMEOUT_MS, ClaudeProvider, GeminiProvider, AntigravityProvider, CursorProvider, WindsurfProvider, Providers;
-var init_ai_provider = __esm({
-  "core/infrastructure/ai-provider.ts"() {
-    "use strict";
-    import_node_child_process = require("node:child_process");
-    import_node_os2 = __toESM(require("node:os"));
-    import_node_path3 = __toESM(require("node:path"));
-    import_node_util = require("node:util");
-    init_model();
-    init_fs_helpers();
-    init_provider_cache();
-    execAsync = (0, import_node_util.promisify)(import_node_child_process.exec);
-    SPAWN_TIMEOUT_MS = 2e3;
-    ClaudeProvider = {
-      name: "claude",
-      displayName: "Claude Code",
-      cliCommand: "claude",
-      configDir: import_node_path3.default.join(import_node_os2.default.homedir(), ".claude"),
-      contextFile: "CLAUDE.md",
-      skillsDir: import_node_path3.default.join(import_node_os2.default.homedir(), ".claude", "skills"),
-      commandsDir: ".claude/commands",
-      commandFormat: "md",
-      settingsFile: "settings.json",
-      projectSettingsFile: "settings.local.json",
-      ignoreFile: ".claudeignore",
-      websiteUrl: "https://www.anthropic.com/claude",
-      docsUrl: "https://docs.anthropic.com/claude-code",
-      defaultModel: "sonnet",
-      supportedModels: ["opus", "sonnet", "haiku"],
-      minCliVersion: "1.0.0"
-    };
-    GeminiProvider = {
-      name: "gemini",
-      displayName: "Gemini CLI",
-      cliCommand: "gemini",
-      configDir: import_node_path3.default.join(import_node_os2.default.homedir(), ".gemini"),
-      contextFile: "GEMINI.md",
-      skillsDir: import_node_path3.default.join(import_node_os2.default.homedir(), ".gemini", "skills"),
-      commandsDir: ".gemini/commands",
-      commandFormat: "toml",
-      settingsFile: "settings.json",
-      projectSettingsFile: "settings.json",
-      ignoreFile: ".geminiignore",
-      websiteUrl: "https://geminicli.com",
-      docsUrl: "https://geminicli.com/docs",
-      defaultModel: "2.5-flash",
-      supportedModels: ["2.5-pro", "2.5-flash", "2.0-flash"],
-      minCliVersion: "1.0.0"
-    };
-    AntigravityProvider = {
-      name: "antigravity",
-      displayName: "Google Antigravity",
-      cliCommand: null,
-      // Not a CLI command, but a platform/app
-      configDir: import_node_path3.default.join(import_node_os2.default.homedir(), ".gemini", "antigravity"),
-      contextFile: "ANTIGRAVITY.md",
-      skillsDir: import_node_path3.default.join(import_node_os2.default.homedir(), ".gemini", "antigravity", "global_skills"),
-      commandsDir: ".agent/skills",
-      // Antigravity uses .agent/skills in projects
-      commandFormat: "md",
-      // Uses SKILL.md
-      settingsFile: "mcp_config.json",
-      // Uses MCP config
-      projectSettingsFile: null,
-      ignoreFile: ".agentignore",
-      // Assumed
-      websiteUrl: "https://gemini.google.com/app/antigravity",
-      docsUrl: "https://gemini.google.com/app/antigravity",
-      defaultModel: null,
-      // Platform-managed
-      supportedModels: [],
-      minCliVersion: null
-    };
-    CursorProvider = {
-      name: "cursor",
-      displayName: "Cursor IDE",
-      cliCommand: null,
-      // Not a CLI - GUI app
-      configDir: null,
-      // No global config directory
-      contextFile: "prjct.mdc",
-      // Uses .mdc format with frontmatter
-      skillsDir: null,
-      // No skills directory
-      commandsDir: ".cursor/commands",
-      rulesDir: ".cursor/rules",
-      // Cursor-specific: rules directory
-      commandFormat: "md",
-      settingsFile: null,
-      projectSettingsFile: null,
-      ignoreFile: ".cursorignore",
-      isProjectLevel: true,
-      // Config is project-level only
-      websiteUrl: "https://cursor.com",
-      docsUrl: "https://cursor.com/docs",
-      defaultModel: null,
-      // Multi-model IDE, user selects
-      supportedModels: [],
-      minCliVersion: null
-    };
-    WindsurfProvider = {
-      name: "windsurf",
-      displayName: "Windsurf IDE",
-      cliCommand: null,
-      // Not a CLI - GUI app
-      configDir: null,
-      // No global config directory
-      contextFile: "prjct.md",
-      // Uses .md format (not .mdc)
-      skillsDir: null,
-      // No skills directory
-      commandsDir: ".windsurf/workflows",
-      // Windsurf uses "workflows" not "commands"
-      rulesDir: ".windsurf/rules",
-      commandFormat: "md",
-      settingsFile: null,
-      projectSettingsFile: null,
-      ignoreFile: ".windsurfignore",
-      isProjectLevel: true,
-      // Config is project-level only
-      websiteUrl: "https://windsurf.com",
-      docsUrl: "https://docs.windsurf.com",
-      defaultModel: null,
-      // Multi-model IDE, user selects
-      supportedModels: [],
-      minCliVersion: null
-    };
-    Providers = {
-      claude: ClaudeProvider,
-      gemini: GeminiProvider,
-      cursor: CursorProvider,
-      antigravity: AntigravityProvider,
-      windsurf: WindsurfProvider
-    };
-    __name(whichCommand, "whichCommand");
-    __name(getCliVersion, "getCliVersion");
-    __name(detectProvider, "detectProvider");
-    __name(validateCliVersion, "validateCliVersion");
-    __name(detectAllProviders, "detectAllProviders");
-    __name(getActiveProvider, "getActiveProvider");
-    __name(hasProviderConfig, "hasProviderConfig");
-    __name(getProviderBranding, "getProviderBranding");
-    __name(detectCursorProject, "detectCursorProject");
-    __name(needsCursorRouterRegeneration, "needsCursorRouterRegeneration");
-    __name(detectWindsurfProject, "detectWindsurfProject");
-    __name(needsWindsurfRouterRegeneration, "needsWindsurfRouterRegeneration");
-    __name(detectAntigravity, "detectAntigravity");
-    __name(getGlobalContextPath, "getGlobalContextPath");
-    __name(getGlobalSettingsPath, "getGlobalSettingsPath");
-    __name(getSkillsPath, "getSkillsPath");
-    __name(getCommandsDir, "getCommandsDir");
-    __name(getProjectCommandsPath, "getProjectCommandsPath");
-    __name(selectProvider, "selectProvider");
-  }
-});
-
-// core/infrastructure/command-installer.ts
-var command_installer_exports = {};
-__export(command_installer_exports, {
-  CommandInstaller: () => CommandInstaller,
-  composeGlobalTemplate: () => composeGlobalTemplate,
-  default: () => command_installer_default,
-  getProfileForCommand: () => getProfileForCommand,
-  getProviderPaths: () => getProviderPaths,
-  installDocs: () => installDocs,
-  installGlobalConfig: () => installGlobalConfig,
-  isRouterInstalled: () => isRouterInstalled
-});
-module.exports = __toCommonJS(command_installer_exports);
-var import_promises3 = __toESM(require("node:fs/promises"));
-var import_node_os3 = __toESM(require("node:os"));
-var import_node_path4 = __toESM(require("node:path"));
-
-// core/types/fs.ts
-function isNodeError(error) {
-  return error instanceof Error && "code" in error;
-}
-__name(isNodeError, "isNodeError");
-function isNotFoundError(error) {
-  return isNodeError(error) && error.code === "ENOENT";
-}
-__name(isNotFoundError, "isNotFoundError");
-function getErrorMessage(error) {
-  if (error instanceof Error) return error.message;
-  if (typeof error === "string") return error;
-  return "Unknown error";
-}
-__name(getErrorMessage, "getErrorMessage");
-
-// core/utils/version.ts
-var import_node_fs = __toESM(require("node:fs"));
-var import_node_path = __toESM(require("node:path"));
-var cachedVersion = null;
-var cachedPackageJson = null;
-var cachedPackageRoot = null;
-function getPackageRoot() {
-  if (cachedPackageRoot) {
-    return cachedPackageRoot;
-  }
-  let currentDir = __dirname;
-  for (let i = 0; i < 5; i++) {
-    const packageJsonPath = import_node_path.default.join(currentDir, "package.json");
-    if (import_node_fs.default.existsSync(packageJsonPath)) {
-      try {
-        const pkg = JSON.parse(import_node_fs.default.readFileSync(packageJsonPath, "utf-8"));
-        if (pkg.name === "prjct-cli") {
-          cachedPackageRoot = currentDir;
-          return currentDir;
-        }
-      } catch (_error) {
-      }
-    }
-    currentDir = import_node_path.default.dirname(currentDir);
-  }
-  cachedPackageRoot = import_node_path.default.join(__dirname, "..", "..", "..");
-  return cachedPackageRoot;
-}
-__name(getPackageRoot, "getPackageRoot");
-function getVersion() {
-  if (cachedVersion) {
-    return cachedVersion;
-  }
-  try {
-    const packageJsonPath = import_node_path.default.join(getPackageRoot(), "package.json");
-    const packageJson = JSON.parse(import_node_fs.default.readFileSync(packageJsonPath, "utf-8"));
-    cachedVersion = packageJson.version;
-    cachedPackageJson = packageJson;
-    return cachedVersion;
-  } catch (error) {
-    console.error("Failed to read version from package.json:", getErrorMessage(error));
-    return "0.0.0";
-  }
-}
-__name(getVersion, "getVersion");
-var VERSION = getVersion();
-var PACKAGE_ROOT = getPackageRoot();
-
-// core/infrastructure/command-installer.ts
-async function loadModuleConfig() {
-  try {
-    const configPath = import_node_path4.default.join(PACKAGE_ROOT, "templates/global/modules/module-config.json");
-    const content = await import_promises3.default.readFile(configPath, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return null;
-  }
-}
-__name(loadModuleConfig, "loadModuleConfig");
-async function composeGlobalTemplate(profile) {
-  const config = await loadModuleConfig();
-  const modulesDir = import_node_path4.default.join(PACKAGE_ROOT, "templates/global/modules");
-  if (!config) {
-    const legacyPath = import_node_path4.default.join(PACKAGE_ROOT, "templates/global/CLAUDE.md");
-    return import_promises3.default.readFile(legacyPath, "utf-8");
-  }
-  const profileName = profile || config.default;
-  const selectedProfile = config.profiles[profileName];
-  if (!selectedProfile) {
-    const defaultProfile = config.profiles[config.default];
-    if (!defaultProfile) {
-      const legacyPath = import_node_path4.default.join(PACKAGE_ROOT, "templates/global/CLAUDE.md");
-      return import_promises3.default.readFile(legacyPath, "utf-8");
-    }
-  }
-  const modules = (selectedProfile || config.profiles[config.default]).modules;
-  const parts = [];
-  parts.push("<!-- prjct:start - DO NOT REMOVE THIS MARKER -->");
-  for (const moduleName of modules) {
-    try {
-      const modulePath = import_node_path4.default.join(modulesDir, moduleName);
-      const content = await import_promises3.default.readFile(modulePath, "utf-8");
-      parts.push("");
-      parts.push(content);
-    } catch {
-      console.warn(`Module not found: ${moduleName}`);
-    }
-  }
-  parts.push("");
-  parts.push("<!-- prjct:end - DO NOT REMOVE THIS MARKER -->");
-  parts.push("");
-  return parts.join("\n");
-}
-__name(composeGlobalTemplate, "composeGlobalTemplate");
-async function getProfileForCommand(command) {
-  const config = await loadModuleConfig();
-  if (!config) return "standard";
-  return config.commandProfiles[command] || config.default;
-}
-__name(getProfileForCommand, "getProfileForCommand");
-async function installDocs() {
-  try {
-    const docsDir = import_node_path4.default.join(import_node_os3.default.homedir(), ".prjct-cli", "docs");
-    const templateDocsDir = import_node_path4.default.join(PACKAGE_ROOT, "templates/global/docs");
-    await import_promises3.default.mkdir(docsDir, { recursive: true });
-    const docFiles = await import_promises3.default.readdir(templateDocsDir);
-    for (const file of docFiles) {
-      if (file.endsWith(".md")) {
-        const srcPath = import_node_path4.default.join(templateDocsDir, file);
-        const destPath = import_node_path4.default.join(docsDir, file);
-        const content = await import_promises3.default.readFile(srcPath, "utf-8");
-        await import_promises3.default.writeFile(destPath, content, "utf-8");
-      }
-    }
-    return { success: true };
-  } catch (error) {
-    return { success: false, error: getErrorMessage(error) };
-  }
-}
-__name(installDocs, "installDocs");
-async function installGlobalConfig() {
-  const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
-  const activeProvider = await aiProvider.getActiveProvider();
-  const providerName = activeProvider.name;
-  const detection = await aiProvider.detectProvider(providerName);
-  if (!detection.installed && !activeProvider.configDir) {
-    return {
-      success: false,
-      error: `${activeProvider.displayName} not detected`,
-      action: "skipped"
-    };
-  }
-  try {
-    await import_promises3.default.mkdir(activeProvider.configDir, { recursive: true });
-    const globalConfigPath = import_node_path4.default.join(activeProvider.configDir, activeProvider.contextFile);
-    const templatePath = import_node_path4.default.join(PACKAGE_ROOT, "templates", "global", activeProvider.contextFile);
-    let templateContent = "";
-    try {
-      templateContent = await import_promises3.default.readFile(templatePath, "utf-8");
-    } catch (_error) {
-      if (providerName === "claude") {
-        try {
-          templateContent = await composeGlobalTemplate("standard");
-        } catch {
-          const fallbackTemplatePath = import_node_path4.default.join(PACKAGE_ROOT, "templates/global/CLAUDE.md");
-          templateContent = await import_promises3.default.readFile(fallbackTemplatePath, "utf-8");
-        }
-      } else {
-        const fallbackTemplatePath = import_node_path4.default.join(PACKAGE_ROOT, "templates/global/CLAUDE.md");
-        templateContent = await import_promises3.default.readFile(fallbackTemplatePath, "utf-8");
-        if (providerName === "gemini") {
-          templateContent = templateContent.replace(/Claude/g, "Gemini");
-        }
-      }
-    }
-    let existingContent = "";
-    let fileExists2 = false;
-    try {
-      existingContent = await import_promises3.default.readFile(globalConfigPath, "utf-8");
-      fileExists2 = true;
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        fileExists2 = false;
-      } else {
-        throw error;
-      }
-    }
-    if (!fileExists2) {
-      await import_promises3.default.writeFile(globalConfigPath, templateContent, "utf-8");
-      return {
-        success: true,
-        action: "created",
-        path: globalConfigPath
-      };
-    } else {
-      const startMarker = "<!-- prjct:start - DO NOT REMOVE THIS MARKER -->";
-      const endMarker = "<!-- prjct:end - DO NOT REMOVE THIS MARKER -->";
-      const hasMarkers = existingContent.includes(startMarker) && existingContent.includes(endMarker);
-      if (!hasMarkers) {
-        const updatedContent = `${existingContent}
-
-${templateContent}`;
-        await import_promises3.default.writeFile(globalConfigPath, updatedContent, "utf-8");
-        return {
-          success: true,
-          action: "appended",
-          path: globalConfigPath
-        };
-      } else {
-        const beforeMarker = existingContent.substring(0, existingContent.indexOf(startMarker));
-        const afterMarker = existingContent.substring(
-          existingContent.indexOf(endMarker) + endMarker.length
-        );
-        const prjctSection = templateContent.substring(
-          templateContent.indexOf(startMarker),
-          templateContent.indexOf(endMarker) + endMarker.length
-        );
-        const updatedContent = beforeMarker + prjctSection + afterMarker;
-        await import_promises3.default.writeFile(globalConfigPath, updatedContent, "utf-8");
-        return {
-          success: true,
-          action: "updated",
-          path: globalConfigPath
-        };
-      }
-    }
-  } catch (error) {
-    return {
-      success: false,
-      error: getErrorMessage(error),
-      action: "failed"
-    };
-  }
-}
-__name(installGlobalConfig, "installGlobalConfig");
-var CommandInstaller = class {
-  static {
-    __name(this, "CommandInstaller");
-  }
-  homeDir;
-  claudeCommandsPath = "";
-  claudeConfigPath = "";
-  templatesDir;
-  _initialized = false;
-  constructor() {
-    this.homeDir = import_node_os3.default.homedir();
-    this.templatesDir = import_node_path4.default.join(PACKAGE_ROOT, "templates", "commands");
-  }
-  async ensureInit() {
-    if (this._initialized) return;
-    const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
-    const activeProvider = await aiProvider.getActiveProvider();
-    if (activeProvider.name === "gemini") {
-      this.claudeCommandsPath = import_node_path4.default.join(activeProvider.configDir, "commands");
-    } else {
-      this.claudeCommandsPath = import_node_path4.default.join(activeProvider.configDir, "commands", "p");
-    }
-    this.claudeConfigPath = activeProvider.configDir;
-    this._initialized = true;
-  }
-  /**
-   * Detect if active provider is installed
-   */
-  async detectActiveProvider() {
-    await this.ensureInit();
-    try {
-      await import_promises3.default.access(this.claudeConfigPath);
-      return true;
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return false;
-      }
-      throw error;
-    }
-  }
-  /**
-   * Detect if Claude is installed (legacy support)
-   */
-  async detectClaude() {
-    return this.detectActiveProvider();
-  }
-  /**
-   * Get list of command files to install
-   */
-  async getCommandFiles() {
-    try {
-      const files = await import_promises3.default.readdir(this.templatesDir);
-      return files.filter((f) => f.endsWith(".md"));
-    } catch (_error) {
-      return [
-        "init.md",
-        "now.md",
-        "done.md",
-        "ship.md",
-        "next.md",
-        "idea.md",
-        "recap.md",
-        "progress.md",
-        "stuck.md",
-        "context.md",
-        "analyze.md",
-        "sync.md",
-        "roadmap.md",
-        "task.md",
-        "git.md",
-        "fix.md",
-        "test.md",
-        "cleanup.md",
-        "design.md"
-      ];
-    }
-  }
-  /**
-   * Install commands to active AI agent
-   */
-  async installCommands() {
-    const providerDetected = await this.detectActiveProvider();
-    const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
-    const activeProvider = await aiProvider.getActiveProvider();
-    if (!providerDetected) {
-      return {
-        success: false,
-        error: `${activeProvider.displayName} not detected. Please install it first.`
-      };
-    }
-    try {
-      await this.installRouter();
-      await import_promises3.default.mkdir(this.claudeCommandsPath, { recursive: true });
-      const commandFiles = await this.getCommandFiles();
-      const installed = [];
-      const errors = [];
-      for (const file of commandFiles) {
-        try {
-          const sourcePath = import_node_path4.default.join(this.templatesDir, file);
-          const destPath = import_node_path4.default.join(this.claudeCommandsPath, file);
-          const content = await import_promises3.default.readFile(sourcePath, "utf-8");
-          await import_promises3.default.writeFile(destPath, content, "utf-8");
-          installed.push(file.replace(".md", ""));
-        } catch (error) {
-          errors.push({ file, error: getErrorMessage(error) });
-        }
-      }
-      return {
-        success: true,
-        installed,
-        errors,
-        path: this.claudeCommandsPath
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: getErrorMessage(error)
-      };
-    }
-  }
-  /**
-   * Uninstall commands from Claude
-   */
-  async uninstallCommands() {
-    try {
-      const commandFiles = await this.getCommandFiles();
-      const uninstalled = [];
-      const errors = [];
-      for (const file of commandFiles) {
-        try {
-          const filePath = import_node_path4.default.join(this.claudeCommandsPath, file);
-          await import_promises3.default.unlink(filePath);
-          uninstalled.push(file.replace(".md", ""));
-        } catch (error) {
-          if (error.code !== "ENOENT") {
-            errors.push({ file, error: getErrorMessage(error) });
-          }
-        }
-      }
-      try {
-        await import_promises3.default.rmdir(this.claudeCommandsPath);
-      } catch (_error) {
-      }
-      return {
-        success: true,
-        uninstalled,
-        errors
-      };
-    } catch (error) {
-      return {
-        success: false,
-        error: getErrorMessage(error)
-      };
-    }
-  }
-  /**
-   * Check if commands are already installed
-   */
-  async checkInstallation() {
-    const claudeDetected = await this.detectClaude();
-    if (!claudeDetected) {
-      return {
-        installed: false,
-        claudeDetected: false
-      };
-    }
-    try {
-      await import_promises3.default.access(this.claudeCommandsPath);
-      const files = await import_promises3.default.readdir(this.claudeCommandsPath);
-      const installedCommands = files.filter((f) => f.endsWith(".md")).map((f) => f.replace(".md", ""));
-      return {
-        installed: installedCommands.length > 0,
-        claudeDetected: true,
-        commands: installedCommands,
-        path: this.claudeCommandsPath
-      };
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return {
-          installed: false,
-          claudeDetected: true,
-          commands: []
-        };
-      }
-      throw error;
-    }
-  }
-  /**
-   * Update commands (reinstall with latest templates)
-   */
-  async updateCommands() {
-    console.log("Updating commands with latest templates...");
-    const result = await this.installCommands();
-    if (result.success && result.installed) {
-      console.log(`Updated ${result.installed.length} commands`);
-    }
-    return result;
-  }
-  /**
-   * Install to all detected editors (alias for installCommands)
-   */
-  async installToAll() {
-    return await this.installCommands();
-  }
-  /**
-   * Get installation path for Claude commands
-   */
-  async getInstallPath() {
-    await this.ensureInit();
-    return this.claudeCommandsPath;
-  }
-  /**
-   * Verify command template exists
-   */
-  async verifyTemplate(commandName) {
-    try {
-      const templatePath = import_node_path4.default.join(this.templatesDir, `${commandName}.md`);
-      await import_promises3.default.access(templatePath);
-      return true;
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return false;
-      }
-      throw error;
-    }
-  }
-  /**
-   * Install the router (p.md for Claude, p.toml for Gemini) to commands directory
-   * This enables the "p. task" natural language trigger
-   */
-  async installRouter() {
-    const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
-    const activeProvider = await aiProvider.getActiveProvider();
-    const routerFile = activeProvider.name === "gemini" ? "p.toml" : "p.md";
-    try {
-      const routerSource = import_node_path4.default.join(this.templatesDir, routerFile);
-      const routerDest = import_node_path4.default.join(activeProvider.configDir, "commands", routerFile);
-      await import_promises3.default.mkdir(import_node_path4.default.dirname(routerDest), { recursive: true });
-      const content = await import_promises3.default.readFile(routerSource, "utf-8");
-      await import_promises3.default.writeFile(routerDest, content, "utf-8");
-      return true;
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        return false;
-      }
-      throw error;
-    }
-  }
-  /**
-   * Remove legacy p.*.md files from commands root directory
-   * These were replaced by the p/ subdirectory structure in v0.50+
-   */
-  async removeLegacyCommands() {
-    const aiProvider = (init_ai_provider(), __toCommonJS(ai_provider_exports));
-    const activeProvider = await aiProvider.getActiveProvider();
-    const commandsRoot = import_node_path4.default.join(activeProvider.configDir, "commands");
-    let removed = 0;
-    try {
-      const files = await import_promises3.default.readdir(commandsRoot);
-      const legacyFiles = files.filter((f) => f.startsWith("p.") && f.endsWith(".md"));
-      for (const file of legacyFiles) {
-        try {
-          await import_promises3.default.unlink(import_node_path4.default.join(commandsRoot, file));
-          removed++;
-        } catch {
-        }
-      }
-    } catch {
-    }
-    return removed;
-  }
-  /**
-   * Sync commands - intelligent update that detects and removes orphans
-   */
-  async syncCommands() {
-    const providerDetected = await this.detectActiveProvider();
-    if (!providerDetected) {
-      return {
-        success: false,
-        error: "AI agent not detected",
-        added: 0,
-        updated: 0,
-        removed: 0
-      };
-    }
-    try {
-      await this.installRouter();
-      await import_promises3.default.mkdir(this.claudeCommandsPath, { recursive: true });
-      const templateFiles = await this.getCommandFiles();
-      let installedFiles = [];
-      try {
-        installedFiles = await import_promises3.default.readdir(this.claudeCommandsPath);
-        installedFiles = installedFiles.filter((f) => f.endsWith(".md"));
-      } catch (error) {
-        if (isNotFoundError(error)) {
-          installedFiles = [];
-        } else {
-          throw error;
-        }
-      }
-      const results = {
-        success: true,
-        added: 0,
-        updated: 0,
-        removed: 0,
-        errors: []
-      };
-      for (const file of templateFiles) {
-        try {
-          const sourcePath = import_node_path4.default.join(this.templatesDir, file);
-          const destPath = import_node_path4.default.join(this.claudeCommandsPath, file);
-          const exists = installedFiles.includes(file);
-          const content = await import_promises3.default.readFile(sourcePath, "utf-8");
-          await import_promises3.default.writeFile(destPath, content, "utf-8");
-          if (!exists) {
-            results.added++;
-          } else {
-            results.updated++;
-          }
-        } catch (error) {
-          results.errors.push({ file, error: getErrorMessage(error) });
-        }
-      }
-      await this.removeLegacyCommands();
-      return results;
-    } catch (error) {
-      return {
-        success: false,
-        error: getErrorMessage(error),
-        added: 0,
-        updated: 0,
-        removed: 0
-      };
-    }
-  }
-  /**
-   * Install or update global AI agent configuration (CLAUDE.md / GEMINI.md)
-   */
-  async installGlobalConfig() {
-    return installGlobalConfig();
-  }
-  /**
-   * Install documentation files to ~/.prjct-cli/docs/
-   */
-  async installDocs() {
-    return installDocs();
-  }
-};
-function getProviderPaths() {
-  const homeDir = import_node_os3.default.homedir();
-  return {
-    claude: {
-      commands: import_node_path4.default.join(homeDir, ".claude", "commands", "p"),
-      config: import_node_path4.default.join(homeDir, ".claude"),
-      router: import_node_path4.default.join(homeDir, ".claude", "commands", "p.md")
-    },
-    gemini: {
-      commands: import_node_path4.default.join(homeDir, ".gemini", "commands"),
-      config: import_node_path4.default.join(homeDir, ".gemini"),
-      router: import_node_path4.default.join(homeDir, ".gemini", "commands", "p.toml")
-    }
-  };
-}
-__name(getProviderPaths, "getProviderPaths");
-async function isRouterInstalled(provider) {
-  const paths = getProviderPaths();
-  const routerPath = paths[provider].router;
-  try {
-    await import_promises3.default.access(routerPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-__name(isRouterInstalled, "isRouterInstalled");
-var commandInstaller = new CommandInstaller();
-var command_installer_default = commandInstaller;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CommandInstaller,
-  composeGlobalTemplate,
-  getProfileForCommand,
-  getProviderPaths,
-  installDocs,
-  installGlobalConfig,
-  isRouterInstalled
-});