prjct-cli 0.35.4 → 0.37.0

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

@@ -33,8 +33,10 @@ var command_installer_exports = {};
 __export(command_installer_exports, {
   CommandInstaller: () => CommandInstaller,
   default: () => command_installer_default,
+  getProviderPaths: () => getProviderPaths,
   installDocs: () => installDocs,
-  installGlobalConfig: () => installGlobalConfig
+  installGlobalConfig: () => installGlobalConfig,
+  isRouterInstalled: () => isRouterInstalled
 });
 module.exports = __toCommonJS(command_installer_exports);
 var import_promises = __toESM(require("fs/promises"));
@@ -489,11 +491,40 @@ var CommandInstaller = class {
     return installDocs();
   }
 };
+function getProviderPaths() {
+  const homeDir = import_os.default.homedir();
+  return {
+    claude: {
+      commands: import_path2.default.join(homeDir, ".claude", "commands", "p"),
+      config: import_path2.default.join(homeDir, ".claude"),
+      router: import_path2.default.join(homeDir, ".claude", "commands", "p.md")
+    },
+    gemini: {
+      commands: import_path2.default.join(homeDir, ".gemini", "commands"),
+      config: import_path2.default.join(homeDir, ".gemini"),
+      router: import_path2.default.join(homeDir, ".gemini", "commands", "p.toml")
+    }
+  };
+}
+__name(getProviderPaths, "getProviderPaths");
+async function isRouterInstalled(provider) {
+  const paths = getProviderPaths();
+  const routerPath = paths[provider].router;
+  try {
+    await import_promises.default.access(routerPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(isRouterInstalled, "isRouterInstalled");
 var commandInstaller = new CommandInstaller();
 var command_installer_default = commandInstaller;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CommandInstaller,
+  getProviderPaths,
   installDocs,
-  installGlobalConfig
+  installGlobalConfig,
+  isRouterInstalled
 });

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

@@ -77,14 +77,16 @@ var EditorsConfig = class {
   /**
    * Save installation configuration
    */
-  async saveConfig(version, claudePath) {
+  async saveConfig(version, installPath, provider = "claude") {
     try {
       await this.ensureConfigDir();
       const config = {
         version,
-        editor: "claude",
+        editor: provider,
+        // deprecated, kept for backward compatibility
+        provider,
         lastInstall: (/* @__PURE__ */ new Date()).toISOString(),
-        path: claudePath
+        path: installPath
       };
       await import_promises.default.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
       return true;
@@ -93,6 +95,14 @@ var EditorsConfig = class {
       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
    */

package/dist/core/infrastructure/setup.js

@@ -35,10 +35,10 @@ __export(setup_exports, {
   run: () => run
 });
 module.exports = __toCommonJS(setup_exports);
-var import_child_process = require("child_process");
+var import_child_process2 = require("child_process");
 var import_fs3 = __toESM(require("fs"));
-var import_path4 = __toESM(require("path"));
-var import_os3 = __toESM(require("os"));
+var import_path5 = __toESM(require("path"));
+var import_os4 = __toESM(require("os"));
 
 // core/infrastructure/command-installer.ts
 var import_promises = __toESM(require("fs/promises"));
@@ -540,14 +540,16 @@ var EditorsConfig = class {
   /**
    * Save installation configuration
    */
-  async saveConfig(version, claudePath) {
+  async saveConfig(version, installPath, provider = "claude") {
     try {
       await this.ensureConfigDir();
       const config = {
         version,
-        editor: "claude",
+        editor: provider,
+        // deprecated, kept for backward compatibility
+        provider,
         lastInstall: (/* @__PURE__ */ new Date()).toISOString(),
-        path: claudePath
+        path: installPath
       };
       await import_promises2.default.writeFile(this.configFile, JSON.stringify(config, null, 2), "utf-8");
       return true;
@@ -556,6 +558,14 @@ var EditorsConfig = class {
       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
    */
@@ -619,84 +629,294 @@ var EditorsConfig = class {
 var editorsConfig = new EditorsConfig();
 var editors_config_default = editorsConfig;
 
+// core/infrastructure/ai-provider.ts
+var import_child_process = require("child_process");
+var import_path4 = __toESM(require("path"));
+var import_os3 = __toESM(require("os"));
+var ClaudeProvider = {
+  name: "claude",
+  displayName: "Claude Code",
+  cliCommand: "claude",
+  configDir: import_path4.default.join(import_os3.default.homedir(), ".claude"),
+  contextFile: "CLAUDE.md",
+  skillsDir: import_path4.default.join(import_os3.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"
+};
+var GeminiProvider = {
+  name: "gemini",
+  displayName: "Gemini CLI",
+  cliCommand: "gemini",
+  configDir: import_path4.default.join(import_os3.default.homedir(), ".gemini"),
+  contextFile: "GEMINI.md",
+  skillsDir: import_path4.default.join(import_os3.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"
+};
+var Providers = {
+  claude: ClaudeProvider,
+  gemini: GeminiProvider
+};
+function whichCommand(command) {
+  try {
+    const result = (0, import_child_process.execSync)(`which ${command}`, { stdio: "pipe", encoding: "utf-8" });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+__name(whichCommand, "whichCommand");
+function getCliVersion(command) {
+  try {
+    const result = (0, import_child_process.execSync)(`${command} --version`, { stdio: "pipe", encoding: "utf-8" });
+    const match = result.match(/\d+\.\d+\.\d+/);
+    return match ? match[0] : result.trim();
+  } catch {
+    return null;
+  }
+}
+__name(getCliVersion, "getCliVersion");
+function detectProvider(provider) {
+  const config = Providers[provider];
+  const cliPath = whichCommand(config.cliCommand);
+  if (!cliPath) {
+    return { installed: false };
+  }
+  const version = getCliVersion(config.cliCommand);
+  return {
+    installed: true,
+    version: version || void 0,
+    path: cliPath
+  };
+}
+__name(detectProvider, "detectProvider");
+function detectAllProviders() {
+  return {
+    claude: detectProvider("claude"),
+    gemini: detectProvider("gemini")
+  };
+}
+__name(detectAllProviders, "detectAllProviders");
+function selectProvider() {
+  const detection = 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
+  };
+}
+__name(selectProvider, "selectProvider");
+
 // core/infrastructure/setup.ts
 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 (_error) {
-    return false;
-  }
-}
-__name(hasClaudeCodeCLI, "hasClaudeCodeCLI");
-async function installClaudeCode() {
+async function installAICLI(provider) {
+  const packageName = provider.name === "claude" ? "@anthropic-ai/claude-code" : "@google/gemini-cli";
   try {
-    console.log(`${YELLOW}\u{1F4E6} Claude Code not found. Installing...${NC}`);
+    console.log(`${YELLOW}\u{1F4E6} ${provider.displayName} not found. Installing...${NC}`);
     console.log("");
-    (0, import_child_process.execSync)("npm install -g @anthropic-ai/claude-code", { stdio: "inherit" });
+    (0, import_child_process2.execSync)(`npm install -g ${packageName}`, { stdio: "inherit" });
     console.log("");
-    console.log(`${GREEN}\u2713${NC} Claude Code installed successfully`);
+    console.log(`${GREEN}\u2713${NC} ${provider.displayName} 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(`${YELLOW}\u26A0\uFE0F  Failed to install ${provider.displayName}: ${error.message}${NC}`);
+    console.log(`${DIM}Please install manually: npm install -g ${packageName}${NC}`);
     console.log("");
     return false;
   }
 }
-__name(installClaudeCode, "installClaudeCode");
+__name(installAICLI, "installAICLI");
 async function run() {
+  const detection = detectAllProviders();
+  const selection = selectProvider();
+  const primaryProvider = Providers[selection.provider];
   const results = {
-    claudeInstalled: false,
+    provider: selection.provider,
+    providers: [],
+    cliInstalled: 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 providerNames = ["claude", "gemini"];
+  for (const providerName of providerNames) {
+    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;
+      }
     }
-    const configResult = await command_installer_default.installGlobalConfig();
-    if (configResult.success) {
-      results.configAction = configResult.action;
+    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();
+      }
+    } 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;
+      }
     }
-    await command_installer_default.installDocs();
-    await installStatusLine();
+    results.providers.push(providerResult);
   }
-  await editors_config_default.saveConfig(VERSION, command_installer_default.getInstallPath());
+  await editors_config_default.saveConfig(VERSION, command_installer_default.getInstallPath(), selection.provider);
   await migrateProjectsCliVersion();
-  showResults(results);
+  for (const providerResult of results.providers) {
+    showResults(providerResult, Providers[providerResult.provider]);
+  }
   return results;
 }
 __name(run, "run");
 var setup_default = { run };
+async function installGeminiRouter() {
+  try {
+    const geminiCommandsDir = import_path5.default.join(import_os4.default.homedir(), ".gemini", "commands");
+    const routerSource = import_path5.default.join(getPackageRoot(), "templates", "commands", "p.toml");
+    const routerDest = import_path5.default.join(geminiCommandsDir, "p.toml");
+    import_fs3.default.mkdirSync(geminiCommandsDir, { recursive: true });
+    if (import_fs3.default.existsSync(routerSource)) {
+      import_fs3.default.copyFileSync(routerSource, routerDest);
+      return true;
+    }
+    return false;
+  } catch (error) {
+    console.error(`Gemini router warning: ${error.message}`);
+    return false;
+  }
+}
+__name(installGeminiRouter, "installGeminiRouter");
+async function installGeminiGlobalConfig() {
+  try {
+    const geminiDir = import_path5.default.join(import_os4.default.homedir(), ".gemini");
+    const globalConfigPath = import_path5.default.join(geminiDir, "GEMINI.md");
+    const templatePath = import_path5.default.join(getPackageRoot(), "templates", "global", "GEMINI.md");
+    import_fs3.default.mkdirSync(geminiDir, { recursive: true });
+    const templateContent = import_fs3.default.readFileSync(templatePath, "utf-8");
+    let existingContent = "";
+    let fileExists = false;
+    try {
+      existingContent = import_fs3.default.readFileSync(globalConfigPath, "utf-8");
+      fileExists = true;
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        fileExists = false;
+      } else {
+        throw error;
+      }
+    }
+    if (!fileExists) {
+      import_fs3.default.writeFileSync(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 + "\n\n" + templateContent;
+      import_fs3.default.writeFileSync(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;
+    import_fs3.default.writeFileSync(globalConfigPath, updatedContent, "utf-8");
+    return { success: true, action: "updated" };
+  } catch (error) {
+    console.error(`Gemini config warning: ${error.message}`);
+    return { success: false, action: null };
+  }
+}
+__name(installGeminiGlobalConfig, "installGeminiGlobalConfig");
 async function migrateProjectsCliVersion() {
   try {
-    const projectsDir = import_path4.default.join(import_os3.default.homedir(), ".prjct-cli", "projects");
+    const projectsDir = import_path5.default.join(import_os4.default.homedir(), ".prjct-cli", "projects");
     if (!import_fs3.default.existsSync(projectsDir)) {
       return;
     }
     const projectDirs = import_fs3.default.readdirSync(projectsDir, { withFileTypes: true }).filter((dirent) => dirent.isDirectory()).map((dirent) => dirent.name);
     let migrated = 0;
     for (const projectId of projectDirs) {
-      const projectJsonPath = import_path4.default.join(projectsDir, projectId, "project.json");
+      const projectJsonPath = import_path5.default.join(projectsDir, projectId, "project.json");
       if (!import_fs3.default.existsSync(projectJsonPath)) {
         continue;
       }
@@ -741,21 +961,21 @@ function ensureStatusLineSettings(settingsPath, statusLinePath) {
 __name(ensureStatusLineSettings, "ensureStatusLineSettings");
 async function installStatusLine() {
   try {
-    const claudeDir = import_path4.default.join(import_os3.default.homedir(), ".claude");
-    const settingsPath = import_path4.default.join(claudeDir, "settings.json");
-    const claudeStatusLinePath = import_path4.default.join(claudeDir, "prjct-statusline.sh");
-    const prjctStatusLineDir = import_path4.default.join(import_os3.default.homedir(), ".prjct-cli", "statusline");
-    const prjctStatusLinePath = import_path4.default.join(prjctStatusLineDir, "statusline.sh");
-    const prjctThemesDir = import_path4.default.join(prjctStatusLineDir, "themes");
-    const prjctLibDir = import_path4.default.join(prjctStatusLineDir, "lib");
-    const prjctComponentsDir = import_path4.default.join(prjctStatusLineDir, "components");
-    const prjctConfigPath = import_path4.default.join(prjctStatusLineDir, "config.json");
-    const assetsDir = import_path4.default.join(getPackageRoot(), "assets", "statusline");
-    const sourceScript = import_path4.default.join(assetsDir, "statusline.sh");
-    const sourceThemeDir = import_path4.default.join(assetsDir, "themes");
-    const sourceLibDir = import_path4.default.join(assetsDir, "lib");
-    const sourceComponentsDir = import_path4.default.join(assetsDir, "components");
-    const sourceConfigPath = import_path4.default.join(assetsDir, "default-config.json");
+    const claudeDir = import_path5.default.join(import_os4.default.homedir(), ".claude");
+    const settingsPath = import_path5.default.join(claudeDir, "settings.json");
+    const claudeStatusLinePath = import_path5.default.join(claudeDir, "prjct-statusline.sh");
+    const prjctStatusLineDir = import_path5.default.join(import_os4.default.homedir(), ".prjct-cli", "statusline");
+    const prjctStatusLinePath = import_path5.default.join(prjctStatusLineDir, "statusline.sh");
+    const prjctThemesDir = import_path5.default.join(prjctStatusLineDir, "themes");
+    const prjctLibDir = import_path5.default.join(prjctStatusLineDir, "lib");
+    const prjctComponentsDir = import_path5.default.join(prjctStatusLineDir, "components");
+    const prjctConfigPath = import_path5.default.join(prjctStatusLineDir, "config.json");
+    const assetsDir = import_path5.default.join(getPackageRoot(), "assets", "statusline");
+    const sourceScript = import_path5.default.join(assetsDir, "statusline.sh");
+    const sourceThemeDir = import_path5.default.join(assetsDir, "themes");
+    const sourceLibDir = import_path5.default.join(assetsDir, "lib");
+    const sourceComponentsDir = import_path5.default.join(assetsDir, "components");
+    const sourceConfigPath = import_path5.default.join(assetsDir, "default-config.json");
     if (!import_fs3.default.existsSync(claudeDir)) {
       import_fs3.default.mkdirSync(claudeDir, { recursive: true });
     }
@@ -801,8 +1021,8 @@ async function installStatusLine() {
       if (import_fs3.default.existsSync(sourceThemeDir)) {
         const themes = import_fs3.default.readdirSync(sourceThemeDir);
         for (const theme of themes) {
-          const src = import_path4.default.join(sourceThemeDir, theme);
-          const dest = import_path4.default.join(prjctThemesDir, theme);
+          const src = import_path5.default.join(sourceThemeDir, theme);
+          const dest = import_path5.default.join(prjctThemesDir, theme);
           import_fs3.default.copyFileSync(src, dest);
         }
       }
@@ -860,8 +1080,8 @@ function installStatusLineModules(sourceDir, destDir) {
   const files = import_fs3.default.readdirSync(sourceDir);
   for (const file of files) {
     if (file.endsWith(".sh")) {
-      const src = import_path4.default.join(sourceDir, file);
-      const dest = import_path4.default.join(destDir, file);
+      const src = import_path5.default.join(sourceDir, file);
+      const dest = import_path5.default.join(destDir, file);
       import_fs3.default.copyFileSync(src, dest);
       import_fs3.default.chmodSync(dest, 493);
     }
@@ -895,12 +1115,12 @@ function ensureStatusLineSymlink(linkPath, targetPath) {
   }
 }
 __name(ensureStatusLineSymlink, "ensureStatusLineSymlink");
-function showResults(results) {
+function showResults(results, provider) {
   console.log("");
-  if (results.claudeInstalled) {
-    console.log(`   ${GREEN}\u2713${NC} Claude Code CLI installed`);
+  if (results.cliInstalled) {
+    console.log(`   ${GREEN}\u2713${NC} ${provider.displayName} CLI installed`);
   } else {
-    console.log(`   ${GREEN}\u2713${NC} Claude Code CLI found`);
+    console.log(`   ${GREEN}\u2713${NC} ${provider.displayName} CLI found`);
   }
   const totalCommands = results.commandsAdded + results.commandsUpdated;
   if (totalCommands > 0) {
@@ -912,11 +1132,11 @@ function showResults(results) {
     console.log(`   ${GREEN}\u2713${NC} Commands up to date`);
   }
   if (results.configAction === "created") {
-    console.log(`   ${GREEN}\u2713${NC} Global config created`);
+    console.log(`   ${GREEN}\u2713${NC} Global config created (${provider.contextFile})`);
   } else if (results.configAction === "updated") {
-    console.log(`   ${GREEN}\u2713${NC} Global config updated`);
+    console.log(`   ${GREEN}\u2713${NC} Global config updated (${provider.contextFile})`);
   } else if (results.configAction === "appended") {
-    console.log(`   ${GREEN}\u2713${NC} Global config merged`);
+    console.log(`   ${GREEN}\u2713${NC} Global config merged (${provider.contextFile})`);
   }
   console.log("");
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "prjct-cli",
-  "version": "0.35.4",
-  "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
+  "version": "0.37.0",
+  "description": "Context layer for AI agents. Project context for Claude Code, Gemini CLI, and more.",
   "main": "core/index.ts",
   "bin": {
     "prjct": "bin/prjct"
@@ -34,15 +34,15 @@
   },
   "keywords": [
     "claude-code",
-    "claude-desktop",
-    "developer-momentum",
-    "indie-hacker",
-    "ship-fast",
+    "gemini-cli",
+    "ai-agents",
+    "context-layer",
+    "developer-tools",
     "ai-assistant",
     "productivity",
-    "developer-tools",
-    "no-bs",
-    "focus"
+    "mcp",
+    "llm",
+    "coding-agents"
   ],
   "author": "prjct.app",
   "license": "MIT",