@contextos/setup 0.1.0 → 0.2.1

package/README.md

@@ -0,0 +1,202 @@
+# @contextos/setup
+
+**Universal setup for ContextOS - one command to configure all AI coding tools**
+
+[![npm version](https://img.shields.io/npm/v/@contextos/setup?style=flat-square)](https://www.npmjs.com/package/@contextos/setup)
+
+```bash
+npx @contextos/setup
+```
+
+## 🎯 What It Does
+
+This package automatically detects and configures ContextOS for **all your AI coding tools**:
+
+### ✅ Supported Tools
+
+| Tool | Type | MCP Support | Auto-Configure |
+|------|------|-------------|----------------|
+| **Claude Desktop** | IDE | ✅ Native | ✅ |
+| **Claude Code CLI** | CLI | ✅ Native | ✅ |
+| **Cursor** | IDE | ✅ Native | ✅ |
+| **Windsurf** | IDE | ✅ Native | ✅ |
+| **VS Code** | IDE | 🔌 Extension | ✅ |
+| **Kilo Code** | IDE | ✅ Native | ✅ |
+| **Codex CLI** | CLI | 📦 Wrapper | ✅ |
+| **Gemini CLI** | CLI | 📦 Wrapper | ✅ |
+| **OpenCode CLI** | CLI | 📦 Wrapper | ✅ |
+| **Warp Terminal** | Terminal | 📦 Wrapper | ✅ |
+
+- ✅ **Native MCP**: Direct config injection, works immediately
+- 🔌 **Extension**: Needs VS Code extension (Continue.dev)
+- 📦 **Wrapper**: Creates wrapper script for context injection
+
+## 🚀 Quick Start
+
+### One-Command Setup
+
+```bash
+# Detect and configure ALL AI tools
+npx @contextos/setup
+
+# Example output:
+# 🚀 ContextOS Universal Setup
+#
+# Found 4 AI tool(s)
+#
+# 🖥️  IDEs:
+#    Claude Desktop MCP
+#    Cursor MCP
+#
+# ⌨️  CLI Tools:
+#    Claude Code CLI MCP
+#    Codex CLI Wrapper
+#
+# ✓ Claude Desktop: MCP configuration added
+# ✓ Cursor: MCP configuration added
+# ✓ Claude Code CLI: MCP configuration added
+# ✓ Codex CLI: Wrapper script created
+#     → Add ~/.local/bin to your PATH
+#     → Use 'codex-ctx' instead of 'codex'
+#
+# ✅ Setup complete: 4/4 tools configured
+```
+
+## 📋 Commands
+
+### `npx @contextos/setup` (or `npx @contextos/setup auto`)
+
+Automatically detect and configure all tools.
+
+**Options:**
+- `--dry-run` - Preview without making changes
+- `--force` - Overwrite existing configurations
+- `--only-mcp` - Only configure tools with native MCP support
+- `--only-cli` - Only configure CLI tools
+- `--only-ide` - Only configure IDE apps
+
+### `npx @contextos/setup list`
+
+List all detected AI tools and their status.
+
+```bash
+npx @contextos/setup list
+
+# Output:
+#   Tool                    Type        MCP Support    Status
+#   ────────────────────────────────────────────────────────────
+#   🖥️ Claude Desktop        IDE         MCP            Ready
+#   🖥️ Cursor                IDE         MCP            Configured
+#   ⌨️ Claude Code CLI       CLI         MCP            Ready
+#   ⌨️ Codex CLI             CLI         Wrapper        Ready
+```
+
+### `npx @contextos/setup configure <tool>`
+
+Configure a specific tool.
+
+```bash
+npx @contextos/setup configure cursor
+npx @contextos/setup configure codex --force
+```
+
+### `npx @contextos/setup hook`
+
+Generate shell hook for automatic context updates.
+
+```bash
+npx @contextos/setup hook
+
+# Output shell script to add to ~/.bashrc or ~/.zshrc
+```
+
+### `npx @contextos/setup status`
+
+Show integration status overview.
+
+## 🔧 How It Works
+
+### For Native MCP Tools (Claude, Cursor, Windsurf)
+
+We inject configuration directly into the tool's config file:
+
+**Claude Desktop** (`~/.config/claude/claude_desktop_config.json`):
+```json
+{
+  "mcpServers": {
+    "contextos": {
+      "command": "npx",
+      "args": ["-y", "@contextos/mcp"]
+    }
+  }
+}
+```
+
+**Cursor** (`~/.config/Cursor/User/settings.json`):
+```json
+{
+  "mcp.servers": {
+    "contextos": {
+      "command": "npx @contextos/mcp",
+      "cwd": "${workspaceFolder}"
+    }
+  }
+}
+```
+
+### For Wrapper Tools (Codex, Gemini CLI)
+
+We create wrapper scripts in `~/.local/bin/`:
+
+```bash
+# ~/.local/bin/codex-ctx
+#!/bin/bash
+# ContextOS wrapper for Codex CLI
+
+# Build context if in a ContextOS project
+if [ -d ".contextos" ]; then
+    npx @contextos/mcp --build 2>/dev/null
+fi
+
+# Run original command with context
+codex "$@" --system-prompt "$(cat .contextos/cache/last-context.md)"
+```
+
+## 📦 After Setup
+
+1. **Restart your IDE(s)** - Configuration changes require restart
+2. **Navigate to a project** - `cd your-project`
+3. **Initialize ContextOS** - `npx @contextos/cli init`
+4. **Use AI with context!** - Your AI tools now have optimized context
+
+## 🔍 Troubleshooting
+
+### Tool not detected?
+
+Make sure the tool is installed and has created its config directory:
+
+```bash
+# Check if config directory exists
+ls ~/.config/Cursor/  # Linux/macOS
+dir %APPDATA%\Cursor\  # Windows
+```
+
+### MCP not working?
+
+1. Check tool's MCP settings
+2. Verify `npx @contextos/mcp` runs correctly
+3. Check logs in tool's developer console
+
+### Need to reconfigure?
+
+```bash
+npx @contextos/setup configure cursor --force
+```
+
+## 🤝 Contributing
+
+Found a tool we should support? Open an issue or PR!
+
+## 📄 License
+
+MIT © ContextOS Team

package/dist/index.js

@@ -10,38 +10,48 @@ import inquirer from "inquirer";
 import { existsSync } from "fs";
 import { homedir, platform } from "os";
 import { join } from "path";
-function detectClaude() {
+import { execSync } from "child_process";
+function commandExists(cmd) {
+  try {
+    const isWin = platform() === "win32";
+    const checkCmd = isWin ? `where ${cmd}` : `which ${cmd}`;
+    execSync(checkCmd, { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getConfigDir(appName, subPath = "") {
   const os = platform();
-  let configPath;
+  let base;
   if (os === "win32") {
-    configPath = join(homedir(), "AppData", "Roaming", "Claude", "claude_desktop_config.json");
+    base = join(homedir(), "AppData", "Roaming", appName);
   } else if (os === "darwin") {
-    configPath = join(homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+    base = join(homedir(), "Library", "Application Support", appName);
   } else {
-    configPath = join(homedir(), ".config", "claude", "claude_desktop_config.json");
+    base = join(homedir(), ".config", appName.toLowerCase());
   }
+  return subPath ? join(base, subPath) : base;
+}
+function detectClaudeDesktop() {
+  const configPath = getConfigDir("Claude", "claude_desktop_config.json");
   const configDir = join(configPath, "..");
   const isInstalled = existsSync(configDir) || existsSync(configPath);
   if (!isInstalled) return null;
   return {
-    id: "claude",
+    id: "claude-desktop",
     name: "Claude Desktop",
     configPath,
     configType: "json",
     hasExistingConfig: existsSync(configPath),
-    mcpKey: "mcpServers"
+    mcpKey: "mcpServers",
+    toolType: "ide",
+    mcpSupport: "native",
+    installMethod: "app"
   };
 }
 function detectCursor() {
-  const os = platform();
-  let configPath;
-  if (os === "win32") {
-    configPath = join(homedir(), "AppData", "Roaming", "Cursor", "User", "settings.json");
-  } else if (os === "darwin") {
-    configPath = join(homedir(), "Library", "Application Support", "Cursor", "User", "settings.json");
-  } else {
-    configPath = join(homedir(), ".config", "Cursor", "User", "settings.json");
-  }
+  const configPath = getConfigDir("Cursor", join("User", "settings.json"));
   const configDir = join(configPath, "..");
   const isInstalled = existsSync(configDir);
   if (!isInstalled) return null;
@@ -51,19 +61,14 @@ function detectCursor() {
     configPath,
     configType: "json",
     hasExistingConfig: existsSync(configPath),
-    mcpKey: "mcp.servers"
+    mcpKey: "mcp.servers",
+    toolType: "ide",
+    mcpSupport: "native",
+    installMethod: "app"
   };
 }
 function detectWindsurf() {
-  const os = platform();
-  let configPath;
-  if (os === "win32") {
-    configPath = join(homedir(), "AppData", "Roaming", "Windsurf", "User", "settings.json");
-  } else if (os === "darwin") {
-    configPath = join(homedir(), "Library", "Application Support", "Windsurf", "User", "settings.json");
-  } else {
-    configPath = join(homedir(), ".config", "Windsurf", "User", "settings.json");
-  }
+  const configPath = getConfigDir("Windsurf", join("User", "settings.json"));
   const configDir = join(configPath, "..");
   const isInstalled = existsSync(configDir);
   if (!isInstalled) return null;
@@ -73,19 +78,14 @@ function detectWindsurf() {
     configPath,
     configType: "json",
     hasExistingConfig: existsSync(configPath),
-    mcpKey: "mcp.servers"
+    mcpKey: "mcp.servers",
+    toolType: "ide",
+    mcpSupport: "native",
+    installMethod: "app"
   };
 }
 function detectVSCode() {
-  const os = platform();
-  let configPath;
-  if (os === "win32") {
-    configPath = join(homedir(), "AppData", "Roaming", "Code", "User", "settings.json");
-  } else if (os === "darwin") {
-    configPath = join(homedir(), "Library", "Application Support", "Code", "User", "settings.json");
-  } else {
-    configPath = join(homedir(), ".config", "Code", "User", "settings.json");
-  }
+  const configPath = getConfigDir("Code", join("User", "settings.json"));
   const configDir = join(configPath, "..");
   const isInstalled = existsSync(configDir);
   if (!isInstalled) return null;
@@ -95,64 +95,186 @@ function detectVSCode() {
     configPath,
     configType: "json",
     hasExistingConfig: existsSync(configPath),
-    mcpKey: "mcp.servers"
+    mcpKey: "mcp.servers",
+    toolType: "ide",
+    mcpSupport: "extension",
+    // VS Code uses Continue.dev extension for MCP
+    installMethod: "app"
   };
 }
-function detectCodex() {
-  const os = platform();
-  let configPath;
-  if (os === "win32") {
-    configPath = join(homedir(), ".codex", "config.json");
-  } else {
-    configPath = join(homedir(), ".codex", "config.json");
-  }
+function detectKiloCode() {
+  const configPath = getConfigDir("KiloCode", join("User", "settings.json"));
   const configDir = join(configPath, "..");
   const isInstalled = existsSync(configDir);
   if (!isInstalled) return null;
+  return {
+    id: "kilocode",
+    name: "Kilo Code",
+    configPath,
+    configType: "json",
+    hasExistingConfig: existsSync(configPath),
+    mcpKey: "mcp.servers",
+    toolType: "ide",
+    mcpSupport: "native",
+    installMethod: "app"
+  };
+}
+function detectClaudeCodeCLI() {
+  const hasCommand = commandExists("claude");
+  const configPath = join(homedir(), ".claude", "mcp.json");
+  const configDir = join(configPath, "..");
+  const hasConfig = existsSync(configDir);
+  if (!hasCommand && !hasConfig) return null;
+  return {
+    id: "claude-code",
+    name: "Claude Code CLI",
+    configPath,
+    configType: "json",
+    hasExistingConfig: existsSync(configPath),
+    mcpKey: "mcpServers",
+    toolType: "cli",
+    mcpSupport: "native",
+    installMethod: hasCommand ? "binary" : "npm"
+  };
+}
+function detectCodexCLI() {
+  const hasCommand = commandExists("codex");
+  const configPath = join(homedir(), ".codex", "config.json");
+  const configDir = join(configPath, "..");
+  const hasConfig = existsSync(configDir);
+  if (!hasCommand && !hasConfig) return null;
   return {
     id: "codex",
     name: "OpenAI Codex CLI",
     configPath,
     configType: "json",
     hasExistingConfig: existsSync(configPath),
-    mcpKey: "mcpServers"
+    mcpKey: "mcpServers",
+    toolType: "cli",
+    mcpSupport: "wrapper",
+    // Need to wrap with context injection
+    installMethod: hasCommand ? "npm" : void 0
+  };
+}
+function detectGeminiCLI() {
+  const hasCommand = commandExists("gemini");
+  const configPath = join(homedir(), ".gemini", "config.json");
+  const configDir = join(configPath, "..");
+  const hasConfig = existsSync(configDir);
+  if (!hasCommand && !hasConfig) return null;
+  return {
+    id: "gemini-cli",
+    name: "Gemini CLI",
+    configPath,
+    configType: "json",
+    hasExistingConfig: existsSync(configPath),
+    mcpKey: "mcpServers",
+    toolType: "cli",
+    mcpSupport: "wrapper",
+    // Need to wrap with context injection
+    installMethod: hasCommand ? "npm" : void 0
+  };
+}
+function detectOpenCodeCLI() {
+  const hasCommand = commandExists("opencode");
+  const configPath = join(homedir(), ".opencode", "config.json");
+  const configDir = join(configPath, "..");
+  const hasConfig = existsSync(configDir);
+  if (!hasCommand && !hasConfig) return null;
+  return {
+    id: "opencode",
+    name: "OpenCode CLI",
+    configPath,
+    configType: "json",
+    hasExistingConfig: existsSync(configPath),
+    mcpKey: "mcpServers",
+    toolType: "cli",
+    mcpSupport: "wrapper",
+    installMethod: hasCommand ? "binary" : void 0
+  };
+}
+function detectWarp() {
+  const os = platform();
+  let configPath;
+  if (os === "darwin") {
+    configPath = join(homedir(), ".warp", "config.yaml");
+  } else {
+    configPath = join(homedir(), ".warp", "config.yaml");
+  }
+  const configDir = join(configPath, "..");
+  const hasWarp = existsSync(configDir) || commandExists("warp");
+  if (!hasWarp) return null;
+  return {
+    id: "warp",
+    name: "Warp Terminal",
+    configPath,
+    configType: "yaml",
+    hasExistingConfig: existsSync(configPath),
+    mcpKey: "ai.context_providers",
+    toolType: "terminal",
+    mcpSupport: "wrapper",
+    // Needs shell hook integration
+    installMethod: "app"
   };
 }
 async function detectIDEs() {
   const detectors = [
-    detectClaude,
+    // Desktop Apps / IDEs
+    detectClaudeDesktop,
     detectCursor,
     detectWindsurf,
     detectVSCode,
-    detectCodex
+    detectKiloCode,
+    // CLI Tools
+    detectClaudeCodeCLI,
+    detectCodexCLI,
+    detectGeminiCLI,
+    detectOpenCodeCLI,
+    // Terminals
+    detectWarp
   ];
   const results = [];
   for (const detect of detectors) {
-    const ide = detect();
-    if (ide) {
-      results.push(ide);
+    try {
+      const ide = detect();
+      if (ide) {
+        results.push(ide);
+      }
+    } catch {
     }
   }
   return results;
 }
+async function detectCLITools() {
+  const all = await detectIDEs();
+  return all.filter((t) => t.toolType === "cli");
+}
+async function detectIDEApps() {
+  const all = await detectIDEs();
+  return all.filter((t) => t.toolType === "ide");
+}
+async function detectMCPNativeTools() {
+  const all = await detectIDEs();
+  return all.filter((t) => t.mcpSupport === "native");
+}
 
 // src/injectors/index.ts
-import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync } from "fs";
-import { dirname } from "path";
-function generateMCPConfig(projectPath) {
-  const baseConfig = {
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync, chmodSync } from "fs";
+import { dirname, join as join2 } from "path";
+import { homedir as homedir2, platform as platform2 } from "os";
+function generateClaudeMCPConfig(_projectPath) {
+  return {
     command: "npx",
-    args: ["@contextos/mcp"]
+    args: ["-y", "@contextos/mcp"]
   };
-  if (projectPath) {
-    return {
-      ...baseConfig,
-      cwd: projectPath
-    };
-  }
-  return baseConfig;
 }
-async function injectClaude(ide, options) {
+function generateVSCodeMCPConfig(projectPath) {
+  return {
+    command: "npx @contextos/mcp",
+    cwd: projectPath || "${workspaceFolder}"
+  };
+}
+async function injectClaudeStyle(ide, options) {
   let config = {};
   if (existsSync2(ide.configPath)) {
     try {
@@ -171,7 +293,7 @@ async function injectClaude(ide, options) {
   }
   config.mcpServers = {
     ...mcpServers,
-    contextos: generateMCPConfig(options.projectPath)
+    contextos: generateClaudeMCPConfig(options.projectPath)
   };
   const configDir = dirname(ide.configPath);
   if (!existsSync2(configDir)) {
@@ -181,7 +303,7 @@ async function injectClaude(ide, options) {
   return {
     ide: ide.name,
     success: true,
-    message: "Configuration added successfully",
+    message: "MCP configuration added",
     configPath: ide.configPath
   };
 }
@@ -214,70 +336,343 @@ async function injectVSCodeStyle(ide, options) {
   }
   current[lastKey] = {
     ...servers,
-    contextos: {
-      command: "npx @contextos/mcp",
-      cwd: options.projectPath || "${workspaceFolder}"
-    }
+    contextos: generateVSCodeMCPConfig(options.projectPath)
   };
   const configDir = dirname(ide.configPath);
   if (!existsSync2(configDir)) {
     mkdirSync(configDir, { recursive: true });
   }
   writeFileSync(ide.configPath, JSON.stringify(config, null, 2));
+  const nextSteps = [];
+  if (ide.id === "vscode" && ide.mcpSupport === "extension") {
+    nextSteps.push("Install Continue.dev extension: code --install-extension continue.continue");
+  }
   return {
     ide: ide.name,
     success: true,
-    message: "Configuration added successfully",
-    configPath: ide.configPath
+    message: "MCP configuration added",
+    configPath: ide.configPath,
+    nextSteps: nextSteps.length > 0 ? nextSteps : void 0
   };
 }
-async function injectConfig(ide, options = {}) {
+function getWrapperDir() {
+  const os = platform2();
+  if (os === "win32") {
+    return join2(homedir2(), ".contextos", "bin");
+  }
+  return join2(homedir2(), ".local", "bin");
+}
+function generateWrapperScript(toolName, originalCommand) {
+  const os = platform2();
+  if (os === "win32") {
+    return `#!/usr/bin/env pwsh
+# ContextOS wrapper for ${toolName}
+# This script injects optimized context before running the tool
+
+$ErrorActionPreference = "SilentlyContinue"
+
+# Build context if in a ContextOS project
+$contextFile = ".contextos/cache/last-context.md"
+if (Test-Path ".contextos") {
+    # Refresh context
+    npx @contextos/mcp --build 2>$null | Out-Null
+}
+
+# Build system prompt with context
+$systemPrompt = ""
+if (Test-Path $contextFile) {
+    $systemPrompt = Get-Content $contextFile -Raw
+}
+
+# Run original command with context
+if ($systemPrompt) {
+    & ${originalCommand} @args --system-prompt $systemPrompt
+} else {
+    & ${originalCommand} @args
+}
+`;
+  } else {
+    return `#!/bin/bash
+# ContextOS wrapper for ${toolName}
+# This script injects optimized context before running the tool
+
+set -e
+
+# Build context if in a ContextOS project
+CONTEXT_FILE=".contextos/cache/last-context.md"
+if [ -d ".contextos" ]; then
+    # Refresh context silently
+    npx @contextos/mcp --build 2>/dev/null || true
+fi
+
+# Build system prompt with context
+SYSTEM_PROMPT=""
+if [ -f "$CONTEXT_FILE" ]; then
+    SYSTEM_PROMPT=$(cat "$CONTEXT_FILE")
+fi
+
+# Run original command with context
+if [ -n "$SYSTEM_PROMPT" ]; then
+    ${originalCommand} "$@" --system-prompt "$SYSTEM_PROMPT"
+else
+    ${originalCommand} "$@"
+fi
+`;
+  }
+}
+async function injectWrapper(ide, options) {
+  const wrapperDir = getWrapperDir();
+  const os = platform2();
+  const ext = os === "win32" ? ".ps1" : "";
+  let wrapperName = "";
+  let originalCommand = "";
   switch (ide.id) {
-    case "claude":
-      return injectClaude(ide, options);
-    case "cursor":
-    case "windsurf":
-    case "vscode":
     case "codex":
+      wrapperName = `codex-ctx${ext}`;
+      originalCommand = "codex";
+      break;
+    case "gemini-cli":
+      wrapperName = `gemini-ctx${ext}`;
+      originalCommand = "gemini";
+      break;
+    case "opencode":
+      wrapperName = `opencode-ctx${ext}`;
+      originalCommand = "opencode";
+      break;
+    default:
+      return {
+        ide: ide.name,
+        success: false,
+        message: `Wrapper not implemented for ${ide.id}`
+      };
+  }
+  const wrapperPath = join2(wrapperDir, wrapperName);
+  if (existsSync2(wrapperPath) && !options.force) {
+    return {
+      ide: ide.name,
+      success: false,
+      message: "Wrapper already exists (use --force to overwrite)"
+    };
+  }
+  if (!existsSync2(wrapperDir)) {
+    mkdirSync(wrapperDir, { recursive: true });
+  }
+  const script = generateWrapperScript(ide.name, originalCommand);
+  writeFileSync(wrapperPath, script);
+  if (os !== "win32") {
+    chmodSync(wrapperPath, "755");
+  }
+  const shellConfigFile = os === "win32" ? "PowerShell Profile" : "~/.bashrc or ~/.zshrc";
+  return {
+    ide: ide.name,
+    success: true,
+    message: `Wrapper script created: ${wrapperName}`,
+    configPath: wrapperPath,
+    nextSteps: [
+      `Add ${wrapperDir} to your PATH`,
+      `Update your ${shellConfigFile}`,
+      `Use '${wrapperName.replace(ext, "")}' instead of '${originalCommand}'`
+    ]
+  };
+}
+async function injectWarp(ide, _options) {
+  return {
+    ide: ide.name,
+    success: true,
+    message: "Warp integration guidance provided",
+    nextSteps: [
+      "Warp AI integration is experimental",
+      'Use shell hook: eval "$(npx @contextos/mcp --hook)"',
+      "Or run: ctx build before Warp AI commands"
+    ]
+  };
+}
+async function injectConfig(ide, options = {}) {
+  switch (ide.mcpSupport) {
+    case "native":
+      if (ide.mcpKey === "mcpServers") {
+        return injectClaudeStyle(ide, options);
+      } else {
+        return injectVSCodeStyle(ide, options);
+      }
+    case "wrapper":
+      if (ide.toolType === "terminal") {
+        return injectWarp(ide, options);
+      }
+      return injectWrapper(ide, options);
+    case "extension":
       return injectVSCodeStyle(ide, options);
     default:
       return {
         ide: ide.name,
         success: false,
-        message: `Unknown IDE: ${ide.id}`
+        message: `Unknown MCP support type: ${ide.mcpSupport}`
       };
   }
 }
+async function injectAll(ides, options = {}) {
+  const results = [];
+  for (const ide of ides) {
+    try {
+      const result = await injectConfig(ide, options);
+      results.push(result);
+    } catch (error) {
+      results.push({
+        ide: ide.name,
+        success: false,
+        message: error instanceof Error ? error.message : "Unknown error"
+      });
+    }
+  }
+  return results;
+}
+function generateShellHook() {
+  const os = platform2();
+  if (os === "win32") {
+    return `
+# ContextOS PowerShell Hook
+# Add to your $PROFILE
+
+function ctx-hook {
+    if (Test-Path ".contextos") {
+        npx @contextos/mcp --build 2>$null | Out-Null
+    }
+}
+
+# Auto-run on directory change
+$ExecutionContext.SessionState.InvokeCommand.PostCommandLookupAction = {
+    param($command)
+    if ($command -eq "cd" -or $command -eq "Set-Location") {
+        ctx-hook
+    }
+}
+`;
+  } else {
+    return `
+# ContextOS Shell Hook
+# Add to your ~/.bashrc or ~/.zshrc
+
+ctx_hook() {
+    if [ -d ".contextos" ]; then
+        npx @contextos/mcp --build 2>/dev/null &
+    fi
+}
+
+# For bash
+if [ -n "$BASH_VERSION" ]; then
+    PROMPT_COMMAND="ctx_hook;$PROMPT_COMMAND"
+fi
+
+# For zsh
+if [ -n "$ZSH_VERSION" ]; then
+    autoload -Uz add-zsh-hook
+    add-zsh-hook chpwd ctx_hook
+fi
+`;
+  }
+}
 
 // src/index.ts
 var program = new Command();
-program.name("contextos-setup").description("One-click ContextOS setup for all your IDEs").version("0.1.0");
-program.command("auto").description("Automatically detect and configure all IDEs").option("--dry-run", "Show what would be configured without making changes").option("--force", "Overwrite existing configurations").action(async (options) => {
-  console.log(chalk.cyan.bold("\n\u{1F680} ContextOS Auto Setup\n"));
-  const spinner = ora("Detecting installed IDEs...").start();
+function getToolTypeIcon(tool) {
+  switch (tool.toolType) {
+    case "ide":
+      return "\u{1F5A5}\uFE0F";
+    case "cli":
+      return "\u2328\uFE0F";
+    case "terminal":
+      return "\u{1F4BB}";
+    default:
+      return "\u{1F4E6}";
+  }
+}
+function getMCPSupportBadge(tool) {
+  switch (tool.mcpSupport) {
+    case "native":
+      return chalk.green("MCP");
+    case "wrapper":
+      return chalk.yellow("Wrapper");
+    case "extension":
+      return chalk.blue("Extension");
+    default:
+      return chalk.gray("Unknown");
+  }
+}
+function printToolList(tools) {
+  console.log();
+  console.log(chalk.gray("  Tool                    Type        MCP Support    Status"));
+  console.log(chalk.gray("  " + "\u2500".repeat(68)));
+  tools.forEach((tool) => {
+    const icon = getToolTypeIcon(tool);
+    const status = tool.hasExistingConfig ? chalk.yellow("Configured") : chalk.green("Ready");
+    const mcpBadge = getMCPSupportBadge(tool);
+    const typeLabel = tool.toolType.toUpperCase().padEnd(10);
+    console.log(`  ${icon} ${tool.name.padEnd(22)} ${typeLabel} ${mcpBadge.padEnd(20)} ${status}`);
+  });
+  console.log();
+}
+program.name("contextos-setup").description("One-click ContextOS setup for all your AI coding tools").version("0.2.0");
+program.command("auto").description("Automatically detect and configure all AI tools").option("--dry-run", "Show what would be configured without making changes").option("--force", "Overwrite existing configurations").option("--only-mcp", "Only configure tools with native MCP support").option("--only-cli", "Only configure CLI tools").option("--only-ide", "Only configure IDE apps").action(async (options) => {
+  console.log(chalk.cyan.bold("\n\u{1F680} ContextOS Universal Setup\n"));
+  const spinner = ora("Detecting AI coding tools...").start();
   try {
-    const ides = await detectIDEs();
-    if (ides.length === 0) {
-      spinner.warn("No supported IDEs detected");
-      console.log(chalk.gray("\nSupported IDEs: Claude Desktop, Cursor, Windsurf, VS Code\n"));
+    let tools;
+    if (options.onlyMcp) {
+      tools = await detectMCPNativeTools();
+    } else if (options.onlyCli) {
+      tools = await detectCLITools();
+    } else if (options.onlyIde) {
+      tools = await detectIDEApps();
+    } else {
+      tools = await detectIDEs();
+    }
+    if (tools.length === 0) {
+      spinner.warn("No supported AI tools detected");
+      console.log(chalk.gray("\nSupported tools:"));
+      console.log(chalk.gray("  IDEs: Claude Desktop, Cursor, Windsurf, VS Code, Kilo Code"));
+      console.log(chalk.gray("  CLI:  Claude Code, Codex, Gemini CLI, OpenCode"));
+      console.log(chalk.gray("  Terminal: Warp\n"));
       return;
     }
-    spinner.succeed(`Found ${ides.length} IDE(s)`);
-    console.log(chalk.gray("\nDetected IDEs:"));
-    ides.forEach((ide) => {
-      const status = ide.hasExistingConfig ? chalk.yellow("\u26A0 has config") : chalk.green("\u2713 ready");
-      console.log(`  ${ide.name} ${status}`);
-    });
+    spinner.succeed(`Found ${tools.length} AI tool(s)`);
+    const ides = tools.filter((t) => t.toolType === "ide");
+    const clis = tools.filter((t) => t.toolType === "cli");
+    const terminals = tools.filter((t) => t.toolType === "terminal");
+    if (ides.length > 0) {
+      console.log(chalk.cyan("\n\u{1F5A5}\uFE0F  IDEs:"));
+      ides.forEach((t) => {
+        const badge = getMCPSupportBadge(t);
+        const status = t.hasExistingConfig ? chalk.yellow("(configured)") : "";
+        console.log(`   ${t.name} ${badge} ${status}`);
+      });
+    }
+    if (clis.length > 0) {
+      console.log(chalk.cyan("\n\u2328\uFE0F  CLI Tools:"));
+      clis.forEach((t) => {
+        const badge = getMCPSupportBadge(t);
+        const status = t.hasExistingConfig ? chalk.yellow("(configured)") : "";
+        console.log(`   ${t.name} ${badge} ${status}`);
+      });
+    }
+    if (terminals.length > 0) {
+      console.log(chalk.cyan("\n\u{1F4BB} Terminals:"));
+      terminals.forEach((t) => {
+        const badge = getMCPSupportBadge(t);
+        const status = t.hasExistingConfig ? chalk.yellow("(configured)") : "";
+        console.log(`   ${t.name} ${badge} ${status}`);
+      });
+    }
     if (options.dryRun) {
       console.log(chalk.yellow("\n[Dry Run] Would configure:"));
-      ides.forEach((ide) => console.log(`  - ${ide.name}`));
+      tools.forEach((t) => console.log(`  - ${t.name} (${t.mcpSupport})`));
       return;
     }
+    console.log();
     const { proceed } = await inquirer.prompt([
       {
         type: "confirm",
         name: "proceed",
-        message: "Configure ContextOS for these IDEs?",
+        message: "Configure ContextOS for these tools?",
         default: true
       }
     ]);
@@ -286,75 +681,84 @@ program.command("auto").description("Automatically detect and configure all IDEs
       return;
     }
     console.log();
-    const results = [];
-    for (const ide of ides) {
-      const configSpinner = ora(`Configuring ${ide.name}...`).start();
-      try {
-        const result = await injectConfig(ide, { force: options.force });
-        results.push(result);
-        if (result.success) {
-          configSpinner.succeed(`${ide.name} configured`);
-        } else {
-          configSpinner.warn(`${ide.name}: ${result.message}`);
+    const results = await injectAll(tools, { force: options.force });
+    for (const result of results) {
+      if (result.success) {
+        console.log(chalk.green(`  \u2713 ${result.ide}: ${result.message}`));
+        if (result.nextSteps && result.nextSteps.length > 0) {
+          result.nextSteps.forEach((step) => {
+            console.log(chalk.gray(`      \u2192 ${step}`));
+          });
         }
-      } catch (error) {
-        configSpinner.fail(`${ide.name} failed`);
-        results.push({
-          ide: ide.name,
-          success: false,
-          message: error instanceof Error ? error.message : "Unknown error"
-        });
+      } else {
+        console.log(chalk.yellow(`  \u26A0 ${result.ide}: ${result.message}`));
       }
     }
     const successful = results.filter((r) => r.success).length;
+    const native = results.filter((r) => r.success && !r.nextSteps).length;
+    const needsSteps = results.filter((r) => r.success && r.nextSteps).length;
     console.log(chalk.green(`
-\u2705 Setup complete: ${successful}/${ides.length} IDEs configured
-`));
-    if (successful > 0) {
-      console.log(chalk.cyan("Next steps:"));
-      console.log("  1. Restart your IDE(s)");
-      console.log("  2. Open a project folder");
-      console.log("  3. ContextOS will be available in your AI assistant!\n");
+\u2705 Setup complete: ${successful}/${tools.length} tools configured`));
+    if (native > 0) {
+      console.log(chalk.cyan(`   ${native} tools are ready to use`));
+    }
+    if (needsSteps > 0) {
+      console.log(chalk.yellow(`   ${needsSteps} tools need additional steps (see above)`));
     }
+    console.log(chalk.cyan("\n\u{1F4CB} Next steps:"));
+    console.log("  1. Restart your IDE(s) and terminal(s)");
+    console.log("  2. Navigate to a project: cd your-project");
+    console.log("  3. Initialize ContextOS: npx @contextos/cli init");
+    console.log("  4. Start using AI with optimized context!\n");
   } catch (error) {
     spinner.fail("Setup failed");
     console.error(chalk.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 });
-program.command("list").description("List detected IDEs and their status").action(async () => {
-  console.log(chalk.cyan.bold("\n\u{1F50D} Detected IDEs\n"));
-  const spinner = ora("Scanning...").start();
-  const ides = await detectIDEs();
+program.command("list").description("List all detected AI tools and their status").option("--json", "Output as JSON").action(async (options) => {
+  const spinner = ora("Scanning for AI tools...").start();
+  const tools = await detectIDEs();
   spinner.stop();
-  if (ides.length === 0) {
-    console.log(chalk.yellow("No supported IDEs found.\n"));
-    console.log(chalk.gray("Supported: Claude Desktop, Cursor, Windsurf, VS Code\n"));
+  if (options.json) {
+    console.log(JSON.stringify(tools, null, 2));
     return;
   }
-  console.log(chalk.gray("IDE                     Status              Config Path"));
-  console.log(chalk.gray("\u2500".repeat(70)));
-  ides.forEach((ide) => {
-    const status = ide.hasExistingConfig ? chalk.yellow("Configured") : chalk.green("Ready");
-    const configPath = ide.configPath.length > 35 ? "..." + ide.configPath.slice(-32) : ide.configPath;
-    console.log(`${ide.name.padEnd(24)}${status.padEnd(20)}${chalk.gray(configPath)}`);
-  });
-  console.log();
+  console.log(chalk.cyan.bold("\n\u{1F50D} Detected AI Tools\n"));
+  if (tools.length === 0) {
+    console.log(chalk.yellow("No AI tools found.\n"));
+    console.log(chalk.gray("Supported tools:"));
+    console.log(chalk.gray("  IDEs: Claude Desktop, Cursor, Windsurf, VS Code, Kilo Code"));
+    console.log(chalk.gray("  CLI:  Claude Code, Codex, Gemini CLI, OpenCode"));
+    console.log(chalk.gray("  Terminal: Warp\n"));
+    return;
+  }
+  printToolList(tools);
 });
-program.command("configure <ide>").description("Configure a specific IDE (claude, cursor, windsurf, vscode)").option("--force", "Overwrite existing configuration").action(async (ideName, options) => {
-  const ides = await detectIDEs();
-  const ide = ides.find((i) => i.id === ideName.toLowerCase());
-  if (!ide) {
+program.command("configure <tool>").description("Configure a specific tool").option("--force", "Overwrite existing configuration").action(async (toolName, options) => {
+  const tools = await detectIDEs();
+  const tool = tools.find(
+    (t) => t.id === toolName.toLowerCase() || t.name.toLowerCase().includes(toolName.toLowerCase())
+  );
+  if (!tool) {
     console.log(chalk.red(`
-IDE not found: ${ideName}`));
-    console.log(chalk.gray("Available: claude, cursor, windsurf, vscode\n"));
+\u274C Tool not found: ${toolName}`));
+    console.log(chalk.gray("\nAvailable tools:"));
+    tools.forEach((t) => console.log(`  - ${t.id} (${t.name})`));
+    console.log();
     process.exit(1);
   }
-  const spinner = ora(`Configuring ${ide.name}...`).start();
+  const spinner = ora(`Configuring ${tool.name}...`).start();
   try {
-    const result = await injectConfig(ide, { force: options.force });
+    const result = await injectConfig(tool, { force: options.force });
     if (result.success) {
-      spinner.succeed(result.message);
+      spinner.succeed(`${tool.name}: ${result.message}`);
+      if (result.nextSteps) {
+        console.log(chalk.cyan("\nNext steps:"));
+        result.nextSteps.forEach((step, i) => {
+          console.log(`  ${i + 1}. ${step}`);
+        });
+      }
     } else {
       spinner.warn(result.message);
     }
@@ -362,13 +766,25 @@ IDE not found: ${ideName}`));
     spinner.fail(error instanceof Error ? error.message : "Failed");
     process.exit(1);
   }
+  console.log();
+});
+program.command("hook").description("Generate shell hook for automatic context updates").option("--install", "Automatically install hook to shell config").action(async (options) => {
+  const hook = generateShellHook();
+  if (options.install) {
+    console.log(chalk.yellow("Auto-install not yet implemented.\n"));
+    console.log(chalk.cyan("Add this to your shell config:\n"));
+  } else {
+    console.log(chalk.cyan.bold("\n\u{1FA9D} ContextOS Shell Hook\n"));
+    console.log(chalk.gray("Add this to your ~/.bashrc, ~/.zshrc, or PowerShell $PROFILE:\n"));
+  }
+  console.log(hook);
 });
-program.command("uninstall").description("Remove ContextOS from all configured IDEs").action(async () => {
+program.command("uninstall").description("Remove ContextOS from all configured tools").action(async () => {
   const { confirm } = await inquirer.prompt([
     {
       type: "confirm",
       name: "confirm",
-      message: "Remove ContextOS configuration from all IDEs?",
+      message: "Remove ContextOS configuration from all tools?",
       default: false
     }
   ]);
@@ -376,12 +792,32 @@ program.command("uninstall").description("Remove ContextOS from all configured I
     console.log(chalk.gray("Cancelled.\n"));
     return;
   }
-  const ides = await detectIDEs();
-  for (const ide of ides) {
-    if (ide.hasExistingConfig) {
-      console.log(chalk.yellow(`Would remove from ${ide.name}`));
-    }
+  const tools = await detectIDEs();
+  const configured = tools.filter((t) => t.hasExistingConfig);
+  if (configured.length === 0) {
+    console.log(chalk.gray("No configured tools found.\n"));
+    return;
+  }
+  console.log(chalk.yellow("\nRemoving ContextOS configuration...\n"));
+  for (const tool of configured) {
+    console.log(chalk.gray(`  Would remove from ${tool.name}`));
+  }
+  console.log(chalk.yellow("\nNote: Removal not yet fully implemented.\n"));
+});
+program.command("status").description("Show ContextOS integration status").action(async () => {
+  console.log(chalk.cyan.bold("\n\u{1F4CA} ContextOS Integration Status\n"));
+  const tools = await detectIDEs();
+  const configured = tools.filter((t) => t.hasExistingConfig);
+  const mcpNative = tools.filter((t) => t.mcpSupport === "native");
+  const needsWrapper = tools.filter((t) => t.mcpSupport === "wrapper");
+  console.log(`  Total tools detected:    ${chalk.bold(tools.length)}`);
+  console.log(`  Already configured:      ${chalk.green(configured.length)}`);
+  console.log(`  MCP Native support:      ${chalk.cyan(mcpNative.length)}`);
+  console.log(`  Need wrapper scripts:    ${chalk.yellow(needsWrapper.length)}`);
+  if (tools.length > 0) {
+    printToolList(tools);
   }
+  console.log(chalk.gray('Run "npx @contextos/setup" to configure all tools.\n'));
 });
 program.action(async () => {
   await program.commands.find((c) => c.name() === "auto")?.parseAsync(process.argv);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@contextos/setup",
-  "version": "0.1.0",
-  "description": "One-click setup for ContextOS - automatically configure all your IDEs",
+  "version": "0.2.1",
+  "description": "Universal setup for ContextOS - one command to configure all AI coding tools (Claude, Cursor, Codex, Gemini, Windsurf, VS Code, Kilo Code, Warp)",
   "type": "module",
   "bin": {
     "contextos-setup": "./dist/index.js"
@@ -30,10 +30,18 @@
     "setup",
     "mcp",
     "claude",
+    "claude-code",
     "cursor",
     "windsurf",
+    "vscode",
+    "codex",
+    "gemini",
+    "opencode",
+    "warp",
+    "kilocode",
     "ai",
-    "coding"
+    "coding",
+    "context"
   ],
   "scripts": {
     "build": "tsup src/index.ts --format esm --clean",