@regression-io/claude-config 0.14.16

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@regression-io/claude-config",
+  "version": "0.14.16",
+  "description": "Configuration management UI for Claude Code - manage MCPs, rules, commands, memory, and .claude folders",
+  "author": "regression.io",
+  "main": "config-loader.js",
+  "type": "commonjs",
+  "bin": {
+    "claude-config": "cli.js"
+  },
+  "scripts": {
+    "start": "node cli.js ui",
+    "display": "node cli.js display",
+    "ui": "node cli.js ui",
+    "ui:dev": "cd ui && npm run dev",
+    "ui:build": "cd ui && npm run build",
+    "version:sync": "node scripts/sync-version.js",
+    "version:bump": "node scripts/sync-version.js --bump",
+    "build": "npm run version:bump && cd ui && npm install && npm run build",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node scripts/postinstall.js",
+    "test": "node --test test/*.test.js"
+  },
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "configuration",
+    "mcp",
+    "model-context-protocol",
+    "project-management",
+    "cli"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "js-yaml": "^4.1.1",
+    "node-pty": "^1.1.0",
+    "ws": "^8.19.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/regression-io/claude-config.git"
+  },
+  "bugs": {
+    "url": "https://github.com/regression-io/claude-config/issues"
+  },
+  "homepage": "https://github.com/regression-io/claude-config#readme",
+  "files": [
+    "cli.js",
+    "config-loader.js",
+    "ui/server.cjs",
+    "ui/terminal-server.cjs",
+    "ui/dist/**",
+    "templates/**",
+    "shared/**",
+    "scripts/**",
+    "README.md"
+  ]
+}

package/scripts/postinstall.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+/**
+ * Post-install script for claude-config
+ * Sets up default configuration if not present
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const home = os.homedir();
+const claudeDir = path.join(home, '.claude');
+const configPath = path.join(claudeDir, 'config.json');
+
+// Default configuration
+const defaultConfig = {
+  toolsDir: path.join(home, 'mcp-tools'),
+  registryPath: path.join(claudeDir, 'registry.json'),
+  ui: {
+    port: 3333,
+    openBrowser: true
+  }
+};
+
+// Create ~/.claude if it doesn't exist
+if (!fs.existsSync(claudeDir)) {
+  fs.mkdirSync(claudeDir, { recursive: true });
+  console.log('Created ~/.claude directory');
+}
+
+// Create config.json if it doesn't exist
+if (!fs.existsSync(configPath)) {
+  fs.writeFileSync(configPath, JSON.stringify(defaultConfig, null, 2) + '\n');
+  console.log('Created ~/.claude/config.json with defaults');
+  console.log(`  Tools directory: ${defaultConfig.toolsDir}`);
+}
+
+// Create default registry if it doesn't exist
+const registryPath = path.join(claudeDir, 'registry.json');
+if (!fs.existsSync(registryPath)) {
+  const defaultRegistry = {
+    mcpServers: {}
+  };
+  fs.writeFileSync(registryPath, JSON.stringify(defaultRegistry, null, 2) + '\n');
+  console.log('Created ~/.claude/registry.json');
+}
+
+console.log('\nClaude Config installed successfully!');
+console.log('Run "claude-config" to start the UI.\n');

package/scripts/sync-version.js

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+
+/**
+ * Sync version from package.json to all version locations
+ * This ensures version is consistent across the codebase
+ *
+ * Usage:
+ *   node sync-version.js           # Sync current version
+ *   node sync-version.js --bump    # Bump patch version then sync
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const rootDir = path.join(__dirname, '..');
+const packageJsonPath = path.join(rootDir, 'package.json');
+const configLoaderPath = path.join(rootDir, 'config-loader.js');
+const uiPackageJsonPath = path.join(rootDir, 'ui', 'package.json');
+
+// Read version from package.json (source of truth)
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+let version = packageJson.version;
+
+// Check for --bump flag
+const shouldBump = process.argv.includes('--bump');
+
+if (shouldBump) {
+  // Bump patch version
+  const parts = version.split('.');
+  parts[2] = parseInt(parts[2], 10) + 1;
+  version = parts.join('.');
+
+  // Update package.json with new version
+  packageJson.version = version;
+  fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', 'utf8');
+  console.log(`Bumped version: ${packageJson.version.replace(/\.\d+$/, `.${parseInt(parts[2]) - 1}`)} -> ${version}`);
+} else {
+  console.log(`Syncing version: ${version}`);
+}
+
+// Update config-loader.js
+let configLoader = fs.readFileSync(configLoaderPath, 'utf8');
+const versionRegex = /const VERSION = ['"][^'"]+['"]/;
+
+if (versionRegex.test(configLoader)) {
+  const oldVersion = configLoader.match(versionRegex)[0];
+  configLoader = configLoader.replace(versionRegex, `const VERSION = '${version}'`);
+  fs.writeFileSync(configLoaderPath, configLoader, 'utf8');
+  console.log(`  config-loader.js: ${oldVersion} -> const VERSION = '${version}'`);
+} else {
+  console.error('Warning: Could not find VERSION constant in config-loader.js');
+}
+
+// Update ui/package.json
+if (fs.existsSync(uiPackageJsonPath)) {
+  const uiPackageJson = JSON.parse(fs.readFileSync(uiPackageJsonPath, 'utf8'));
+  if (uiPackageJson.version !== version) {
+    const oldVersion = uiPackageJson.version;
+    uiPackageJson.version = version;
+    fs.writeFileSync(uiPackageJsonPath, JSON.stringify(uiPackageJson, null, 2) + '\n', 'utf8');
+    console.log(`  ui/package.json: ${oldVersion} -> ${version}`);
+  }
+}
+
+console.log('Version sync complete!');

package/shared/mcp-registry.json

@@ -0,0 +1,117 @@
+{
+  "mcpServers": {
+    "github": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-github"
+      ],
+      "env": {
+        "GITHUB_TOKEN": "${GITHUB_TOKEN}"
+      }
+    },
+    "gitlab": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-gitlab"
+      ],
+      "env": {
+        "GITLAB_TOKEN": "${GITLAB_TOKEN}",
+        "GITLAB_URL": "${GITLAB_URL}"
+      }
+    },
+    "slack": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-slack"
+      ],
+      "env": {
+        "SLACK_BOT_TOKEN": "${SLACK_BOT_TOKEN}",
+        "SLACK_TEAM_ID": "${SLACK_TEAM_ID}"
+      }
+    },
+    "postgres": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-postgres"
+      ],
+      "env": {
+        "DATABASE_URL": "${DATABASE_URL}"
+      }
+    },
+    "sqlite": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-sqlite"
+      ],
+      "env": {
+        "SQLITE_PATH": "${SQLITE_PATH}"
+      }
+    },
+    "filesystem": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-filesystem",
+        "./"
+      ]
+    },
+    "memory": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-memory"
+      ]
+    },
+    "puppeteer": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-puppeteer"
+      ]
+    },
+    "brave-search": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-brave-search"
+      ],
+      "env": {
+        "BRAVE_API_KEY": "${BRAVE_API_KEY}"
+      }
+    },
+    "fetch": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-fetch"
+      ]
+    },
+    "google-drive": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-google-drive"
+      ],
+      "env": {
+        "GOOGLE_DRIVE_CREDENTIALS": "${GOOGLE_DRIVE_CREDENTIALS}"
+      }
+    },
+    "aws-s3": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@modelcontextprotocol/server-aws-s3"
+      ],
+      "env": {
+        "AWS_ACCESS_KEY_ID": "${AWS_ACCESS_KEY_ID}",
+        "AWS_SECRET_ACCESS_KEY": "${AWS_SECRET_ACCESS_KEY}",
+        "AWS_REGION": "${AWS_REGION}"
+      }
+    }
+  }
+}

package/templates/composites/fastapi-react-js/rules/backend-python.md

@@ -0,0 +1,54 @@
+---
+globs: backend/**
+---
+# Python Rules (Backend)
+
+These rules apply to the FastAPI backend in `backend/`.
+
+## Style
+- Use 4 spaces for indentation
+- `snake_case` for functions/variables, `PascalCase` for classes
+- Type hints on all public functions
+- Google-style docstrings
+
+## Patterns
+```python
+# Use Pydantic for validation
+from pydantic import BaseModel
+
+class UserCreate(BaseModel):
+    name: str
+    email: EmailStr
+
+# Use dependency injection
+async def get_user(
+    user_id: int,
+    db: AsyncSession = Depends(get_db),
+) -> User:
+    ...
+
+# Async context managers for resources
+async with async_session() as session:
+    ...
+```
+
+## Project Structure
+```
+backend/
+├── src/api/
+│   ├── main.py           # FastAPI app
+│   ├── config.py         # Settings
+│   ├── dependencies.py   # DI
+│   ├── routers/          # Endpoints
+│   ├── models/           # SQLAlchemy
+│   ├── schemas/          # Pydantic
+│   └── services/         # Business logic
+├── tests/
+└── pyproject.toml
+```
+
+## Testing
+```bash
+cd backend
+pytest -v --cov=src
+```

package/templates/composites/fastapi-react-js/rules/frontend-react.md

@@ -0,0 +1,69 @@
+---
+globs: frontend/**
+---
+# React JavaScript Rules (Frontend)
+
+These rules apply to the React frontend in `frontend/`.
+
+## Style
+- Functional components only
+- `PascalCase` for components, `camelCase` for functions
+- PropTypes for runtime validation
+- Named exports preferred
+
+## Component Pattern
+```javascript
+import PropTypes from 'prop-types';
+
+export function UserCard({ user, onEdit }) {
+  return (
+    <div>
+      <h3>{user.name}</h3>
+      {onEdit && <button onClick={() => onEdit(user)}>Edit</button>}
+    </div>
+  );
+}
+
+UserCard.propTypes = {
+  user: PropTypes.shape({
+    id: PropTypes.number.isRequired,
+    name: PropTypes.string.isRequired,
+  }).isRequired,
+  onEdit: PropTypes.func,
+};
+```
+
+## Project Structure
+```
+frontend/
+├── src/
+│   ├── components/
+│   │   ├── ui/           # Reusable (Button, Input)
+│   │   └── features/     # Domain-specific
+│   ├── hooks/            # Custom hooks
+│   ├── pages/            # Route pages
+│   ├── services/         # API calls
+│   └── utils/
+├── package.json
+└── jsconfig.json
+```
+
+## API Integration
+```javascript
+/**
+ * @param {number} id
+ * @returns {Promise<import('../../shared/api-types').User>}
+ */
+async function fetchUser(id) {
+  const res = await fetch(`/api/users/${id}`);
+  if (!res.ok) throw new Error('Failed to fetch');
+  return res.json();
+}
+```
+
+## Testing
+```bash
+cd frontend
+npm run test
+npm run lint
+```

package/templates/composites/fastapi-react-js/rules/monorepo.md

@@ -0,0 +1,77 @@
+# FastAPI + React JavaScript Monorepo Rules
+
+## Project Structure
+```
+project/
+├── backend/                  # FastAPI Python
+│   ├── src/
+│   │   └── api/
+│   ├── tests/
+│   ├── pyproject.toml
+│   └── .env
+├── frontend/                 # React JavaScript
+│   ├── src/
+│   ├── package.json
+│   └── jsconfig.json
+├── shared/                   # Shared types via JSDoc
+│   └── api-types.js
+├── docker-compose.yml
+├── .claude/
+│   └── mcps.json
+└── CLAUDE.md
+```
+
+## Path-Scoped Rules
+This monorepo uses path-scoped rules:
+
+- `/backend/**` → Python + FastAPI rules
+- `/frontend/**` → JavaScript + React rules
+- `/**` → Universal rules
+
+## Shared Types (JSDoc)
+```javascript
+// shared/api-types.js
+/**
+ * @typedef {Object} User
+ * @property {number} id
+ * @property {string} name
+ * @property {string} email
+ * @property {string} createdAt
+ */
+
+/**
+ * @typedef {Object} CreateUserRequest
+ * @property {string} name
+ * @property {string} email
+ * @property {string} password
+ */
+
+/**
+ * @typedef {Object} ApiError
+ * @property {{code: string, message: string, details?: any}} error
+ */
+
+export {};
+```
+
+## Backend/Frontend Communication
+- Backend generates OpenAPI schema
+- Use PropTypes for runtime validation in React
+- Keep JSDoc types in sync with backend schemas
+- Consistent error handling format
+
+## Development Workflow
+```bash
+# Start both services
+docker-compose up
+
+# Or separately:
+cd backend && uvicorn src.api.main:app --reload
+cd frontend && npm run dev
+```
+
+## Testing Strategy
+- Backend: pytest
+- Frontend: Jest + Testing Library
+- E2E: Playwright
+- Manual API testing with Postman/httpie

package/templates/composites/fastapi-react-js/template.json

@@ -0,0 +1,7 @@
+{
+  "name": "fastapi-react-js",
+  "description": "FastAPI backend + React JavaScript frontend monorepo",
+  "includes": ["universal"],
+  "mcpDefaults": ["github", "filesystem", "postgres"],
+  "_note": "Uses path-scoped rules in backend-python.md and frontend-react.md"
+}

package/templates/composites/fastapi-react-ts/rules/backend-python.md

@@ -0,0 +1,54 @@
+---
+globs: backend/**
+---
+# Python Rules (Backend)
+
+These rules apply to the FastAPI backend in `backend/`.
+
+## Style
+- Use 4 spaces for indentation
+- `snake_case` for functions/variables, `PascalCase` for classes
+- Type hints on all public functions
+- Google-style docstrings
+
+## Patterns
+```python
+# Use Pydantic for validation
+from pydantic import BaseModel
+
+class UserCreate(BaseModel):
+    name: str
+    email: EmailStr
+
+# Use dependency injection
+async def get_user(
+    user_id: int,
+    db: AsyncSession = Depends(get_db),
+) -> User:
+    ...
+
+# Async context managers for resources
+async with async_session() as session:
+    ...
+```
+
+## Project Structure
+```
+backend/
+├── src/api/
+│   ├── main.py           # FastAPI app
+│   ├── config.py         # Settings
+│   ├── dependencies.py   # DI
+│   ├── routers/          # Endpoints
+│   ├── models/           # SQLAlchemy
+│   ├── schemas/          # Pydantic
+│   └── services/         # Business logic
+├── tests/
+└── pyproject.toml
+```
+
+## Testing
+```bash
+cd backend
+pytest -v --cov=src
+```

package/templates/composites/fastapi-react-ts/rules/frontend-react.md

@@ -0,0 +1,64 @@
+---
+globs: frontend/**
+---
+# React TypeScript Rules (Frontend)
+
+These rules apply to the React frontend in `frontend/`.
+
+## Style
+- Functional components only
+- `PascalCase` for components, `camelCase` for functions
+- Explicit TypeScript types for props
+- Named exports preferred
+
+## Component Pattern
+```typescript
+interface UserCardProps {
+  user: User;
+  onEdit?: (user: User) => void;
+}
+
+export function UserCard({ user, onEdit }: UserCardProps) {
+  return (
+    <div>
+      <h3>{user.name}</h3>
+      {onEdit && <button onClick={() => onEdit(user)}>Edit</button>}
+    </div>
+  );
+}
+```
+
+## Project Structure
+```
+frontend/
+├── src/
+│   ├── components/
+│   │   ├── ui/           # Reusable (Button, Input)
+│   │   └── features/     # Domain-specific
+│   ├── hooks/            # Custom hooks
+│   ├── pages/            # Route pages
+│   ├── services/         # API calls
+│   ├── types/            # TypeScript types
+│   └── utils/
+├── package.json
+└── tsconfig.json
+```
+
+## API Integration
+```typescript
+// Use shared types from ../shared/
+import type { User, ApiError } from '../../shared/api-types';
+
+async function fetchUser(id: number): Promise<User> {
+  const res = await fetch(`/api/users/${id}`);
+  if (!res.ok) throw new Error('Failed to fetch');
+  return res.json();
+}
+```
+
+## Testing
+```bash
+cd frontend
+npm run test
+npm run typecheck
+```

package/templates/composites/fastapi-react-ts/rules/monorepo.md

@@ -0,0 +1,82 @@
+# FastAPI + React TypeScript Monorepo Rules
+
+## Project Structure
+```
+project/
+├── backend/                  # FastAPI Python
+│   ├── src/
+│   │   └── api/
+│   ├── tests/
+│   ├── pyproject.toml
+│   └── .env
+├── frontend/                 # React TypeScript
+│   ├── src/
+│   ├── package.json
+│   └── tsconfig.json
+├── shared/                   # Shared types/contracts
+│   └── api-types.ts
+├── docker-compose.yml
+├── .claude/
+│   └── mcps.json
+└── CLAUDE.md
+```
+
+## Path-Scoped Rules
+This monorepo uses path-scoped rules. Rules apply to specific directories:
+
+- `/backend/**` → Python + FastAPI rules
+- `/frontend/**` → TypeScript + React rules
+- `/**` → Universal rules
+
+## API Contract
+```typescript
+// shared/api-types.ts
+// Generate from FastAPI OpenAPI schema
+// or define manually and share
+
+export interface User {
+  id: number;
+  name: string;
+  email: string;
+  createdAt: string;
+}
+
+export interface CreateUserRequest {
+  name: string;
+  email: string;
+  password: string;
+}
+
+export interface ApiError {
+  error: {
+    code: string;
+    message: string;
+    details?: unknown;
+  };
+}
+```
+
+## Backend/Frontend Communication
+- Backend generates OpenAPI schema: `GET /openapi.json`
+- Frontend can use generated types from OpenAPI
+- Keep shared types in sync
+- Use consistent error format
+
+## Development Workflow
+```bash
+# Start both services
+docker-compose up
+
+# Or separately:
+# Backend
+cd backend && uvicorn src.api.main:app --reload
+
+# Frontend
+cd frontend && npm run dev
+```
+
+## Testing Strategy
+- Backend: pytest with TestClient
+- Frontend: Vitest + Testing Library
+- E2E: Playwright against both services
+- Contract tests: Verify API matches types