prjct-cli 0.61.0 → 0.63.0

package/dist/core/infrastructure/setup.js

@@ -60,7 +60,7 @@ __export(ai_provider_exports, {
 });
 function whichCommand(command) {
   try {
-    const result = (0, import_node_child_process.execSync)(`which ${command}`, { stdio: "pipe", encoding: "utf-8" });
+    const result = (0, import_node_child_process2.execSync)(`which ${command}`, { stdio: "pipe", encoding: "utf-8" });
     return result.trim();
   } catch {
     return null;
@@ -68,7 +68,7 @@ function whichCommand(command) {
 }
 function getCliVersion(command) {
   try {
-    const result = (0, import_node_child_process.execSync)(`${command} --version`, { stdio: "pipe", encoding: "utf-8" });
+    const result = (0, import_node_child_process2.execSync)(`${command} --version`, { stdio: "pipe", encoding: "utf-8" });
     const match = result.match(/\d+\.\d+\.\d+/);
     return match ? match[0] : result.trim();
   } catch {
@@ -233,11 +233,11 @@ function selectProvider() {
     detection
   };
 }
-var import_node_child_process, import_node_fs2, import_node_os, import_node_path2, ClaudeProvider, GeminiProvider, AntigravityProvider, CursorProvider, WindsurfProvider, Providers, ai_provider_default;
+var import_node_child_process2, import_node_fs2, import_node_os, import_node_path2, ClaudeProvider, GeminiProvider, AntigravityProvider, CursorProvider, WindsurfProvider, Providers, ai_provider_default;
 var init_ai_provider = __esm({
   "core/infrastructure/ai-provider.ts"() {
     "use strict";
-    import_node_child_process = require("node:child_process");
+    import_node_child_process2 = require("node:child_process");
     import_node_fs2 = __toESM(require("node:fs"));
     import_node_os = __toESM(require("node:os"));
     import_node_path2 = __toESM(require("node:path"));
@@ -404,11 +404,287 @@ __export(setup_exports, {
   run: () => run
 });
 module.exports = __toCommonJS(setup_exports);
-var import_node_child_process2 = require("node:child_process");
+var import_node_child_process3 = require("node:child_process");
 var import_node_fs3 = __toESM(require("node:fs"));
 var import_node_os4 = __toESM(require("node:os"));
 var import_node_path5 = __toESM(require("node:path"));
 
+// 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 isNotFoundError(error) {
   return error?.code === "ENOENT";
@@ -1119,19 +1395,49 @@ var DIM = "\x1B[2m";
 var NC = "\x1B[0m";
 async function installAICLI(provider) {
   const packageName = provider.name === "claude" ? "@anthropic-ai/claude-code" : "@google/gemini-cli";
+  if (!dependencyValidator.isAvailable("npm")) {
+    console.log(`${YELLOW}\u26A0\uFE0F  npm is not available${NC}`);
+    console.log("");
+    console.log(`${DIM}Install ${provider.displayName} using one of:${NC}`);
+    console.log(`${DIM}  \u2022 Install Node.js: https://nodejs.org${NC}`);
+    console.log(
+      `${DIM}  \u2022 Use Homebrew: brew install ${provider.name === "claude" ? "claude" : "gemini"}${NC}`
+    );
+    console.log(`${DIM}  \u2022 Use npx directly: npx ${packageName}${NC}`);
+    console.log("");
+    return false;
+  }
   try {
     console.log(`${YELLOW}\u{1F4E6} ${provider.displayName} not found. Installing...${NC}`);
     console.log("");
-    (0, import_node_child_process2.execSync)(`npm install -g ${packageName}`, { stdio: "inherit" });
+    (0, import_node_child_process3.execSync)(`npm install -g ${packageName}`, {
+      stdio: "inherit",
+      timeout: getTimeout("NPM_INSTALL")
+    });
     console.log("");
     console.log(`${GREEN}\u2713${NC} ${provider.displayName} installed successfully`);
     console.log("");
     return true;
   } catch (error) {
+    const err = error;
+    const isTimeout = err.killed && err.signal === "SIGTERM";
+    if (isTimeout) {
+      console.log(`${YELLOW}\u26A0\uFE0F  Installation timed out for ${provider.displayName}${NC}`);
+      console.log("");
+      console.log(`${DIM}The npm install took too long. Try:${NC}`);
+      console.log(`${DIM}  \u2022 Set PRJCT_TIMEOUT_NPM_INSTALL=300000 for 5 minutes${NC}`);
+      console.log(`${DIM}  \u2022 Run manually: npm install -g ${packageName}${NC}`);
+    } else {
+      console.log(`${YELLOW}\u26A0\uFE0F  Failed to install ${provider.displayName}: ${err.message}${NC}`);
+    }
+    console.log("");
+    console.log(`${DIM}Alternative installation methods:${NC}`);
+    console.log(`${DIM}  \u2022 npm:  npm install -g ${packageName}${NC}`);
+    console.log(`${DIM}  \u2022 yarn: yarn global add ${packageName}${NC}`);
+    console.log(`${DIM}  \u2022 pnpm: pnpm add -g ${packageName}${NC}`);
     console.log(
-      `${YELLOW}\u26A0\uFE0F  Failed to install ${provider.displayName}: ${error.message}${NC}`
+      `${DIM}  \u2022 brew: brew install ${provider.name === "claude" ? "claude" : "gemini"}${NC}`
     );
-    console.log(`${DIM}Please install manually: npm install -g ${packageName}${NC}`);
     console.log("");
     return false;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.61.0",
+  "version": "0.63.0",
   "description": "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
   "main": "core/index.ts",
   "bin": {