prjct-cli 1.22.0 → 1.24.0

package/dist/core/infrastructure/setup.js

@@ -1,2244 +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/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/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/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_process2, 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_process2 = 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_process2.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/setup.ts
-var setup_exports = {};
-__export(setup_exports, {
-  hasCursorProject: () => hasCursorProject,
-  hasWindsurfProject: () => hasWindsurfProject,
-  installAntigravitySkill: () => installAntigravitySkill,
-  installCursorProject: () => installCursorProject,
-  installWindsurfProject: () => installWindsurfProject,
-  needsAntigravityInstallation: () => needsAntigravityInstallation,
-  needsCursorRegeneration: () => needsCursorRegeneration,
-  needsWindsurfRegeneration: () => needsWindsurfRegeneration,
-  run: () => run
-});
-module.exports = __toCommonJS(setup_exports);
-var import_node_child_process3 = require("node:child_process");
-var import_promises5 = __toESM(require("node:fs/promises"));
-var import_node_os5 = __toESM(require("node:os"));
-var import_node_path6 = __toESM(require("node:path"));
-var import_chalk = __toESM(require("chalk"));
-
-// core/constants/index.ts
-var TIMEOUTS = {
-  /** Tool availability checks (git --version, npm --version) */
-  TOOL_CHECK: 5e3,
-  /** Standard git operations (status, add, commit) */
-  GIT_OPERATION: 1e4,
-  /** Git clone with --depth 1 */
-  GIT_CLONE: 6e4,
-  /** HTTP fetch/API requests */
-  API_REQUEST: 3e4,
-  /** npm install -g (CLI installation) - 2 minutes */
-  NPM_INSTALL: 12e4,
-  /** User-defined workflow hooks */
-  WORKFLOW_HOOK: 6e4
-};
-function getTimeout(key) {
-  const envVar = `PRJCT_TIMEOUT_${key}`;
-  const envValue = process.env[envVar];
-  if (envValue) {
-    const parsed = Number.parseInt(envValue, 10);
-    if (!Number.isNaN(parsed) && parsed > 0) {
-      return parsed;
-    }
-  }
-  return TIMEOUTS[key];
-}
-__name(getTimeout, "getTimeout");
-
-// core/services/dependency-validator.ts
-var import_node_child_process = require("node:child_process");
-
-// core/utils/error-messages.ts
-function createError(message, hint, options) {
-  return {
-    message,
-    hint,
-    ...options
-  };
-}
-__name(createError, "createError");
-
-// core/services/dependency-validator.ts
-var TOOLS = {
-  git: {
-    name: "git",
-    command: "git --version",
-    versionRegex: /git version ([\d.]+)/,
-    required: true,
-    installHint: "Install Git: https://git-scm.com/downloads",
-    docs: "https://git-scm.com/doc"
-  },
-  node: {
-    name: "node",
-    command: "node --version",
-    versionRegex: /v([\d.]+)/,
-    required: true,
-    installHint: "Install Node.js: https://nodejs.org",
-    docs: "https://nodejs.org/docs"
-  },
-  bun: {
-    name: "bun",
-    command: "bun --version",
-    versionRegex: /([\d.]+)/,
-    required: false,
-    installHint: "Install Bun: curl -fsSL https://bun.sh/install | bash",
-    docs: "https://bun.sh/docs"
-  },
-  gh: {
-    name: "gh",
-    command: "gh --version",
-    versionRegex: /gh version ([\d.]+)/,
-    required: false,
-    installHint: "Install GitHub CLI: https://cli.github.com",
-    docs: "https://cli.github.com/manual"
-  },
-  npm: {
-    name: "npm",
-    command: "npm --version",
-    versionRegex: /([\d.]+)/,
-    required: false,
-    installHint: "npm comes with Node.js: https://nodejs.org"
-  },
-  claude: {
-    name: "claude",
-    command: "claude --version",
-    versionRegex: /claude ([\d.]+)/,
-    required: false,
-    installHint: "Install Claude Code: npm install -g @anthropic-ai/claude-code",
-    docs: "https://docs.anthropic.com/claude-code"
-  },
-  gemini: {
-    name: "gemini",
-    command: "gemini --version",
-    versionRegex: /gemini ([\d.]+)/,
-    required: false,
-    installHint: "Install Gemini CLI: npm install -g @google/gemini-cli",
-    docs: "https://ai.google.dev/gemini-api/docs"
-  }
-};
-var DependencyValidator = class {
-  static {
-    __name(this, "DependencyValidator");
-  }
-  cache = /* @__PURE__ */ new Map();
-  cacheTimeout = 6e4;
-  // 1 minute cache
-  cacheTimestamps = /* @__PURE__ */ new Map();
-  /**
-   * Check if a tool is available
-   * Uses caching to avoid repeated execSync calls
-   */
-  checkTool(toolName) {
-    const cached = this.getCached(toolName);
-    if (cached) return cached;
-    const definition = TOOLS[toolName];
-    if (!definition) {
-      return this.checkUnknownTool(toolName);
-    }
-    const status = this.executeCheck(definition);
-    this.setCache(toolName, status);
-    return status;
-  }
-  /**
-   * Ensure a tool is available, throw helpful error if not
-   * Use this before operations that require a specific tool
-   */
-  ensureTool(toolName) {
-    const status = this.checkTool(toolName);
-    if (!status.available) {
-      const definition = TOOLS[toolName];
-      const error = status.error || {
-        message: `${toolName} is not available`,
-        hint: definition?.installHint || `Install ${toolName} and try again`,
-        docs: definition?.docs
-      };
-      throw new DependencyError(error);
-    }
-  }
-  /**
-   * Ensure multiple tools are available
-   */
-  ensureTools(toolNames) {
-    const missing = [];
-    for (const name of toolNames) {
-      const status = this.checkTool(name);
-      if (!status.available) {
-        missing.push(name);
-      }
-    }
-    if (missing.length > 0) {
-      const hints = missing.map((name) => {
-        const def = TOOLS[name];
-        return def ? `  ${name}: ${def.installHint}` : `  ${name}: Install and try again`;
-      }).join("\n");
-      throw new DependencyError({
-        message: `Missing required tools: ${missing.join(", ")}`,
-        hint: `Install the following:
-${hints}`
-      });
-    }
-  }
-  /**
-   * Check if tool is available (boolean convenience method)
-   */
-  isAvailable(toolName) {
-    return this.checkTool(toolName).available;
-  }
-  /**
-   * Get tool version if available
-   */
-  getVersion(toolName) {
-    return this.checkTool(toolName).version;
-  }
-  /**
-   * Check multiple tools and return summary
-   */
-  checkAll(toolNames) {
-    const names = toolNames || Object.keys(TOOLS);
-    const results = /* @__PURE__ */ new Map();
-    for (const name of names) {
-      results.set(name, this.checkTool(name));
-    }
-    return results;
-  }
-  /**
-   * Clear the cache (useful for tests or after installations)
-   */
-  clearCache() {
-    this.cache.clear();
-    this.cacheTimestamps.clear();
-  }
-  // ==========================================================================
-  // PRIVATE METHODS
-  // ==========================================================================
-  executeCheck(definition) {
-    try {
-      const output = (0, import_node_child_process.execSync)(definition.command, {
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"],
-        timeout: 5e3
-        // 5 second timeout
-      });
-      let version;
-      if (definition.versionRegex) {
-        const match = output.match(definition.versionRegex);
-        version = match ? match[1] : void 0;
-      }
-      return { available: true, version };
-    } catch {
-      return {
-        available: false,
-        error: createError(
-          `${definition.name} is not installed or not in PATH`,
-          definition.installHint,
-          { docs: definition.docs }
-        )
-      };
-    }
-  }
-  checkUnknownTool(toolName) {
-    try {
-      (0, import_node_child_process.execSync)(`${toolName} --version`, {
-        encoding: "utf-8",
-        stdio: ["pipe", "pipe", "pipe"],
-        timeout: 5e3
-      });
-      return { available: true };
-    } catch {
-      try {
-        (0, import_node_child_process.execSync)(`${toolName} -v`, {
-          encoding: "utf-8",
-          stdio: ["pipe", "pipe", "pipe"],
-          timeout: 5e3
-        });
-        return { available: true };
-      } catch {
-        return {
-          available: false,
-          error: createError(
-            `${toolName} is not installed or not in PATH`,
-            `Install ${toolName} and try again`
-          )
-        };
-      }
-    }
-  }
-  getCached(toolName) {
-    const timestamp = this.cacheTimestamps.get(toolName);
-    if (!timestamp) return null;
-    if (Date.now() - timestamp > this.cacheTimeout) {
-      this.cache.delete(toolName);
-      this.cacheTimestamps.delete(toolName);
-      return null;
-    }
-    return this.cache.get(toolName) || null;
-  }
-  setCache(toolName, status) {
-    this.cache.set(toolName, status);
-    this.cacheTimestamps.set(toolName, Date.now());
-  }
-};
-var DependencyError = class extends Error {
-  static {
-    __name(this, "DependencyError");
-  }
-  hint;
-  docs;
-  constructor(error) {
-    super(error.message);
-    this.name = "DependencyError";
-    this.hint = error.hint;
-    this.docs = error.docs;
-  }
-};
-var dependencyValidator = new DependencyValidator();
-
-// 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/infrastructure/setup.ts
-init_fs_helpers();
-
-// core/utils/logger.ts
-var LEVELS = { error: 0, warn: 1, info: 2, debug: 3 };
-var TRUTHY_VALUES = /* @__PURE__ */ new Set(["1", "true", "*"]);
-function getLogLevel() {
-  const debugEnv = process.env.PRJCT_DEBUG || process.env.DEBUG || "";
-  if (!debugEnv) return { level: -1, name: "disabled" };
-  if (TRUTHY_VALUES.has(debugEnv) || debugEnv.includes("prjct")) {
-    return { level: LEVELS.debug, name: "debug" };
-  }
-  const levelValue = LEVELS[debugEnv] ?? -1;
-  const levelName = levelValue >= 0 ? debugEnv : "disabled";
-  return { level: levelValue, name: levelName };
-}
-__name(getLogLevel, "getLogLevel");
-var { level: currentLevel, name: currentLevelName } = getLogLevel();
-var noop = /* @__PURE__ */ __name(() => {
-}, "noop");
-function createLogMethod(levelThreshold, prefix, method) {
-  return currentLevel >= levelThreshold ? (...args) => console[method](prefix, ...args) : noop;
-}
-__name(createLogMethod, "createLogMethod");
-var logger = {
-  error: createLogMethod(LEVELS.error, "[prjct:error]", "error"),
-  warn: createLogMethod(LEVELS.warn, "[prjct:warn]", "warn"),
-  info: createLogMethod(LEVELS.info, "[prjct:info]", "log"),
-  debug: createLogMethod(LEVELS.debug, "[prjct:debug]", "log"),
-  // Check if logging is enabled (useful for expensive log prep)
-  isEnabled: /* @__PURE__ */ __name(() => currentLevel >= 0, "isEnabled"),
-  // Get current level name (pre-computed, no runtime lookup)
-  level: /* @__PURE__ */ __name(() => currentLevelName, "level")
-};
-var logger_default = logger;
-
-// 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/setup.ts
-init_ai_provider();
-
-// core/infrastructure/command-installer.ts
-var import_promises3 = __toESM(require("node:fs/promises"));
-var import_node_os3 = __toESM(require("node:os"));
-var import_node_path4 = __toESM(require("node:path"));
-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 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();
-  }
-};
-var commandInstaller = new CommandInstaller();
-var command_installer_default = commandInstaller;
-
-// core/infrastructure/editors-config.ts
-var import_promises4 = __toESM(require("node:fs/promises"));
-var import_node_os4 = __toESM(require("node:os"));
-var import_node_path5 = __toESM(require("node:path"));
-var EditorsConfig = class {
-  static {
-    __name(this, "EditorsConfig");
-  }
-  homeDir;
-  configDir;
-  configFile;
-  constructor() {
-    this.homeDir = import_node_os4.default.homedir();
-    this.configDir = import_node_path5.default.join(this.homeDir, ".prjct-cli", "config");
-    this.configFile = import_node_path5.default.join(this.configDir, "installed-editors.json");
-  }
-  /**
-   * Ensure config directory exists
-   */
-  async ensureConfigDir() {
-    try {
-      await import_promises4.default.mkdir(this.configDir, { recursive: true });
-    } catch (error) {
-      console.error("[editors-config] Error creating config directory:", getErrorMessage(error));
-    }
-  }
-  /**
-   * Load installation configuration
-   */
-  async loadConfig() {
-    try {
-      const content = await import_promises4.default.readFile(this.configFile, "utf-8");
-      return JSON.parse(content);
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return null;
-      }
-      console.error("[editors-config] Error loading config:", getErrorMessage(error));
-      return null;
-    }
-  }
-  /**
-   * Save installation configuration
-   */
-  async saveConfig(version, installPath, provider = "claude") {
-    try {
-      await this.ensureConfigDir();
-      const config = {
-        version,
-        editor: provider,
-        // deprecated, kept for backward compatibility
-        provider,
-        lastInstall: (/* @__PURE__ */ new Date()).toISOString(),
-        path: installPath
-      };
-      await import_promises4.default.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
-      return true;
-    } catch (error) {
-      console.error("[editors-config] Error saving config:", getErrorMessage(error));
-      return false;
-    }
-  }
-  /**
-   * Get the configured provider
-   */
-  async getProvider() {
-    const config = await this.loadConfig();
-    if (!config) return null;
-    return config.provider || config.editor || "claude";
-  }
-  /**
-   * Get last installed version
-   */
-  async getLastVersion() {
-    const config = await this.loadConfig();
-    return config ? config.version : null;
-  }
-  /**
-   * Check if version has changed since last install
-   */
-  async hasVersionChanged(currentVersion) {
-    const lastVersion = await this.getLastVersion();
-    return lastVersion !== null && lastVersion !== currentVersion;
-  }
-  /**
-   * Update version in configuration
-   */
-  async updateVersion(version) {
-    try {
-      const config = await this.loadConfig();
-      if (!config) {
-        return false;
-      }
-      config.version = version;
-      config.lastInstall = (/* @__PURE__ */ new Date()).toISOString();
-      await import_promises4.default.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
-      return true;
-    } catch (error) {
-      console.error("[editors-config] Error updating version:", getErrorMessage(error));
-      return false;
-    }
-  }
-  /**
-   * Check if config file exists
-   */
-  async configExists() {
-    try {
-      await import_promises4.default.access(this.configFile);
-      return true;
-    } catch (_error) {
-      return false;
-    }
-  }
-  /**
-   * Delete configuration file
-   * Used during uninstallation to clean up tracking data
-   */
-  async deleteConfig() {
-    try {
-      const exists = await this.configExists();
-      if (exists) {
-        await import_promises4.default.unlink(this.configFile);
-      }
-      return true;
-    } catch (error) {
-      console.error("[editors-config] Error deleting config:", getErrorMessage(error));
-      return false;
-    }
-  }
-};
-var editorsConfig = new EditorsConfig();
-var editors_config_default = editorsConfig;
-
-// core/infrastructure/setup.ts
-async function installAICLI(provider) {
-  const packageName = provider.name === "claude" ? "@anthropic-ai/claude-code" : "@google/gemini-cli";
-  if (!dependencyValidator.isAvailable("npm")) {
-    console.log(`${import_chalk.default.yellow("\u26A0\uFE0F  npm is not available")}`);
-    console.log("");
-    console.log(`${import_chalk.default.dim(`Install ${provider.displayName} using one of:`)}`);
-    console.log(import_chalk.default.dim("  \u2022 Install Node.js: https://nodejs.org"));
-    console.log(
-      import_chalk.default.dim(
-        `  \u2022 Use Homebrew: brew install ${provider.name === "claude" ? "claude" : "gemini"}`
-      )
-    );
-    console.log(import_chalk.default.dim(`  \u2022 Use npx directly: npx ${packageName}`));
-    console.log("");
-    return false;
-  }
-  try {
-    console.log(import_chalk.default.yellow(`\u{1F4E6} ${provider.displayName} not found. Installing...`));
-    console.log("");
-    (0, import_node_child_process3.execSync)(`npm install -g ${packageName}`, {
-      stdio: "inherit",
-      timeout: getTimeout("NPM_INSTALL")
-    });
-    console.log("");
-    console.log(`${import_chalk.default.green("\u2713")} ${provider.displayName} installed successfully`);
-    console.log("");
-    return true;
-  } catch (error) {
-    const err = error;
-    const isTimeout = err.killed && err.signal === "SIGTERM";
-    if (isTimeout) {
-      console.log(import_chalk.default.yellow(`\u26A0\uFE0F  Installation timed out for ${provider.displayName}`));
-      console.log("");
-      console.log(import_chalk.default.dim("The npm install took too long. Try:"));
-      console.log(import_chalk.default.dim("  \u2022 Set PRJCT_TIMEOUT_NPM_INSTALL=300000 for 5 minutes"));
-      console.log(import_chalk.default.dim(`  \u2022 Run manually: npm install -g ${packageName}`));
-    } else {
-      console.log(import_chalk.default.yellow(`\u26A0\uFE0F  Failed to install ${provider.displayName}: ${err.message}`));
-    }
-    console.log("");
-    console.log(import_chalk.default.dim("Alternative installation methods:"));
-    console.log(import_chalk.default.dim(`  \u2022 npm:  npm install -g ${packageName}`));
-    console.log(import_chalk.default.dim(`  \u2022 yarn: yarn global add ${packageName}`));
-    console.log(import_chalk.default.dim(`  \u2022 pnpm: pnpm add -g ${packageName}`));
-    console.log(
-      import_chalk.default.dim(`  \u2022 brew: brew install ${provider.name === "claude" ? "claude" : "gemini"}`)
-    );
-    console.log("");
-    return false;
-  }
-}
-__name(installAICLI, "installAICLI");
-async function run() {
-  const detection = await detectAllProviders();
-  const selection = await selectProvider();
-  const _primaryProvider = Providers[selection.provider];
-  const results = {
-    provider: selection.provider,
-    providers: [],
-    cliInstalled: false,
-    commandsAdded: 0,
-    commandsUpdated: 0,
-    configAction: null
-  };
-  const cliProviderNames = ["claude", "gemini"];
-  for (const providerName of cliProviderNames) {
-    const providerConfig = Providers[providerName];
-    const providerDetection = detection[providerName];
-    const providerResult = {
-      provider: providerName,
-      cliInstalled: false,
-      commandsAdded: 0,
-      commandsUpdated: 0,
-      configAction: null
-    };
-    if (!providerDetection.installed) {
-      if (providerName === selection.provider) {
-        const installed = await installAICLI(providerConfig);
-        if (installed) {
-          providerResult.cliInstalled = true;
-          results.cliInstalled = true;
-        } else {
-          throw new Error(`${providerConfig.displayName} installation failed`);
-        }
-      } else {
-        continue;
-      }
-    }
-    if (providerName === "claude") {
-      const claudeDetected = await command_installer_default.detectClaude();
-      if (claudeDetected) {
-        const syncResult = await command_installer_default.syncCommands();
-        if (syncResult.success) {
-          providerResult.commandsAdded = syncResult.added;
-          providerResult.commandsUpdated = syncResult.updated;
-          results.commandsAdded += syncResult.added;
-          results.commandsUpdated += syncResult.updated;
-        }
-        const configResult = await command_installer_default.installGlobalConfig();
-        if (configResult.success) {
-          providerResult.configAction = configResult.action;
-          if (!results.configAction) {
-            results.configAction = configResult.action;
-          }
-        }
-        await command_installer_default.installDocs();
-        await installStatusLine();
-        await installContext7MCP();
-      }
-    } else if (providerName === "gemini") {
-      const geminiInstalled = await installGeminiRouter();
-      if (geminiInstalled) {
-        providerResult.commandsAdded = 1;
-        results.commandsAdded += 1;
-      }
-      const geminiConfigResult = await installGeminiGlobalConfig();
-      if (geminiConfigResult.success) {
-        providerResult.configAction = geminiConfigResult.action;
-      }
-    }
-    results.providers.push(providerResult);
-  }
-  const antigravityDetection = await detectAntigravity();
-  if (antigravityDetection.installed) {
-    const antigravityResult = await installAntigravitySkill();
-    if (antigravityResult.success) {
-      console.log(`   ${import_chalk.default.green("\u2713")} Antigravity skill installed`);
-    }
-  }
-  await editors_config_default.saveConfig(VERSION, await command_installer_default.getInstallPath(), selection.provider);
-  await migrateProjectsCliVersion();
-  for (const providerResult of results.providers) {
-    showResults(providerResult, Providers[providerResult.provider]);
-  }
-  return results;
-}
-__name(run, "run");
-async function installGeminiRouter() {
-  try {
-    const geminiCommandsDir = import_node_path6.default.join(import_node_os5.default.homedir(), ".gemini", "commands");
-    const routerSource = import_node_path6.default.join(PACKAGE_ROOT, "templates", "commands", "p.toml");
-    const routerDest = import_node_path6.default.join(geminiCommandsDir, "p.toml");
-    await import_promises5.default.mkdir(geminiCommandsDir, { recursive: true });
-    if (await fileExists(routerSource)) {
-      await import_promises5.default.copyFile(routerSource, routerDest);
-      return true;
-    }
-    return false;
-  } catch (error) {
-    logger_default.warn(`Gemini router warning: ${getErrorMessage(error)}`);
-    return false;
-  }
-}
-__name(installGeminiRouter, "installGeminiRouter");
-async function installGeminiGlobalConfig() {
-  try {
-    const geminiDir = import_node_path6.default.join(import_node_os5.default.homedir(), ".gemini");
-    const globalConfigPath = import_node_path6.default.join(geminiDir, "GEMINI.md");
-    const templatePath = import_node_path6.default.join(PACKAGE_ROOT, "templates", "global", "GEMINI.md");
-    await import_promises5.default.mkdir(geminiDir, { recursive: true });
-    const templateContent = await import_promises5.default.readFile(templatePath, "utf-8");
-    let existingContent = "";
-    let configExists = false;
-    try {
-      existingContent = await import_promises5.default.readFile(globalConfigPath, "utf-8");
-      configExists = true;
-    } catch (error) {
-      if (isNotFoundError(error)) {
-        configExists = false;
-      } else {
-        throw error;
-      }
-    }
-    if (!configExists) {
-      await import_promises5.default.writeFile(globalConfigPath, templateContent, "utf-8");
-      return { success: true, action: "created" };
-    }
-    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 updatedContent2 = `${existingContent}
-
-${templateContent}`;
-      await import_promises5.default.writeFile(globalConfigPath, updatedContent2, "utf-8");
-      return { success: true, action: "appended" };
-    }
-    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_promises5.default.writeFile(globalConfigPath, updatedContent, "utf-8");
-    return { success: true, action: "updated" };
-  } catch (error) {
-    logger_default.warn(`Gemini config warning: ${getErrorMessage(error)}`);
-    return { success: false, action: null };
-  }
-}
-__name(installGeminiGlobalConfig, "installGeminiGlobalConfig");
-async function installAntigravitySkill() {
-  try {
-    const antigravitySkillsDir = import_node_path6.default.join(import_node_os5.default.homedir(), ".gemini", "antigravity", "skills");
-    const prjctSkillDir = import_node_path6.default.join(antigravitySkillsDir, "prjct");
-    const skillMdPath = import_node_path6.default.join(prjctSkillDir, "SKILL.md");
-    const templatePath = import_node_path6.default.join(PACKAGE_ROOT, "templates", "antigravity", "SKILL.md");
-    await import_promises5.default.mkdir(prjctSkillDir, { recursive: true });
-    const skillExists = await fileExists(skillMdPath);
-    if (!await fileExists(templatePath)) {
-      logger_default.warn("Antigravity SKILL.md template not found");
-      return { success: false, action: null };
-    }
-    const templateContent = await import_promises5.default.readFile(templatePath, "utf-8");
-    await import_promises5.default.writeFile(skillMdPath, templateContent, "utf-8");
-    return { success: true, action: skillExists ? "updated" : "created" };
-  } catch (error) {
-    logger_default.warn(`Antigravity skill warning: ${getErrorMessage(error)}`);
-    return { success: false, action: null };
-  }
-}
-__name(installAntigravitySkill, "installAntigravitySkill");
-async function needsAntigravityInstallation() {
-  const detection = await detectAntigravity();
-  return detection.installed && !detection.skillInstalled;
-}
-__name(needsAntigravityInstallation, "needsAntigravityInstallation");
-async function installCursorProject(projectRoot) {
-  const result = {
-    success: false,
-    rulesCreated: false,
-    commandsCreated: false,
-    gitignoreUpdated: false
-  };
-  try {
-    const cursorDir = import_node_path6.default.join(projectRoot, ".cursor");
-    const rulesDir = import_node_path6.default.join(cursorDir, "rules");
-    const commandsDir = import_node_path6.default.join(cursorDir, "commands");
-    const routerMdcDest = import_node_path6.default.join(rulesDir, "prjct.mdc");
-    const routerMdcSource = import_node_path6.default.join(PACKAGE_ROOT, "templates", "cursor", "router.mdc");
-    const cursorCommandsSource = import_node_path6.default.join(PACKAGE_ROOT, "templates", "cursor", "commands");
-    await import_promises5.default.mkdir(rulesDir, { recursive: true });
-    await import_promises5.default.mkdir(commandsDir, { recursive: true });
-    if (await fileExists(routerMdcSource)) {
-      await import_promises5.default.copyFile(routerMdcSource, routerMdcDest);
-      result.rulesCreated = true;
-    }
-    if (await fileExists(cursorCommandsSource)) {
-      const commandFiles = (await import_promises5.default.readdir(cursorCommandsSource)).filter((f) => f.endsWith(".md"));
-      for (const file of commandFiles) {
-        const src = import_node_path6.default.join(cursorCommandsSource, file);
-        const dest = import_node_path6.default.join(commandsDir, file);
-        await import_promises5.default.copyFile(src, dest);
-      }
-      result.commandsCreated = commandFiles.length > 0;
-    }
-    result.gitignoreUpdated = await addCursorToGitignore(projectRoot);
-    result.success = result.rulesCreated || result.commandsCreated;
-    return result;
-  } catch (error) {
-    logger_default.warn(`Cursor installation warning: ${getErrorMessage(error)}`);
-    return result;
-  }
-}
-__name(installCursorProject, "installCursorProject");
-async function addCursorToGitignore(projectRoot) {
-  try {
-    const gitignorePath = import_node_path6.default.join(projectRoot, ".gitignore");
-    const entriesToAdd = [
-      "# prjct Cursor routers (regenerated per-developer)",
-      ".cursor/rules/prjct.mdc",
-      ".cursor/commands/sync.md",
-      ".cursor/commands/task.md",
-      ".cursor/commands/done.md",
-      ".cursor/commands/ship.md",
-      ".cursor/commands/bug.md",
-      ".cursor/commands/pause.md",
-      ".cursor/commands/resume.md"
-    ];
-    let content = "";
-    let configExists = false;
-    try {
-      content = await import_promises5.default.readFile(gitignorePath, "utf-8");
-      configExists = true;
-    } catch (error) {
-      if (!isNotFoundError(error)) {
-        throw error;
-      }
-    }
-    if (content.includes(".cursor/rules/prjct.mdc")) {
-      return false;
-    }
-    const newContent = configExists ? `${content.trimEnd()}
-
-${entriesToAdd.join("\n")}
-` : `${entriesToAdd.join("\n")}
-`;
-    await import_promises5.default.writeFile(gitignorePath, newContent, "utf-8");
-    return true;
-  } catch (error) {
-    logger_default.warn(`Gitignore update warning: ${getErrorMessage(error)}`);
-    return false;
-  }
-}
-__name(addCursorToGitignore, "addCursorToGitignore");
-async function hasCursorProject(projectRoot) {
-  return await fileExists(import_node_path6.default.join(projectRoot, ".cursor"));
-}
-__name(hasCursorProject, "hasCursorProject");
-async function needsCursorRegeneration(projectRoot) {
-  const cursorDir = import_node_path6.default.join(projectRoot, ".cursor");
-  const routerPath = import_node_path6.default.join(cursorDir, "rules", "prjct.mdc");
-  return await fileExists(cursorDir) && !await fileExists(routerPath);
-}
-__name(needsCursorRegeneration, "needsCursorRegeneration");
-async function installWindsurfProject(projectRoot) {
-  const result = {
-    success: false,
-    rulesCreated: false,
-    workflowsCreated: false,
-    gitignoreUpdated: false
-  };
-  try {
-    const windsurfDir = import_node_path6.default.join(projectRoot, ".windsurf");
-    const rulesDir = import_node_path6.default.join(windsurfDir, "rules");
-    const workflowsDir = import_node_path6.default.join(windsurfDir, "workflows");
-    const routerDest = import_node_path6.default.join(rulesDir, "prjct.md");
-    const routerSource = import_node_path6.default.join(PACKAGE_ROOT, "templates", "windsurf", "router.md");
-    const windsurfWorkflowsSource = import_node_path6.default.join(PACKAGE_ROOT, "templates", "windsurf", "workflows");
-    await import_promises5.default.mkdir(rulesDir, { recursive: true });
-    await import_promises5.default.mkdir(workflowsDir, { recursive: true });
-    if (await fileExists(routerSource)) {
-      await import_promises5.default.copyFile(routerSource, routerDest);
-      result.rulesCreated = true;
-    }
-    if (await fileExists(windsurfWorkflowsSource)) {
-      const workflowFiles = (await import_promises5.default.readdir(windsurfWorkflowsSource)).filter(
-        (f) => f.endsWith(".md")
-      );
-      for (const file of workflowFiles) {
-        const src = import_node_path6.default.join(windsurfWorkflowsSource, file);
-        const dest = import_node_path6.default.join(workflowsDir, file);
-        await import_promises5.default.copyFile(src, dest);
-      }
-      result.workflowsCreated = workflowFiles.length > 0;
-    }
-    result.gitignoreUpdated = await addWindsurfToGitignore(projectRoot);
-    result.success = result.rulesCreated || result.workflowsCreated;
-    return result;
-  } catch (error) {
-    logger_default.warn(`Windsurf installation warning: ${getErrorMessage(error)}`);
-    return result;
-  }
-}
-__name(installWindsurfProject, "installWindsurfProject");
-async function addWindsurfToGitignore(projectRoot) {
-  try {
-    const gitignorePath = import_node_path6.default.join(projectRoot, ".gitignore");
-    const entriesToAdd = [
-      "# prjct Windsurf routers (regenerated per-developer)",
-      ".windsurf/rules/prjct.md",
-      ".windsurf/workflows/sync.md",
-      ".windsurf/workflows/task.md",
-      ".windsurf/workflows/done.md",
-      ".windsurf/workflows/ship.md",
-      ".windsurf/workflows/bug.md",
-      ".windsurf/workflows/pause.md",
-      ".windsurf/workflows/resume.md"
-    ];
-    let content = "";
-    let configExists = false;
-    try {
-      content = await import_promises5.default.readFile(gitignorePath, "utf-8");
-      configExists = true;
-    } catch (error) {
-      if (!isNotFoundError(error)) {
-        throw error;
-      }
-    }
-    if (content.includes(".windsurf/rules/prjct.md")) {
-      return false;
-    }
-    const newContent = configExists ? `${content.trimEnd()}
-
-${entriesToAdd.join("\n")}
-` : `${entriesToAdd.join("\n")}
-`;
-    await import_promises5.default.writeFile(gitignorePath, newContent, "utf-8");
-    return true;
-  } catch (error) {
-    logger_default.warn(`Gitignore update warning: ${getErrorMessage(error)}`);
-    return false;
-  }
-}
-__name(addWindsurfToGitignore, "addWindsurfToGitignore");
-async function hasWindsurfProject(projectRoot) {
-  return await fileExists(import_node_path6.default.join(projectRoot, ".windsurf"));
-}
-__name(hasWindsurfProject, "hasWindsurfProject");
-async function needsWindsurfRegeneration(projectRoot) {
-  const windsurfDir = import_node_path6.default.join(projectRoot, ".windsurf");
-  const routerPath = import_node_path6.default.join(windsurfDir, "rules", "prjct.md");
-  return await fileExists(windsurfDir) && !await fileExists(routerPath);
-}
-__name(needsWindsurfRegeneration, "needsWindsurfRegeneration");
-async function migrateProjectsCliVersion() {
-  try {
-    const projectsDir = import_node_path6.default.join(import_node_os5.default.homedir(), ".prjct-cli", "projects");
-    if (!await fileExists(projectsDir)) {
-      return;
-    }
-    const projectDirs = (await import_promises5.default.readdir(projectsDir, { withFileTypes: true })).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
-    let migrated = 0;
-    for (const projectId of projectDirs) {
-      const projectJsonPath = import_node_path6.default.join(projectsDir, projectId, "project.json");
-      if (!await fileExists(projectJsonPath)) {
-        continue;
-      }
-      try {
-        const content = await import_promises5.default.readFile(projectJsonPath, "utf8");
-        const project = JSON.parse(content);
-        if (project.cliVersion !== VERSION) {
-          project.cliVersion = VERSION;
-          await import_promises5.default.writeFile(projectJsonPath, JSON.stringify(project, null, 2));
-          migrated++;
-        }
-      } catch (error) {
-        if (!isNotFoundError(error) && !(error instanceof SyntaxError)) {
-          throw error;
-        }
-      }
-    }
-    if (migrated > 0) {
-      console.log(`   ${import_chalk.default.green("\u2713")} Updated ${migrated} project(s) to v${VERSION}`);
-    }
-  } catch (error) {
-    if (!isNotFoundError(error)) {
-      logger_default.warn(`Migration warning: ${getErrorMessage(error)}`);
-    }
-  }
-}
-__name(migrateProjectsCliVersion, "migrateProjectsCliVersion");
-async function ensureStatusLineSettings(settingsPath, statusLinePath) {
-  let settings = {};
-  if (await fileExists(settingsPath)) {
-    try {
-      settings = JSON.parse(await import_promises5.default.readFile(settingsPath, "utf8"));
-    } catch (error) {
-      if (!(error instanceof SyntaxError)) {
-        throw error;
-      }
-    }
-  }
-  settings.statusLine = { type: "command", command: statusLinePath };
-  await import_promises5.default.writeFile(settingsPath, JSON.stringify(settings, null, 2));
-}
-__name(ensureStatusLineSettings, "ensureStatusLineSettings");
-async function installStatusLine() {
-  try {
-    const claudeDir = import_node_path6.default.join(import_node_os5.default.homedir(), ".claude");
-    const settingsPath = import_node_path6.default.join(claudeDir, "settings.json");
-    const claudeStatusLinePath = import_node_path6.default.join(claudeDir, "prjct-statusline.sh");
-    const prjctStatusLineDir = import_node_path6.default.join(import_node_os5.default.homedir(), ".prjct-cli", "statusline");
-    const prjctStatusLinePath = import_node_path6.default.join(prjctStatusLineDir, "statusline.sh");
-    const prjctThemesDir = import_node_path6.default.join(prjctStatusLineDir, "themes");
-    const prjctLibDir = import_node_path6.default.join(prjctStatusLineDir, "lib");
-    const prjctComponentsDir = import_node_path6.default.join(prjctStatusLineDir, "components");
-    const prjctConfigPath = import_node_path6.default.join(prjctStatusLineDir, "config.json");
-    const assetsDir = import_node_path6.default.join(PACKAGE_ROOT, "assets", "statusline");
-    const sourceScript = import_node_path6.default.join(assetsDir, "statusline.sh");
-    const sourceThemeDir = import_node_path6.default.join(assetsDir, "themes");
-    const sourceLibDir = import_node_path6.default.join(assetsDir, "lib");
-    const sourceComponentsDir = import_node_path6.default.join(assetsDir, "components");
-    const sourceConfigPath = import_node_path6.default.join(assetsDir, "default-config.json");
-    if (!await fileExists(claudeDir)) {
-      await import_promises5.default.mkdir(claudeDir, { recursive: true });
-    }
-    if (!await fileExists(prjctStatusLineDir)) {
-      await import_promises5.default.mkdir(prjctStatusLineDir, { recursive: true });
-    }
-    if (!await fileExists(prjctThemesDir)) {
-      await import_promises5.default.mkdir(prjctThemesDir, { recursive: true });
-    }
-    if (!await fileExists(prjctLibDir)) {
-      await import_promises5.default.mkdir(prjctLibDir, { recursive: true });
-    }
-    if (!await fileExists(prjctComponentsDir)) {
-      await import_promises5.default.mkdir(prjctComponentsDir, { recursive: true });
-    }
-    if (await fileExists(prjctStatusLinePath)) {
-      const existingContent = await import_promises5.default.readFile(prjctStatusLinePath, "utf8");
-      if (existingContent.includes("CLI_VERSION=")) {
-        const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
-        if (versionMatch && versionMatch[1] !== VERSION) {
-          const updatedContent = existingContent.replace(
-            /CLI_VERSION="[^"]*"/,
-            `CLI_VERSION="${VERSION}"`
-          );
-          await import_promises5.default.writeFile(prjctStatusLinePath, updatedContent, { mode: 493 });
-        }
-        await installStatusLineModules(sourceLibDir, prjctLibDir);
-        await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
-        await ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
-        await ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
-        return;
-      }
-    }
-    if (await fileExists(sourceScript)) {
-      let scriptContent = await import_promises5.default.readFile(sourceScript, "utf8");
-      scriptContent = scriptContent.replace(/CLI_VERSION="[^"]*"/, `CLI_VERSION="${VERSION}"`);
-      await import_promises5.default.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
-      await installStatusLineModules(sourceLibDir, prjctLibDir);
-      await installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
-      if (await fileExists(sourceThemeDir)) {
-        const themes = await import_promises5.default.readdir(sourceThemeDir);
-        for (const theme of themes) {
-          const src = import_node_path6.default.join(sourceThemeDir, theme);
-          const dest = import_node_path6.default.join(prjctThemesDir, theme);
-          await import_promises5.default.copyFile(src, dest);
-        }
-      }
-      if (!await fileExists(prjctConfigPath) && await fileExists(sourceConfigPath)) {
-        await import_promises5.default.copyFile(sourceConfigPath, prjctConfigPath);
-      }
-    } else {
-      const scriptContent = `#!/bin/bash
-# prjct Status Line for Claude Code
-CLI_VERSION="${VERSION}"
-input=$(cat)
-CWD=$(echo "$input" | jq -r '.workspace.current_dir // "~"' 2>/dev/null)
-CONFIG="$CWD/.prjct/prjct.config.json"
-if [ -f "$CONFIG" ]; then
-  PROJECT_ID=$(jq -r '.projectId // ""' "$CONFIG" 2>/dev/null)
-  if [ -n "$PROJECT_ID" ]; then
-    PROJECT_JSON="$HOME/.prjct-cli/projects/$PROJECT_ID/project.json"
-    if [ -f "$PROJECT_JSON" ]; then
-      PROJECT_VERSION=$(jq -r '.cliVersion // ""' "$PROJECT_JSON" 2>/dev/null)
-      if [ -z "$PROJECT_VERSION" ] || [ "$PROJECT_VERSION" != "$CLI_VERSION" ]; then
-        echo "prjct v$CLI_VERSION - run p. sync"
-        exit 0
-      fi
-    else
-      echo "prjct v$CLI_VERSION - run p. sync"
-      exit 0
-    fi
-    STATE="$HOME/.prjct-cli/projects/$PROJECT_ID/storage/state.json"
-    if [ -f "$STATE" ]; then
-      TASK=$(jq -r '.currentTask.description // ""' "$STATE" 2>/dev/null)
-      if [ -n "$TASK" ]; then
-        echo "$TASK"
-        exit 0
-      fi
-    fi
-  fi
-fi
-echo "prjct"
-`;
-      await import_promises5.default.writeFile(prjctStatusLinePath, scriptContent, { mode: 493 });
-    }
-    await ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
-    await ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
-  } catch (error) {
-    if (!isNotFoundError(error)) {
-      logger_default.warn(`Status line warning: ${getErrorMessage(error)}`);
-    }
-  }
-}
-__name(installStatusLine, "installStatusLine");
-async function installContext7MCP() {
-  try {
-    const claudeDir = import_node_path6.default.join(import_node_os5.default.homedir(), ".claude");
-    const mcpConfigPath = import_node_path6.default.join(claudeDir, "mcp.json");
-    if (!await fileExists(claudeDir)) {
-      await import_promises5.default.mkdir(claudeDir, { recursive: true });
-    }
-    const context7Config = {
-      mcpServers: {
-        context7: {
-          command: "npx",
-          args: ["-y", "@upstash/context7-mcp@latest"]
-        }
-      }
-    };
-    if (await fileExists(mcpConfigPath)) {
-      const existingContent = await import_promises5.default.readFile(mcpConfigPath, "utf-8");
-      const existingConfig = JSON.parse(existingContent);
-      if (existingConfig.mcpServers?.context7) {
-        return;
-      }
-      existingConfig.mcpServers = existingConfig.mcpServers || {};
-      existingConfig.mcpServers.context7 = context7Config.mcpServers.context7;
-      await import_promises5.default.writeFile(mcpConfigPath, JSON.stringify(existingConfig, null, 2), "utf-8");
-    } else {
-      await import_promises5.default.writeFile(mcpConfigPath, JSON.stringify(context7Config, null, 2), "utf-8");
-    }
-  } catch (error) {
-    logger_default.warn(`Context7 MCP setup warning: ${getErrorMessage(error)}`);
-  }
-}
-__name(installContext7MCP, "installContext7MCP");
-async function installStatusLineModules(sourceDir, destDir) {
-  if (!await fileExists(sourceDir)) {
-    return;
-  }
-  const files = await import_promises5.default.readdir(sourceDir);
-  for (const file of files) {
-    if (file.endsWith(".sh")) {
-      const src = import_node_path6.default.join(sourceDir, file);
-      const dest = import_node_path6.default.join(destDir, file);
-      await import_promises5.default.copyFile(src, dest);
-      await import_promises5.default.chmod(dest, 493);
-    }
-  }
-}
-__name(installStatusLineModules, "installStatusLineModules");
-async function ensureStatusLineSymlink(linkPath, targetPath) {
-  try {
-    if (await fileExists(linkPath)) {
-      const stats = await import_promises5.default.lstat(linkPath);
-      if (stats.isSymbolicLink()) {
-        const existingTarget = await import_promises5.default.readlink(linkPath);
-        if (existingTarget === targetPath) {
-          return;
-        }
-      }
-      await import_promises5.default.unlink(linkPath);
-    }
-    await import_promises5.default.symlink(targetPath, linkPath);
-  } catch (_error) {
-    try {
-      if (await fileExists(targetPath)) {
-        await import_promises5.default.copyFile(targetPath, linkPath);
-        await import_promises5.default.chmod(linkPath, 493);
-      }
-    } catch (copyError) {
-      if (!isNotFoundError(copyError)) {
-        logger_default.warn(`Symlink fallback warning: ${copyError.message}`);
-      }
-    }
-  }
-}
-__name(ensureStatusLineSymlink, "ensureStatusLineSymlink");
-function showResults(results, provider) {
-  console.log("");
-  if (results.cliInstalled) {
-    console.log(`   ${import_chalk.default.green("\u2713")} ${provider.displayName} CLI installed`);
-  } else {
-    console.log(`   ${import_chalk.default.green("\u2713")} ${provider.displayName} CLI found`);
-  }
-  const totalCommands = results.commandsAdded + results.commandsUpdated;
-  if (totalCommands > 0) {
-    const parts = [];
-    if (results.commandsAdded > 0) parts.push(`${results.commandsAdded} new`);
-    if (results.commandsUpdated > 0) parts.push(`${results.commandsUpdated} updated`);
-    console.log(`   ${import_chalk.default.green("\u2713")} Commands synced (${parts.join(", ")})`);
-  } else {
-    console.log(`   ${import_chalk.default.green("\u2713")} Commands up to date`);
-  }
-  if (results.configAction === "created") {
-    console.log(`   ${import_chalk.default.green("\u2713")} Global config created (${provider.contextFile})`);
-  } else if (results.configAction === "updated") {
-    console.log(`   ${import_chalk.default.green("\u2713")} Global config updated (${provider.contextFile})`);
-  } else if (results.configAction === "appended") {
-    console.log(`   ${import_chalk.default.green("\u2713")} Global config merged (${provider.contextFile})`);
-  }
-  console.log("");
-}
-__name(showResults, "showResults");
-var isDirectRun = process.argv[1]?.includes("setup.ts") || process.argv[1]?.includes("setup.js");
-if (isDirectRun) {
-  run().catch((error) => {
-    console.error("Setup error:", error.message);
-    process.exit(1);
-  });
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  hasCursorProject,
-  hasWindsurfProject,
-  installAntigravitySkill,
-  installCursorProject,
-  installWindsurfProject,
-  needsAntigravityInstallation,
-  needsCursorRegeneration,
-  needsWindsurfRegeneration,
-  run
-});