prjct-cli 0.29.2 → 0.29.3

package/dist/core/infrastructure/setup.js

@@ -0,0 +1,837 @@
+"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 __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/infrastructure/setup.ts
+var setup_exports = {};
+__export(setup_exports, {
+  default: () => setup_default,
+  run: () => run
+});
+module.exports = __toCommonJS(setup_exports);
+var import_child_process = require("child_process");
+var import_fs = __toESM(require("fs"));
+var import_path3 = __toESM(require("path"));
+var import_os3 = __toESM(require("os"));
+
+// core/infrastructure/command-installer.ts
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+async function installDocs() {
+  try {
+    const docsDir = import_path.default.join(import_os.default.homedir(), ".prjct-cli", "docs");
+    const templateDocsDir = import_path.default.join(__dirname, "../../templates/global/docs");
+    await import_promises.default.mkdir(docsDir, { recursive: true });
+    const docFiles = await import_promises.default.readdir(templateDocsDir);
+    for (const file of docFiles) {
+      if (file.endsWith(".md")) {
+        const srcPath = import_path.default.join(templateDocsDir, file);
+        const destPath = import_path.default.join(docsDir, file);
+        const content = await import_promises.default.readFile(srcPath, "utf-8");
+        await import_promises.default.writeFile(destPath, content, "utf-8");
+      }
+    }
+    return { success: true };
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+__name(installDocs, "installDocs");
+async function installGlobalConfig(claudeConfigPath, detectClaude) {
+  const claudeDetected = await detectClaude();
+  if (!claudeDetected) {
+    return {
+      success: false,
+      error: "Claude not detected",
+      action: "skipped"
+    };
+  }
+  try {
+    const claudeDir = import_path.default.join(import_os.default.homedir(), ".claude");
+    await import_promises.default.mkdir(claudeDir, { recursive: true });
+    const globalConfigPath = import_path.default.join(claudeDir, "CLAUDE.md");
+    const templatePath = import_path.default.join(__dirname, "../../templates/global/CLAUDE.md");
+    const templateContent = await import_promises.default.readFile(templatePath, "utf-8");
+    let existingContent = "";
+    let fileExists = false;
+    try {
+      existingContent = await import_promises.default.readFile(globalConfigPath, "utf-8");
+      fileExists = true;
+    } catch {
+      fileExists = false;
+    }
+    if (!fileExists) {
+      await import_promises.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 + "\n\n" + templateContent;
+        await import_promises.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_promises.default.writeFile(globalConfigPath, updatedContent, "utf-8");
+        return {
+          success: true,
+          action: "updated",
+          path: globalConfigPath
+        };
+      }
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: error.message,
+      action: "failed"
+    };
+  }
+}
+__name(installGlobalConfig, "installGlobalConfig");
+var CommandInstaller = class {
+  static {
+    __name(this, "CommandInstaller");
+  }
+  homeDir;
+  claudeCommandsPath;
+  claudeConfigPath;
+  templatesDir;
+  constructor() {
+    this.homeDir = import_os.default.homedir();
+    this.claudeCommandsPath = import_path.default.join(this.homeDir, ".claude", "commands", "p");
+    this.claudeConfigPath = import_path.default.join(this.homeDir, ".claude");
+    this.templatesDir = import_path.default.join(__dirname, "..", "..", "templates", "commands");
+  }
+  /**
+   * Detect if Claude is installed
+   */
+  async detectClaude() {
+    try {
+      await import_promises.default.access(this.claudeConfigPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get list of command files to install
+   */
+  async getCommandFiles() {
+    try {
+      const files = await import_promises.default.readdir(this.templatesDir);
+      return files.filter((f) => f.endsWith(".md"));
+    } catch {
+      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 Claude
+   */
+  async installCommands() {
+    const claudeDetected = await this.detectClaude();
+    if (!claudeDetected) {
+      return {
+        success: false,
+        error: "Claude not detected. Please install Claude Code or Claude Desktop first."
+      };
+    }
+    try {
+      await this.installRouter();
+      await import_promises.default.mkdir(this.claudeCommandsPath, { recursive: true });
+      const commandFiles = await this.getCommandFiles();
+      const installed = [];
+      const errors = [];
+      for (const file of commandFiles) {
+        try {
+          const sourcePath = import_path.default.join(this.templatesDir, file);
+          const destPath = import_path.default.join(this.claudeCommandsPath, file);
+          const content = await import_promises.default.readFile(sourcePath, "utf-8");
+          await import_promises.default.writeFile(destPath, content, "utf-8");
+          installed.push(file.replace(".md", ""));
+        } catch (error) {
+          errors.push({ file, error: error.message });
+        }
+      }
+      return {
+        success: true,
+        installed,
+        errors,
+        path: this.claudeCommandsPath
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+  /**
+   * 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_path.default.join(this.claudeCommandsPath, file);
+          await import_promises.default.unlink(filePath);
+          uninstalled.push(file.replace(".md", ""));
+        } catch (error) {
+          if (error.code !== "ENOENT") {
+            errors.push({ file, error: error.message });
+          }
+        }
+      }
+      try {
+        await import_promises.default.rmdir(this.claudeCommandsPath);
+      } catch {
+      }
+      return {
+        success: true,
+        uninstalled,
+        errors
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+  }
+  /**
+   * Check if commands are already installed
+   */
+  async checkInstallation() {
+    const claudeDetected = await this.detectClaude();
+    if (!claudeDetected) {
+      return {
+        installed: false,
+        claudeDetected: false
+      };
+    }
+    try {
+      await import_promises.default.access(this.claudeCommandsPath);
+      const files = await import_promises.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 {
+      return {
+        installed: false,
+        claudeDetected: true,
+        commands: []
+      };
+    }
+  }
+  /**
+   * 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
+   */
+  getInstallPath() {
+    return this.claudeCommandsPath;
+  }
+  /**
+   * Verify command template exists
+   */
+  async verifyTemplate(commandName) {
+    try {
+      const templatePath = import_path.default.join(this.templatesDir, `${commandName}.md`);
+      await import_promises.default.access(templatePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Install the p.md router to ~/.claude/commands/
+   * This enables the "p. task" natural language trigger
+   * Claude Code bug #2422 prevents subdirectory slash command discovery
+   */
+  async installRouter() {
+    try {
+      const routerSource = import_path.default.join(this.templatesDir, "p.md");
+      const routerDest = import_path.default.join(this.homeDir, ".claude", "commands", "p.md");
+      const content = await import_promises.default.readFile(routerSource, "utf-8");
+      await import_promises.default.writeFile(routerDest, content, "utf-8");
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Sync commands - intelligent update that detects and removes orphans
+   */
+  async syncCommands() {
+    const claudeDetected = await this.detectClaude();
+    if (!claudeDetected) {
+      return {
+        success: false,
+        error: "Claude not detected",
+        added: 0,
+        updated: 0,
+        removed: 0
+      };
+    }
+    try {
+      await this.installRouter();
+      await import_promises.default.mkdir(this.claudeCommandsPath, { recursive: true });
+      const templateFiles = await this.getCommandFiles();
+      let installedFiles = [];
+      try {
+        installedFiles = await import_promises.default.readdir(this.claudeCommandsPath);
+        installedFiles = installedFiles.filter((f) => f.endsWith(".md"));
+      } catch {
+        installedFiles = [];
+      }
+      const results = {
+        success: true,
+        added: 0,
+        updated: 0,
+        removed: 0,
+        errors: []
+      };
+      for (const file of templateFiles) {
+        try {
+          const sourcePath = import_path.default.join(this.templatesDir, file);
+          const destPath = import_path.default.join(this.claudeCommandsPath, file);
+          const exists = installedFiles.includes(file);
+          const content = await import_promises.default.readFile(sourcePath, "utf-8");
+          await import_promises.default.writeFile(destPath, content, "utf-8");
+          if (!exists) {
+            results.added++;
+          } else {
+            results.updated++;
+          }
+        } catch (error) {
+          results.errors.push({ file, error: error.message });
+        }
+      }
+      return results;
+    } catch (error) {
+      return {
+        success: false,
+        error: error.message,
+        added: 0,
+        updated: 0,
+        removed: 0
+      };
+    }
+  }
+  /**
+   * Install or update global CLAUDE.md configuration
+   */
+  async installGlobalConfig() {
+    return installGlobalConfig(this.claudeConfigPath, () => this.detectClaude());
+  }
+  /**
+   * 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_promises2 = __toESM(require("fs/promises"));
+var import_path2 = __toESM(require("path"));
+var import_os2 = __toESM(require("os"));
+var EditorsConfig = class {
+  static {
+    __name(this, "EditorsConfig");
+  }
+  homeDir;
+  configDir;
+  configFile;
+  constructor() {
+    this.homeDir = import_os2.default.homedir();
+    this.configDir = import_path2.default.join(this.homeDir, ".prjct-cli", "config");
+    this.configFile = import_path2.default.join(this.configDir, "installed-editors.json");
+  }
+  /**
+   * Ensure config directory exists
+   */
+  async ensureConfigDir() {
+    try {
+      await import_promises2.default.mkdir(this.configDir, { recursive: true });
+    } catch (error) {
+      console.error("[editors-config] Error creating config directory:", error.message);
+    }
+  }
+  /**
+   * Load installation configuration
+   */
+  async loadConfig() {
+    try {
+      const content = await import_promises2.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:", error.message);
+      return null;
+    }
+  }
+  /**
+   * Save installation configuration
+   */
+  async saveConfig(version, claudePath) {
+    try {
+      await this.ensureConfigDir();
+      const config = {
+        version,
+        editor: "claude",
+        lastInstall: (/* @__PURE__ */ new Date()).toISOString(),
+        path: claudePath
+      };
+      await import_promises2.default.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
+      return true;
+    } catch (error) {
+      console.error("[editors-config] Error saving config:", error.message);
+      return false;
+    }
+  }
+  /**
+   * 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_promises2.default.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
+      return true;
+    } catch (error) {
+      console.error("[editors-config] Error updating version:", error.message);
+      return false;
+    }
+  }
+  /**
+   * Check if config file exists
+   */
+  async configExists() {
+    try {
+      await import_promises2.default.access(this.configFile);
+      return true;
+    } catch {
+      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_promises2.default.unlink(this.configFile);
+      }
+      return true;
+    } catch (error) {
+      console.error("[editors-config] Error deleting config:", error.message);
+      return false;
+    }
+  }
+};
+var editorsConfig = new EditorsConfig();
+var editors_config_default = editorsConfig;
+
+// core/infrastructure/setup.ts
+var import_version = require("../utils/version");
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var DIM = "\x1B[2m";
+var NC = "\x1B[0m";
+async function hasClaudeCodeCLI() {
+  try {
+    (0, import_child_process.execSync)("which claude", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(hasClaudeCodeCLI, "hasClaudeCodeCLI");
+async function installClaudeCode() {
+  try {
+    console.log(`${YELLOW}\u{1F4E6} Claude Code not found. Installing...${NC}`);
+    console.log("");
+    (0, import_child_process.execSync)("npm install -g @anthropic-ai/claude-code", { stdio: "inherit" });
+    console.log("");
+    console.log(`${GREEN}\u2713${NC} Claude Code installed successfully`);
+    console.log("");
+    return true;
+  } catch (error) {
+    console.log(`${YELLOW}\u26A0\uFE0F  Failed to install Claude Code: ${error.message}${NC}`);
+    console.log(`${DIM}Please install manually: npm install -g @anthropic-ai/claude-code${NC}`);
+    console.log("");
+    return false;
+  }
+}
+__name(installClaudeCode, "installClaudeCode");
+async function run() {
+  const results = {
+    claudeInstalled: false,
+    commandsAdded: 0,
+    commandsUpdated: 0,
+    configAction: null
+  };
+  const hasClaude = await hasClaudeCodeCLI();
+  if (!hasClaude) {
+    const installed = await installClaudeCode();
+    if (installed) {
+      results.claudeInstalled = true;
+    } else {
+      throw new Error("Claude Code installation failed");
+    }
+  }
+  const claudeDetected = await command_installer_default.detectClaude();
+  if (claudeDetected) {
+    const syncResult = await command_installer_default.syncCommands();
+    if (syncResult.success) {
+      results.commandsAdded = syncResult.added;
+      results.commandsUpdated = syncResult.updated;
+    }
+    const configResult = await command_installer_default.installGlobalConfig();
+    if (configResult.success) {
+      results.configAction = configResult.action;
+    }
+    await command_installer_default.installDocs();
+    await installStatusLine();
+  }
+  await editors_config_default.saveConfig(import_version.VERSION, command_installer_default.getInstallPath());
+  await migrateProjectsCliVersion();
+  showResults(results);
+  return results;
+}
+__name(run, "run");
+var setup_default = { run };
+async function migrateProjectsCliVersion() {
+  try {
+    const projectsDir = import_path3.default.join(import_os3.default.homedir(), ".prjct-cli", "projects");
+    if (!import_fs.default.existsSync(projectsDir)) {
+      return;
+    }
+    const projectDirs = import_fs.default.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
+    let migrated = 0;
+    for (const projectId of projectDirs) {
+      const projectJsonPath = import_path3.default.join(projectsDir, projectId, "project.json");
+      if (!import_fs.default.existsSync(projectJsonPath)) {
+        continue;
+      }
+      try {
+        const content = import_fs.default.readFileSync(projectJsonPath, "utf8");
+        const project = JSON.parse(content);
+        if (project.cliVersion !== import_version.VERSION) {
+          project.cliVersion = import_version.VERSION;
+          import_fs.default.writeFileSync(projectJsonPath, JSON.stringify(project, null, 2));
+          migrated++;
+        }
+      } catch {
+      }
+    }
+    if (migrated > 0) {
+      console.log(`   ${GREEN}\u2713${NC} Updated ${migrated} project(s) to v${import_version.VERSION}`);
+    }
+  } catch {
+  }
+}
+__name(migrateProjectsCliVersion, "migrateProjectsCliVersion");
+function ensureStatusLineSettings(settingsPath, statusLinePath) {
+  let settings = {};
+  if (import_fs.default.existsSync(settingsPath)) {
+    try {
+      settings = JSON.parse(import_fs.default.readFileSync(settingsPath, "utf8"));
+    } catch {
+    }
+  }
+  settings.statusLine = { type: "command", command: statusLinePath };
+  import_fs.default.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+}
+__name(ensureStatusLineSettings, "ensureStatusLineSettings");
+async function installStatusLine() {
+  try {
+    const claudeDir = import_path3.default.join(import_os3.default.homedir(), ".claude");
+    const settingsPath = import_path3.default.join(claudeDir, "settings.json");
+    const claudeStatusLinePath = import_path3.default.join(claudeDir, "prjct-statusline.sh");
+    const prjctStatusLineDir = import_path3.default.join(import_os3.default.homedir(), ".prjct-cli", "statusline");
+    const prjctStatusLinePath = import_path3.default.join(prjctStatusLineDir, "statusline.sh");
+    const prjctThemesDir = import_path3.default.join(prjctStatusLineDir, "themes");
+    const prjctLibDir = import_path3.default.join(prjctStatusLineDir, "lib");
+    const prjctComponentsDir = import_path3.default.join(prjctStatusLineDir, "components");
+    const prjctConfigPath = import_path3.default.join(prjctStatusLineDir, "config.json");
+    const assetsDir = import_path3.default.join(__dirname, "..", "..", "assets", "statusline");
+    const sourceScript = import_path3.default.join(assetsDir, "statusline.sh");
+    const sourceThemeDir = import_path3.default.join(assetsDir, "themes");
+    const sourceLibDir = import_path3.default.join(assetsDir, "lib");
+    const sourceComponentsDir = import_path3.default.join(assetsDir, "components");
+    const sourceConfigPath = import_path3.default.join(assetsDir, "default-config.json");
+    if (!import_fs.default.existsSync(claudeDir)) {
+      import_fs.default.mkdirSync(claudeDir, { recursive: true });
+    }
+    if (!import_fs.default.existsSync(prjctStatusLineDir)) {
+      import_fs.default.mkdirSync(prjctStatusLineDir, { recursive: true });
+    }
+    if (!import_fs.default.existsSync(prjctThemesDir)) {
+      import_fs.default.mkdirSync(prjctThemesDir, { recursive: true });
+    }
+    if (!import_fs.default.existsSync(prjctLibDir)) {
+      import_fs.default.mkdirSync(prjctLibDir, { recursive: true });
+    }
+    if (!import_fs.default.existsSync(prjctComponentsDir)) {
+      import_fs.default.mkdirSync(prjctComponentsDir, { recursive: true });
+    }
+    if (import_fs.default.existsSync(prjctStatusLinePath)) {
+      const existingContent = import_fs.default.readFileSync(prjctStatusLinePath, "utf8");
+      if (existingContent.includes("CLI_VERSION=")) {
+        const versionMatch = existingContent.match(/CLI_VERSION="([^"]*)"/);
+        if (versionMatch && versionMatch[1] !== import_version.VERSION) {
+          const updatedContent = existingContent.replace(
+            /CLI_VERSION="[^"]*"/,
+            `CLI_VERSION="${import_version.VERSION}"`
+          );
+          import_fs.default.writeFileSync(prjctStatusLinePath, updatedContent, { mode: 493 });
+        }
+        installStatusLineModules(sourceLibDir, prjctLibDir);
+        installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
+        ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
+        ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
+        return;
+      }
+    }
+    if (import_fs.default.existsSync(sourceScript)) {
+      let scriptContent = import_fs.default.readFileSync(sourceScript, "utf8");
+      scriptContent = scriptContent.replace(
+        /CLI_VERSION="[^"]*"/,
+        `CLI_VERSION="${import_version.VERSION}"`
+      );
+      import_fs.default.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+      installStatusLineModules(sourceLibDir, prjctLibDir);
+      installStatusLineModules(sourceComponentsDir, prjctComponentsDir);
+      if (import_fs.default.existsSync(sourceThemeDir)) {
+        const themes = import_fs.default.readdirSync(sourceThemeDir);
+        for (const theme of themes) {
+          const src = import_path3.default.join(sourceThemeDir, theme);
+          const dest = import_path3.default.join(prjctThemesDir, theme);
+          import_fs.default.copyFileSync(src, dest);
+        }
+      }
+      if (!import_fs.default.existsSync(prjctConfigPath) && import_fs.default.existsSync(sourceConfigPath)) {
+        import_fs.default.copyFileSync(sourceConfigPath, prjctConfigPath);
+      }
+    } else {
+      const scriptContent = `#!/bin/bash
+# prjct Status Line for Claude Code
+CLI_VERSION="${import_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"
+`;
+      import_fs.default.writeFileSync(prjctStatusLinePath, scriptContent, { mode: 493 });
+    }
+    ensureStatusLineSymlink(claudeStatusLinePath, prjctStatusLinePath);
+    ensureStatusLineSettings(settingsPath, claudeStatusLinePath);
+  } catch {
+  }
+}
+__name(installStatusLine, "installStatusLine");
+function installStatusLineModules(sourceDir, destDir) {
+  if (!import_fs.default.existsSync(sourceDir)) {
+    return;
+  }
+  const files = import_fs.default.readdirSync(sourceDir);
+  for (const file of files) {
+    if (file.endsWith(".sh")) {
+      const src = import_path3.default.join(sourceDir, file);
+      const dest = import_path3.default.join(destDir, file);
+      import_fs.default.copyFileSync(src, dest);
+      import_fs.default.chmodSync(dest, 493);
+    }
+  }
+}
+__name(installStatusLineModules, "installStatusLineModules");
+function ensureStatusLineSymlink(linkPath, targetPath) {
+  try {
+    if (import_fs.default.existsSync(linkPath)) {
+      const stats = import_fs.default.lstatSync(linkPath);
+      if (stats.isSymbolicLink()) {
+        const existingTarget = import_fs.default.readlinkSync(linkPath);
+        if (existingTarget === targetPath) {
+          return;
+        }
+      }
+      import_fs.default.unlinkSync(linkPath);
+    }
+    import_fs.default.symlinkSync(targetPath, linkPath);
+  } catch {
+    try {
+      if (import_fs.default.existsSync(targetPath)) {
+        import_fs.default.copyFileSync(targetPath, linkPath);
+        import_fs.default.chmodSync(linkPath, 493);
+      }
+    } catch {
+    }
+  }
+}
+__name(ensureStatusLineSymlink, "ensureStatusLineSymlink");
+function showResults(results) {
+  console.log("");
+  if (results.claudeInstalled) {
+    console.log(`   ${GREEN}\u2713${NC} Claude Code CLI installed`);
+  } else {
+    console.log(`   ${GREEN}\u2713${NC} Claude Code 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(`   ${GREEN}\u2713${NC} Commands synced (${parts.join(", ")})`);
+  } else {
+    console.log(`   ${GREEN}\u2713${NC} Commands up to date`);
+  }
+  if (results.configAction === "created") {
+    console.log(`   ${GREEN}\u2713${NC} Global config created`);
+  } else if (results.configAction === "updated") {
+    console.log(`   ${GREEN}\u2713${NC} Global config updated`);
+  } else if (results.configAction === "appended") {
+    console.log(`   ${GREEN}\u2713${NC} Global config merged`);
+  }
+  console.log("");
+}
+__name(showResults, "showResults");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  run
+});