prjct-cli 0.34.0 → 0.35.0

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

@@ -0,0 +1,499 @@
+"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/command-installer.ts
+var command_installer_exports = {};
+__export(command_installer_exports, {
+  CommandInstaller: () => CommandInstaller,
+  default: () => command_installer_default,
+  installDocs: () => installDocs,
+  installGlobalConfig: () => installGlobalConfig
+});
+module.exports = __toCommonJS(command_installer_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_path2 = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+
+// core/utils/version.ts
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("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_path.default.join(currentDir, "package.json");
+    if (import_fs.default.existsSync(packageJsonPath)) {
+      try {
+        const pkg = JSON.parse(import_fs.default.readFileSync(packageJsonPath, "utf-8"));
+        if (pkg.name === "prjct-cli") {
+          cachedPackageRoot = currentDir;
+          return currentDir;
+        }
+      } catch (_error) {
+      }
+    }
+    currentDir = import_path.default.dirname(currentDir);
+  }
+  cachedPackageRoot = import_path.default.join(__dirname, "..", "..", "..");
+  return cachedPackageRoot;
+}
+__name(getPackageRoot, "getPackageRoot");
+function getVersion() {
+  if (cachedVersion) {
+    return cachedVersion;
+  }
+  try {
+    const packageJsonPath = import_path.default.join(getPackageRoot(), "package.json");
+    const packageJson = JSON.parse(import_fs.default.readFileSync(packageJsonPath, "utf-8"));
+    cachedVersion = packageJson.version;
+    cachedPackageJson = packageJson;
+    return cachedVersion;
+  } catch (error) {
+    console.error("Failed to read version from package.json:", error.message);
+    return "0.0.0";
+  }
+}
+__name(getVersion, "getVersion");
+var VERSION = getVersion();
+var PACKAGE_ROOT = getPackageRoot();
+
+// core/types/fs.ts
+function isNotFoundError(error) {
+  return error?.code === "ENOENT";
+}
+__name(isNotFoundError, "isNotFoundError");
+
+// core/infrastructure/command-installer.ts
+async function installDocs() {
+  try {
+    const docsDir = import_path2.default.join(import_os.default.homedir(), ".prjct-cli", "docs");
+    const templateDocsDir = import_path2.default.join(getPackageRoot(), "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_path2.default.join(templateDocsDir, file);
+        const destPath = import_path2.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_path2.default.join(import_os.default.homedir(), ".claude");
+    await import_promises.default.mkdir(claudeDir, { recursive: true });
+    const globalConfigPath = import_path2.default.join(claudeDir, "CLAUDE.md");
+    const templatePath = import_path2.default.join(getPackageRoot(), "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 (error) {
+      if (isNotFoundError(error)) {
+        fileExists = false;
+      } else {
+        throw error;
+      }
+    }
+    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_path2.default.join(this.homeDir, ".claude", "commands", "p");
+    this.claudeConfigPath = import_path2.default.join(this.homeDir, ".claude");
+    this.templatesDir = import_path2.default.join(getPackageRoot(), "templates", "commands");
+  }
+  /**
+   * Detect if Claude is installed
+   */
+  async detectClaude() {
+    try {
+      await import_promises.default.access(this.claudeConfigPath);
+      return true;
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * 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 (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 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_path2.default.join(this.templatesDir, file);
+          const destPath = import_path2.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_path2.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 (error) {
+      }
+      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 (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
+   */
+  getInstallPath() {
+    return this.claudeCommandsPath;
+  }
+  /**
+   * Verify command template exists
+   */
+  async verifyTemplate(commandName) {
+    try {
+      const templatePath = import_path2.default.join(this.templatesDir, `${commandName}.md`);
+      await import_promises.default.access(templatePath);
+      return true;
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * 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_path2.default.join(this.templatesDir, "p.md");
+      const routerDest = import_path2.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 (error) {
+      if (isNotFoundError(error)) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  /**
+   * 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 (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_path2.default.join(this.templatesDir, file);
+          const destPath = import_path2.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;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CommandInstaller,
+  installDocs,
+  installGlobalConfig
+});

package/dist/core/infrastructure/editors-config.js

@@ -0,0 +1,157 @@
+"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/editors-config.ts
+var editors_config_exports = {};
+__export(editors_config_exports, {
+  default: () => editors_config_default
+});
+module.exports = __toCommonJS(editors_config_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var import_os = __toESM(require("os"));
+var EditorsConfig = class {
+  static {
+    __name(this, "EditorsConfig");
+  }
+  homeDir;
+  configDir;
+  configFile;
+  constructor() {
+    this.homeDir = import_os.default.homedir();
+    this.configDir = import_path.default.join(this.homeDir, ".prjct-cli", "config");
+    this.configFile = import_path.default.join(this.configDir, "installed-editors.json");
+  }
+  /**
+   * Ensure config directory exists
+   */
+  async ensureConfigDir() {
+    try {
+      await import_promises.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_promises.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_promises.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_promises.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_promises.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_promises.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;