@regression-io/claude-config 0.14.16

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 regression.io
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,286 @@
+# Claude Config
+
+Configuration management for **Claude Code** with CLI and optional Web UI.
+
+## Installation
+
+```bash
+npm install -g @regression-io/claude-config
+```
+
+Or from GitHub:
+```bash
+npm install -g github:regression-io/claude-config
+```
+
+## Quick Start
+
+```bash
+# Initialize a project with a template
+claude-config init --template fastapi
+
+# Add MCPs to your project
+claude-config add postgres github
+
+# Generate .mcp.json for Claude Code
+claude-config apply
+
+# Or open the Web UI
+claude-config ui
+```
+
+## CLI Commands
+
+### Project Commands
+
+```bash
+claude-config init [--template <name>]   # Initialize project
+claude-config apply                       # Generate .mcp.json from config
+claude-config apply-template <name>       # Add template to existing project
+claude-config show                        # Show current project config
+claude-config list                        # List available MCPs (✓ = active)
+claude-config templates                   # List available templates
+claude-config add <mcp> [mcp...]          # Add MCP(s) to project
+claude-config remove <mcp> [mcp...]       # Remove MCP(s) from project
+```
+
+### Memory Commands
+
+```bash
+claude-config memory                         # Show memory status
+claude-config memory init                    # Initialize project memory
+claude-config memory add <type> "<content>"  # Add entry
+claude-config memory search <query>          # Search all memory
+
+# Types: preference, correction, fact (global)
+#        context, pattern, decision, issue, history (project)
+```
+
+### Environment Commands
+
+```bash
+claude-config env                    # List environment variables
+claude-config env set <KEY> <value>  # Set variable in .claude/.env
+claude-config env unset <KEY>        # Remove variable
+```
+
+### Project Commands
+
+```bash
+claude-config project                      # List registered projects
+claude-config project add [path]           # Add project (defaults to cwd)
+claude-config project add [path] --name X  # Add with custom display name
+claude-config project remove <name|path>   # Remove from registry
+```
+
+### Registry Commands
+
+```bash
+claude-config registry-add <name> '<json>'   # Add MCP to global registry
+claude-config registry-remove <name>         # Remove MCP from registry
+```
+
+### Web UI
+
+```bash
+claude-config ui                    # Start UI on port 3333
+claude-config ui --port 8080        # Custom port
+claude-config ui /path/to/project   # Specific project directory
+claude-config ui --daemon           # Run as background daemon
+claude-config ui status             # Check if daemon is running
+claude-config ui stop               # Stop the daemon
+```
+
+**Daemon Mode**: Run `claude-config ui --daemon` to start the UI as a background service.
+The UI runs from your home directory and persists across terminal sessions.
+Switch between registered projects using the dropdown in the header.
+
+## Templates
+
+Initialize projects with pre-configured rules and settings:
+
+```bash
+# List available templates
+claude-config templates
+
+# Frameworks
+claude-config init --template fastapi
+claude-config init --template react-ts
+claude-config init --template python-cli
+claude-config init --template mcp-python
+
+# Languages
+claude-config init --template python
+claude-config init --template typescript
+
+# Monorepos
+claude-config init --template fastapi-react-ts
+claude-config init --template fastapi-react-js
+```
+
+Add templates to existing projects:
+```bash
+claude-config apply-template python
+```
+
+## Shell Integration
+
+For auto-apply on directory change, add to `~/.zshrc`:
+
+```bash
+source /path/to/claude-config/shell/claude-config.zsh
+```
+
+This enables:
+- Auto-generates `.mcp.json` when entering a project with `.claude/mcps.json`
+- Tab completion for all commands
+
+## Configuration Hierarchy
+
+Settings merge from global to project:
+
+```
+~/.claude/mcps.json              # Global - applies everywhere
+~/projects/.claude/mcps.json     # Workspace - applies to projects here
+~/projects/my-app/.claude/       # Project - specific to this project
+```
+
+## Project Structure
+
+After `claude-config init`:
+
+```
+your-project/
+├── .claude/
+│   ├── mcps.json       # MCP configuration
+│   ├── settings.json   # Claude Code settings
+│   ├── rules/          # Project rules (*.md)
+│   └── commands/       # Custom commands (*.md)
+└── .mcp.json           # Generated - Claude Code reads this
+```
+
+## MCP Configuration
+
+`.claude/mcps.json`:
+
+```json
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/path"]
+    },
+    "github": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-github"],
+      "env": {
+        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
+      }
+    }
+  }
+}
+```
+
+Environment variables use `${VAR}` syntax and load from `.claude/.env`.
+
+## Memory System
+
+Persistent memory for Claude Code sessions:
+
+**Global Memory** (`~/.claude/memory/`):
+- `preferences.md` - User preferences (tools, style)
+- `corrections.md` - Mistakes to avoid
+- `facts.md` - Environment facts
+
+**Project Memory** (`<project>/.claude/memory/`):
+- `context.md` - Project overview
+- `patterns.md` - Code patterns
+- `decisions.md` - Architecture decisions
+- `issues.md` - Known issues
+- `history.md` - Session history
+
+Manage via Web UI or edit files directly.
+
+## Web UI Features
+
+When you run `claude-config ui`:
+
+- **Project Switcher** - Switch between registered projects from header dropdown
+- **File Explorer** - Browse/edit all .claude folders in hierarchy
+- **MCP Registry** - Search GitHub/npm, add/edit/delete MCPs
+- **Claude Code Settings** - Visual editor for `~/.claude/settings.json`
+  - Permissions (allow/ask/deny rules)
+  - Model selection
+  - Behavior settings
+  - Hooks and advanced options
+- **Memory System** - Manage preferences, corrections, patterns, decisions
+- **Templates** - Apply rule templates to projects
+- **Preferences** - Configure claude-config tool settings
+- **One-Click Updates** - Update badge appears when new version available
+
+## Claude Code Settings
+
+The Web UI provides a visual editor for `~/.claude/settings.json`:
+
+### Permissions
+Configure what Claude Code can do automatically:
+- **Allow** - Tools that run without asking
+- **Ask** - Tools that require confirmation
+- **Deny** - Tools that are blocked
+
+Pattern examples:
+```
+Bash(npm run build)      # Specific command
+Bash(npm:*)              # Prefix match (npm anything)
+Read(**)                 # All file reads
+Edit(src/**)             # Edit files in src/
+mcp__github__*           # All GitHub MCP tools
+```
+
+### Model Selection
+Choose your preferred Claude model (Sonnet 4, Opus 4.5, etc.)
+
+### Behavior
+- Auto-accept edits
+- Verbose mode
+- Enable/disable MCP servers
+
+## Preferences
+
+User settings stored in `~/.claude-config/config.json`:
+
+```json
+{
+  "toolsDir": "~/mcp-tools",
+  "registryPath": "~/.claude/registry.json",
+  "ui": {
+    "port": 3333,
+    "openBrowser": true
+  }
+}
+```
+
+| Key | Description |
+|-----|-------------|
+| `toolsDir` | Directory for local MCP tools |
+| `registryPath` | Path to custom MCP registry |
+| `ui.port` | Default port for web UI |
+| `ui.openBrowser` | Auto-open browser on `claude-config ui` |
+
+## Requirements
+
+- Node.js 18+
+
+## Development
+
+```bash
+git clone https://github.com/regression-io/claude-config.git
+cd claude-config
+npm install
+npm run build
+npm start
+```
+
+## License
+
+MIT

package/cli.js

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+
+/**
+ * Claude Config CLI
+ *
+ * Configuration management for Claude Code
+ * CLI-first with optional Web UI
+ */
+
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const { spawn, execSync } = require('child_process');
+
+const args = process.argv.slice(2);
+const command = args[0] || '';
+
+// PID file for daemon mode
+const PID_FILE = path.join(os.homedir(), '.claude-config', 'ui.pid');
+
+// UI command needs special handling (starts web server with better error handling)
+if (command === 'ui' || command === 'web' || command === 'server') {
+  // Check for subcommand: ui stop, ui status
+  const subcommand = args[1];
+  if (subcommand === 'stop') {
+    stopDaemon();
+  } else if (subcommand === 'status') {
+    checkDaemonStatus();
+  } else {
+    startUI();
+  }
+} else {
+  // Pass everything to config-loader.js
+  const loaderPath = path.join(__dirname, 'config-loader.js');
+  const child = spawn('node', [loaderPath, ...args], {
+    stdio: 'inherit',
+    cwd: process.cwd()
+  });
+
+  child.on('close', (code) => {
+    process.exit(code || 0);
+  });
+}
+
+function stopDaemon() {
+  if (!fs.existsSync(PID_FILE)) {
+    console.log('No daemon running (PID file not found)');
+    return;
+  }
+
+  try {
+    const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim());
+    process.kill(pid, 'SIGTERM');
+    fs.unlinkSync(PID_FILE);
+    console.log(`Stopped daemon (PID: ${pid})`);
+  } catch (err) {
+    if (err.code === 'ESRCH') {
+      // Process doesn't exist, clean up PID file
+      fs.unlinkSync(PID_FILE);
+      console.log('Daemon was not running, cleaned up stale PID file');
+    } else {
+      console.error('Failed to stop daemon:', err.message);
+    }
+  }
+}
+
+function checkDaemonStatus() {
+  if (!fs.existsSync(PID_FILE)) {
+    console.log('Daemon: not running');
+    return;
+  }
+
+  try {
+    const pid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim());
+    // Check if process is running
+    process.kill(pid, 0);
+    console.log(`Daemon: running (PID: ${pid})`);
+    console.log(`UI available at: http://localhost:3333`);
+  } catch (err) {
+    console.log('Daemon: not running (stale PID file)');
+    fs.unlinkSync(PID_FILE);
+  }
+}
+
+function startDaemon(flags) {
+  // Check if already running
+  if (fs.existsSync(PID_FILE)) {
+    try {
+      const existingPid = parseInt(fs.readFileSync(PID_FILE, 'utf8').trim());
+      process.kill(existingPid, 0);
+      console.log(`Daemon already running (PID: ${existingPid})`);
+      console.log(`UI available at: http://localhost:${flags.port}`);
+      console.log('Use "claude-config ui stop" to stop the daemon');
+      return;
+    } catch (err) {
+      // Process not running, clean up stale PID file
+      fs.unlinkSync(PID_FILE);
+    }
+  }
+
+  // Ensure PID directory exists
+  const pidDir = path.dirname(PID_FILE);
+  if (!fs.existsSync(pidDir)) {
+    fs.mkdirSync(pidDir, { recursive: true });
+  }
+
+  // Log file for daemon output
+  const logFile = path.join(pidDir, 'ui.log');
+
+  // Build args for spawned process (without --daemon flag)
+  const spawnArgs = ['ui'];
+  if (flags.port !== 3333) {
+    spawnArgs.push('--port', String(flags.port));
+  }
+  if (flags.dir) {
+    spawnArgs.push('--dir', flags.dir);
+  }
+
+  // Spawn detached process
+  const out = fs.openSync(logFile, 'a');
+  const err = fs.openSync(logFile, 'a');
+
+  const child = spawn(process.execPath, [__filename, ...spawnArgs], {
+    detached: true,
+    stdio: ['ignore', out, err],
+    cwd: os.homedir()
+  });
+
+  // Write PID file
+  fs.writeFileSync(PID_FILE, String(child.pid));
+
+  // Unref to allow parent to exit
+  child.unref();
+
+  console.log(`Started daemon (PID: ${child.pid})`);
+  console.log(`UI available at: http://localhost:${flags.port}`);
+  console.log(`Logs: ${logFile}`);
+  console.log('\nCommands:');
+  console.log('  claude-config ui status  - Check daemon status');
+  console.log('  claude-config ui stop    - Stop the daemon');
+}
+
+function startUI() {
+  // Parse UI-specific flags
+  const flags = {
+    port: 3333,
+    dir: null, // Will default to active project or home
+    daemon: false
+  };
+
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--port' || arg === '-p') {
+      const portArg = args[++i];
+      if (!portArg || isNaN(parseInt(portArg))) {
+        console.error('Error: --port requires a valid port number');
+        process.exit(1);
+      }
+      flags.port = parseInt(portArg);
+    } else if (arg.startsWith('--port=')) {
+      const portVal = parseInt(arg.split('=')[1]);
+      if (isNaN(portVal)) {
+        console.error('Error: --port requires a valid port number');
+        process.exit(1);
+      }
+      flags.port = portVal;
+    } else if (arg === '--dir' || arg === '-d') {
+      flags.dir = args[++i] || null;
+    } else if (arg.startsWith('--dir=')) {
+      flags.dir = arg.split('=')[1] || null;
+    } else if (arg === '--daemon' || arg === '-D') {
+      flags.daemon = true;
+    } else if (!arg.startsWith('-') && fs.existsSync(arg) && fs.statSync(arg).isDirectory()) {
+      flags.dir = arg;
+    }
+  }
+
+  // Daemon mode: spawn detached and exit
+  if (flags.daemon) {
+    return startDaemon(flags);
+  }
+
+  // Validate port range
+  if (flags.port < 1 || flags.port > 65535) {
+    console.error('Error: Port must be between 1 and 65535');
+    process.exit(1);
+  }
+
+  // Validate directory exists (if specified)
+  if (flags.dir) {
+    if (!fs.existsSync(flags.dir)) {
+      console.error(`Error: Directory not found: ${flags.dir}`);
+      process.exit(1);
+    }
+
+    if (!fs.statSync(flags.dir).isDirectory()) {
+      console.error(`Error: Not a directory: ${flags.dir}`);
+      process.exit(1);
+    }
+
+    flags.dir = path.resolve(flags.dir);
+  }
+  // If no dir specified, server will load from projects registry or use cwd
+
+  // Load dependencies
+  const serverPath = path.join(__dirname, 'ui', 'server.cjs');
+
+  if (!fs.existsSync(serverPath)) {
+    console.error('Error: UI server not found.');
+    console.error('The package may not be installed correctly.');
+    process.exit(1);
+  }
+
+  const distPath = path.join(__dirname, 'ui', 'dist');
+  if (!fs.existsSync(distPath)) {
+    console.error('Error: UI build not found.');
+    console.error('Run "npm run build" to build the UI first.');
+    process.exit(1);
+  }
+
+  let ConfigUIServer, ClaudeConfigManager;
+  try {
+    ConfigUIServer = require(serverPath);
+    ClaudeConfigManager = require('./config-loader.js');
+  } catch (err) {
+    console.error('Error: Failed to load dependencies');
+    console.error(err.message);
+    if (err.message.includes('node-pty')) {
+      console.error('\nThe terminal feature requires node-pty which failed to load.');
+      console.error('Try reinstalling: npm rebuild node-pty');
+    }
+    process.exit(1);
+  }
+
+  // Handle server errors
+  process.on('uncaughtException', (err) => {
+    if (err.code === 'EADDRINUSE') {
+      console.error(`\nError: Port ${flags.port} is already in use.`);
+      console.error(`Try a different port: claude-config ui --port ${flags.port + 1}`);
+      process.exit(1);
+    } else if (err.code === 'EACCES') {
+      console.error(`\nError: Permission denied for port ${flags.port}.`);
+      console.error('Ports below 1024 require elevated privileges.');
+      process.exit(1);
+    } else {
+      console.error('\nUnexpected error:', err.message);
+      process.exit(1);
+    }
+  });
+
+  try {
+    const manager = new ClaudeConfigManager();
+    const server = new ConfigUIServer(flags.port, flags.dir, manager);
+    server.start();
+  } catch (err) {
+    console.error('Error: Failed to start server');
+    console.error(err.message);
+    process.exit(1);
+  }
+}