super-opencode 1.1.2 → 1.2.0

package/README.md

@@ -16,7 +16,7 @@ Super-OpenCode provides a structured framework for AI-assisted software developm
 
 ### Prerequisites
 
-- Node.js 18+ 
+- Node.js 18+
 - npm, pnpm, or yarn
 
 ### Quick Install
@@ -32,6 +32,7 @@ super-opencode
 ```
 
 The installer will guide you through:
+
 1. Choosing installation scope (global or project)
 2. Selecting components to install (agents, commands, skills, core)
 3. Configuring optional MCP servers (Context7, Serena, Tavily, etc.)
@@ -39,8 +40,15 @@ The installer will guide you through:
 ### Manual Install
 
 After npm install, the framework files will be available at:
-- **Global**: `~/.opencode/`
-- **Project**: `./opencode.json` in your project directory
+
+**Global Installation:**
+
+- **Linux/macOS**: `~/.config/opencode/`
+- **Windows**: `%APPDATA%\opencode\`
+
+**Project Installation:**
+
+- **All Platforms**: Files are copied to the current working directory under `.opencode/` and `AGENTS.md`
 
 ## Features
 
@@ -71,6 +79,7 @@ Reusable capabilities that agents can invoke:
 - **reflexion**: Post-action analysis and learning
 - **debug-protocol**: Root cause analysis workflow
 - **simplification**: Complexity reduction
+- **package-manager**: Multi-language package manager detection (npm, yarn, pnpm, poetry, cargo, and 40+ more)
 
 ### Slash Commands
 
@@ -91,11 +100,62 @@ Pre-built workflows for common tasks:
 - `/soc-improve` - Continuous improvement
 - `/soc-help` - Help and documentation
 
+### Package Manager Detection
+
+Super-OpenCode includes a powerful multi-language package manager detection system that automatically identifies the correct package manager for any project:
+
+**Supported Languages:** JavaScript/TypeScript, Python, Go, Rust, Java, Ruby, PHP, .NET, Elixir, Haskell, C/C++, Swift, Scala, Clojure, Julia, R
+
+**Quick Usage:**
+
+```bash
+# After installing super-opencode
+detect-pm
+
+# Or use directly from node_modules
+npx super-opencode detect-pm
+
+# Get JSON output for CI/CD
+detect-pm --json
+
+# Detect specific language
+detect-pm python
+detect-pm javascript
+```
+
+**Example Output:**
+
+```json
+{
+  "languages": [
+    {
+      "language": "javascript",
+      "package_manager": "pnpm",
+      "confidence": 95,
+      "commands": {
+        "install": "pnpm install --frozen-lockfile",
+        "add": "pnpm add"
+      }
+    }
+  ]
+}
+```
+
+**CI/CD Integration:**
+
+```yaml
+- name: Detect Package Manager
+  run: |
+    PM=$(npx detect-pm --recommend)
+    $PM install
+```
+
 ### MCP Server Integration
 
 The framework supports configuration of various MCP servers:
 
 **Recommended (Core)**:
+
 - Context7 - Official documentation lookup
 - Serena - Codebase analysis and navigation
 - Tavily Search - Web search for research
@@ -103,6 +163,7 @@ The framework supports configuration of various MCP servers:
 - Sequential Thinking - Multi-step reasoning
 
 **Optional**:
+
 - GitHub - GitHub API integration
 - SQLite - Database operations
 - Chrome DevTools - Browser debugging
@@ -146,21 +207,25 @@ super-opencode/
 ### Example Workflows
 
 #### Implement a Feature
+
 ```bash
 /soc-implement "User Authentication" --agent backend
 ```
 
 #### Design a System
+
 ```bash
 /soc-design "Microservices Architecture"
 ```
 
 #### Code Review
+
 ```bash
 /soc-review
 ```
 
 #### Research
+
 ```bash
 /soc-research "Best practices for React state management"
 ```
@@ -170,25 +235,30 @@ super-opencode/
 Super-OpenCode enforces a structured development approach:
 
 ### 1. Evidence-Based Development
+
 - Always verify with official sources
 - Use context7 MCP for documentation lookup
 - Check existing code before implementing
 - Never guess or make assumptions
 
 ### 2. Confidence-First Implementation
+
 - Check confidence before starting work
 - **≥90%**: Proceed with implementation
 - **70-89%**: Investigate more, present alternatives
 - **<70%**: STOP - ask questions, gather context
 
 ### 3. Parallel-First Execution
+
 - Use Wave → Checkpoint → Wave pattern
 - Batch read operations together
 - Analyze together before editing
 - 3.5x faster than sequential execution
 
 ### 4. Self-Correction Protocol
+
 When errors occur:
+
 1. STOP - Don't retry immediately
 2. INVESTIGATE - Research root cause
 3. HYPOTHESIZE - Form theory with evidence
@@ -200,44 +270,91 @@ When errors occur:
 
 ### OpenCode Configuration
 
-After installation, configuration is stored in:
-- **Global**: `~/.config/opencode/opencode.json`
-- **Project**: `./opencode.json`
+After installation, configuration is stored in platform-specific locations:
+
+**Global Configuration:**
+
+- **Linux**: `~/.config/opencode/opencode.json` (follows XDG Base Directory Specification)
+- **macOS**: `~/Library/Application Support/opencode/opencode.json`
+- **Windows**: `%APPDATA%\opencode\opencode.json` (typically `C:\Users\<username>\AppData\Roaming\opencode\opencode.json`)
+
+**Project Configuration:**
+
+- **All Platforms**: `./opencode.json` in your project root
+
+**Environment Variables:**
+
+- `OPENCODE_CONFIG_DIR`: Override the global config directory
+- `OPENCODE_CONFIG`: Override the full path to the config file
+- `OPENCODE_CONFIG_CONTENT`: Provide inline JSON configuration
+
+### Framework Installation Locations
+
+When installing Super-OpenCode globally:
+
+- **Linux**: `~/.config/opencode/` (follows XDG Base Directory Specification)
+- **macOS**: `~/.config/opencode/` (same as Linux for consistency with OpenCode)
+- **Windows**: `%APPDATA%\opencode\` (typically `C:\Users\<username>\AppData\Roaming\opencode\`)
+
+**Note**: Framework files (agents, commands, skills) are stored alongside the OpenCode config file for easy access.
+
+**Project Installation:**
+
+- **All Platforms**: Current working directory (where you run the installer)
 
 ### MCP Server Configuration
 
-MCP servers are configured in the `mcp` section of your config:
+MCP servers are configured in the `mcp` section of your config. According to the [OpenCode MCP documentation](https://opencode.ai/docs/mcp-servers):
 
 ```json
 {
+  "$schema": "https://opencode.ai/config.json",
   "mcp": {
     "context7": {
       "type": "local",
-      "command": ["npx", "-y", "@upstash/context7-mcp"]
+      "command": ["npx", "-y", "@upstash/context7-mcp"],
+      "enabled": true
     },
     "filesystem": {
       "type": "local",
-      "command": ["npx", "-y", "@modelcontextprotocol/server-filesystem", "/path/to/project"]
+      "command": [
+        "npx",
+        "-y",
+        "@modelcontextprotocol/server-filesystem",
+        "/path/to/project"
+      ]
+    },
+    "tavily": {
+      "type": "local",
+      "command": ["npx", "-y", "tavily-mcp@latest"],
+      "environment": {
+        "TAVILY_API_KEY": "your-api-key"
+      }
     }
   }
 }
 ```
 
+**Note**: MCP servers can be enabled/disabled per agent by modifying the agent configuration. For more details, see the [official OpenCode MCP docs](https://opencode.ai/docs/mcp-servers).
+
 ## Quality Standards
 
 ### Code Quality
+
 - All public functions require docstrings
 - Use type hints where supported
 - Follow existing project patterns
 - Include usage examples for complex functions
 
 ### Documentation Quality
+
 - Current with "Last Verified" dates
 - Minimal but necessary information
 - Clear with concrete examples
 - Practical and copy-paste ready
 
 ### Testing Standards
+
 - Write tests for new functionality
 - Aim for >80% code coverage
 - Include edge cases and error conditions

package/dist/cli.js

@@ -10,26 +10,80 @@ import ora from "ora";
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const FRAMEWORK_DIR = path.join(__dirname, "..");
-const MCP_KEY = "mcp";
-const MCP_SERVERS_KEY = "mcpServers";
-const CONFIG_FILENAME = "opencode.json";
-const FALLBACK_FILENAME = "mcp_settings.json";
 /**
- * Validates that a resolved path is within the allowed base directory
- * @throws Error if path traversal is detected
+ * Get the platform-specific global configuration directory for OpenCode
+ * Follows XDG Base Directory Specification on Linux, standard locations on macOS and Windows
  */
-function resolveSafePath(baseDir, targetPath) {
-    const resolvedBase = path.resolve(baseDir);
-    const resolvedTarget = path.resolve(targetPath);
-    // Normalize paths for cross-platform comparison
-    const normalizedBase = path.normalize(resolvedBase).toLowerCase();
-    const normalizedTarget = path.normalize(resolvedTarget).toLowerCase();
-    if (!normalizedTarget.startsWith(normalizedBase + path.sep) &&
-        normalizedTarget !== normalizedBase) {
-        throw new Error(`Path traversal detected: ${resolvedTarget} is outside ${resolvedBase}`);
+function getGlobalConfigDir() {
+    const platform = os.platform();
+    const homeDir = os.homedir();
+    // Check for OPENCODE_CONFIG_DIR environment variable first
+    const envConfigDir = process.env.OPENCODE_CONFIG_DIR;
+    if (envConfigDir) {
+        return path.resolve(envConfigDir);
+    }
+    if (platform === "win32") {
+        // Windows: %APPDATA%\opencode or %LOCALAPPDATA%\opencode
+        const appData = process.env.APPDATA || path.join(homeDir, "AppData", "Roaming");
+        return path.join(appData, "opencode");
+    }
+    else {
+        // macOS and Linux: use ~/.config/opencode per spec
+        const xdgConfigHome = process.env.XDG_CONFIG_HOME;
+        if (xdgConfigHome) {
+            return path.join(xdgConfigHome, "opencode");
+        }
+        // Default: ~/.config/opencode
+        return path.join(homeDir, ".config", "opencode");
     }
-    return resolvedTarget;
 }
+/**
+ * Get the framework installation directory
+ * Returns the appropriate directory based on installation scope
+ *
+ * Note: According to OpenCode spec, framework files (agents, skills, commands)
+ * should be in ~/.config/opencode/ alongside the opencode.json config file
+ */
+function getFrameworkInstallDir(scope) {
+    if (scope === "global") {
+        // For global installations, use the config directory (NOT data directory)
+        // This places agents/, skills/, commands/ alongside opencode.json
+        return getGlobalConfigDir();
+    }
+    // For project installations, use current working directory
+    return process.cwd();
+}
+/**
+ * Get the path to the opencode.json configuration file
+ */
+function getConfigFilePath(scope, targetDir) {
+    if (scope === "global") {
+        return path.join(getGlobalConfigDir(), CONFIG_FILENAME);
+    }
+    return path.join(targetDir, CONFIG_FILENAME);
+}
+/**
+ * Get the default allowed paths for Filesystem MCP based on platform
+ */
+function getDefaultFilesystemPaths(targetDir) {
+    const platform = os.platform();
+    const homeDir = os.homedir();
+    // Always include the target project directory
+    const paths = [targetDir];
+    if (platform === "win32") {
+        // Windows: include Documents folder and home
+        paths.push(path.join(homeDir, "Documents"));
+    }
+    else {
+        // Unix-like: include home directory
+        paths.push(homeDir);
+    }
+    return paths;
+}
+const MCP_KEY = "mcp";
+const MCP_SERVERS_KEY = "mcpServers";
+const CONFIG_FILENAME = "opencode.json";
+const FALLBACK_FILENAME = "mcp_settings.json";
 function sanitizePaths(pathInput) {
     const paths = pathInput
         .split(",")
@@ -152,8 +206,15 @@ function getMcpServerConfig(serverId, envVars, targetDir) {
     return configs[serverId];
 }
 async function copyFile(src, dest, targetDir, overwrite) {
-    const srcPath = resolveSafePath(FRAMEWORK_DIR, src);
-    const destPath = resolveSafePath(targetDir, dest);
+    const srcPath = path.join(FRAMEWORK_DIR, src);
+    const destPath = path.join(targetDir, dest);
+    // Only validate destination path (user-controlled)
+    const resolvedDest = path.resolve(destPath);
+    const resolvedTarget = path.resolve(targetDir);
+    if (!resolvedDest.startsWith(resolvedTarget + path.sep) &&
+        resolvedDest !== resolvedTarget) {
+        throw new Error(`Path traversal detected: ${resolvedDest} is outside ${resolvedTarget}`);
+    }
     if (await fs.pathExists(srcPath)) {
         try {
             await fs.copy(srcPath, destPath, { overwrite });
@@ -166,12 +227,17 @@ async function copyFile(src, dest, targetDir, overwrite) {
         }
     }
 }
-async function installModules(modules, targetDir, overwrite) {
+async function installModules(modules, targetDir, overwrite, scope) {
+    // For global installs, copy directly to targetDir/agents (no .opencode wrapper)
+    // For project installs, copy to targetDir/.opencode/agents
+    const agentsDest = scope === "global" ? "agents" : ".opencode/agents";
+    const commandsDest = scope === "global" ? "commands" : ".opencode/commands";
+    const skillsDest = scope === "global" ? "skills" : ".opencode/skills";
     const moduleMap = {
         core: ["README.md", "README.md"],
-        agents: [".opencode/agents", ".opencode/agents"],
-        commands: [".opencode/commands", ".opencode/commands"],
-        skills: [".opencode/skills", ".opencode/skills"],
+        agents: [".opencode/agents", agentsDest],
+        commands: [".opencode/commands", commandsDest],
+        skills: [".opencode/skills", skillsDest],
     };
     for (const module of modules) {
         const [src, dest] = moduleMap[module] || [];
@@ -181,7 +247,6 @@ async function installModules(modules, targetDir, overwrite) {
                 await fs.ensureDir(path.join(targetDir, ".opencode"));
                 await copyFile("AGENTS.md", "AGENTS.md", targetDir, overwrite);
                 await copyFile("LICENSE", "LICENSE", targetDir, overwrite);
-                await copyFile(".opencode/settings.json", ".opencode/settings.json", targetDir, overwrite);
             }
         }
     }
@@ -237,22 +302,43 @@ async function collectEnvVars(serverDef) {
     return envVars;
 }
 async function configureFilesystemMcp(targetDir) {
+    const defaultPaths = getDefaultFilesystemPaths(targetDir);
     const { allowedPaths: pathsInput } = await inquirer.prompt([
         {
             type: "input",
             name: "allowedPaths",
             message: "Enter absolute paths for Filesystem MCP (comma separated):",
-            default: targetDir,
+            default: defaultPaths.join(", "),
         },
     ]);
     const sanitizedPaths = sanitizePaths(pathsInput);
+    // Validate that paths exist and are accessible
+    const validPaths = [];
+    for (const p of sanitizedPaths) {
+        try {
+            const stats = await fs.stat(p);
+            if (stats.isDirectory()) {
+                validPaths.push(p);
+            }
+            else {
+                console.warn(chalk.yellow(`⚠️  Skipping non-directory path: ${p}`));
+            }
+        }
+        catch {
+            console.warn(chalk.yellow(`⚠️  Path does not exist or is not accessible: ${p}`));
+        }
+    }
+    if (validPaths.length === 0) {
+        console.warn(chalk.yellow("⚠️  No valid paths provided. Using target directory only."));
+        validPaths.push(targetDir);
+    }
     return {
         type: "local",
         command: [
             "npx",
             "-y",
             "@modelcontextprotocol/server-filesystem",
-            ...sanitizedPaths,
+            ...validPaths,
         ],
     };
 }
@@ -276,9 +362,7 @@ async function collectMcpServerConfigs(selectedServers, targetDir) {
     return mcpServers;
 }
 async function writeMcpConfiguration(mcpServers, scope, targetDir) {
-    const configPath = scope === "global"
-        ? path.join(os.homedir(), ".config", "opencode", CONFIG_FILENAME)
-        : path.join(targetDir, CONFIG_FILENAME);
+    const configPath = getConfigFilePath(scope, targetDir);
     let finalSettings = {};
     let writeTarget = configPath;
     if (scope === "global") {
@@ -325,26 +409,38 @@ async function handleMcpInstallation(scope, targetDir) {
 }
 async function main() {
     console.log(chalk.cyan.bold("\n🚀 Welcome to Super-OpenCode Installer\n"));
+    // Show platform info
+    const platform = os.platform();
+    const homeDir = os.homedir();
+    console.log(chalk.gray(`Platform: ${platform} | Home: ${homeDir}\n`));
+    // Display installation options info before selection
+    console.log(chalk.cyan("📦 Installation Options:\n"));
+    console.log(chalk.white("🌍 Global Install (Recommended)"));
+    console.log(chalk.gray(`   Framework: ${getGlobalConfigDir()}`));
+    console.log(chalk.gray(`   Config: ${path.join(getGlobalConfigDir(), "opencode.json")}`));
+    console.log(chalk.gray(`   Available for all projects\n`));
+    console.log(chalk.white("📁 Project Install (Current Directory)"));
+    console.log(chalk.gray(`   Framework: ${process.cwd()}`));
+    console.log(chalk.gray(`   Config: ${path.join(process.cwd(), "opencode.json")}`));
+    console.log(chalk.gray(`   Project-specific only\n`));
     const scopeAnswer = await inquirer.prompt([
         {
             type: "list",
             name: "scope",
             message: "Where would you like to install Super-OpenCode?",
             choices: [
-                { name: "Global (Recommended for User-wide access)", value: "global" },
-                { name: "Project (Current Directory)", value: "project" },
+                { name: "🌍 Global (Recommended)", value: "global" },
+                { name: "📁 Project (Current Directory)", value: "project" },
             ],
             default: "global",
         },
     ]);
-    const targetDir = scopeAnswer.scope === "global"
-        ? path.join(os.homedir(), ".opencode")
-        : process.cwd();
+    const targetDir = getFrameworkInstallDir(scopeAnswer.scope);
     const questions = [
         {
             type: "confirm",
             name: "proceed",
-            message: `Install Super-OpenCode to ${chalk.yellow(targetDir)}?`,
+            message: `\n📦 Ready to install to:\n   ${chalk.cyan(targetDir)}\n\n   ${chalk.gray("This will create:")}\n   ${chalk.gray("• Framework files (agents, commands, skills)")}\n   ${chalk.gray("• Configuration file (opencode.json)")}\n\nProceed with installation?`,
             default: true,
         },
         {
@@ -353,7 +449,7 @@ async function main() {
             message: "Select components to install:",
             choices: [
                 {
-                    name: "Core (README, LICENSE, AGENTS.md, settings.json)",
+                    name: "Core (README, LICENSE, AGENTS.md)",
                     value: "core",
                     checked: true,
                 },
@@ -375,6 +471,7 @@ async function main() {
             when: (answers) => answers.proceed,
         },
     ];
+    // biome-ignore lint/suspicious/noExplicitAny: inquirer types are complex, using any for compatibility
     const answers = await inquirer.prompt(questions);
     if (!answers.proceed) {
         console.log(chalk.yellow("Installation cancelled."));
@@ -383,19 +480,24 @@ async function main() {
     const spinner = ora("Installing Super-OpenCode...").start();
     try {
         const { modules, overwrite } = answers;
-        await installModules(modules, targetDir, overwrite);
+        await installModules(modules, targetDir, overwrite, scopeAnswer.scope);
         spinner.stop();
         await handleMcpInstallation(scopeAnswer.scope, targetDir);
         spinner.start();
         spinner.succeed(chalk.green("Installation complete!"));
-        console.log("\nNext steps:");
+        console.log(chalk.green.bold("\n✨ Installation Summary\n"));
+        console.log(chalk.white(`📦 Framework: ${chalk.cyan(targetDir)}`));
+        console.log(chalk.white(`⚙️  Config: ${chalk.cyan(getConfigFilePath(scopeAnswer.scope, targetDir))}\n`));
+        console.log(chalk.yellow.bold("Next Steps:\n"));
+        console.log(chalk.white("1. 📖 Read AGENTS.md for workflow guidelines"));
+        console.log(chalk.white("2. 🔧 Configure MCP servers if needed"));
+        console.log(chalk.white("3. 🚀 Start using: super-opencode --help\n"));
         if (scopeAnswer.scope === "global") {
-            console.log(chalk.white(`1. Framework installed to: ${chalk.cyan(targetDir)}`));
-            console.log(chalk.white(`2. Configuration updated at: ${chalk.cyan(path.join(os.homedir(), ".config", "opencode", "opencode.json"))}`));
+            console.log(chalk.gray("💡 The framework is now available globally"));
+            console.log(chalk.gray("   Use 'super-opencode' command from any project\n"));
         }
         else {
-            console.log(chalk.white("1. Read AGENTS.md to understand the workflow."));
-            console.log(chalk.white("2. Configuration updated in ./opencode.json"));
+            console.log(chalk.gray("💡 The framework is installed in the current project only\n"));
         }
     }
     catch (error) {

package/package.json

@@ -1,26 +1,21 @@
 {
   "name": "super-opencode",
-  "version": "1.1.2",
-  "description": "Super-OpenCode Framework Installer",
+  "version": "1.2.0",
+  "description": "Multi-language package manager detection and OpenCode agent framework. Auto-detects npm, yarn, pnpm, poetry, cargo, and 40+ package managers across 16 programming languages.",
   "type": "module",
   "main": "dist/cli.js",
   "bin": {
-    "super-opencode": "./dist/cli.js"
+    "super-opencode": "./dist/cli.js",
+    "detect-pm": "./.opencode/skills/package-manager/scripts/detect-package-manager.sh"
   },
   "files": [
     "dist",
     "AGENTS.md",
     ".opencode",
     "README.md",
-    "LICENSE"
+    "LICENSE",
+    "!.opencode/skills/package-manager/scripts/test*"
   ],
-  "scripts": {
-    "build": "tsc",
-    "lint": "biome check src/",
-    "format": "biome check --write src/",
-    "prepublishOnly": "npm run build",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
   "keywords": [
     "opencode",
     "agent",
@@ -29,6 +24,17 @@
   ],
   "author": "lst97",
   "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lst97/super-opencode.git"
+  },
+  "bugs": {
+    "url": "https://github.com/lst97/super-opencode/issues"
+  },
+  "homepage": "https://github.com/lst97/super-opencode#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "dependencies": {
     "chalk": "^5.6.2",
     "fs-extra": "^11.3.3",
@@ -41,5 +47,14 @@
     "@types/node": "^25.0.10",
     "ts-node": "^10.9.2",
     "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "build": "tsc",
+    "lint": "biome check src/",
+    "format": "biome check --write src/",
+    "validate": "npm run check-files && npm run check-scripts",
+    "check-files": "node -e \"console.log('Package files:', require('fs').readdirSync('.'))\"",
+    "check-scripts": "bash .opencode/skills/package-manager/scripts/detect-package-manager.sh --help > /dev/null && echo '✓ Package manager detection script works'",
+    "test": "echo 'Tests not implemented - validation only' && npm run validate"
   }
-}
+}

package/.opencode/settings.json

@@ -1,3 +0,0 @@
-{
-  "version": "1.1.0"
-}