hsh19900502 1.0.21 → 1.0.23

package/CLAUDE.md

@@ -47,7 +47,8 @@ src/
 ├── commands/
 │   ├── git.ts          # Git workflow commands (gcm, push, merge, mr, branchout)
 │   ├── mono.ts         # Monorepo management (init, cd)
-│   └── ide.ts          # IDE integration (cursor, surf)
+│   ├── ide.ts          # IDE integration (cursor, claude)
+│   └── mcp.ts          # MCP server synchronization
 ├── types/
 │   └── index.ts        # TypeScript type definitions
 └── util.ts             # Utility functions (package.json reading)
@@ -89,13 +90,20 @@ The CLI follows a modular command structure using Commander.js:
 ### IDE Integration
 
 - `cursor`: Open project in Cursor editor with config-based project selection
-- `surf`: Open project in Windsurf editor with config-based project selection
+
+### MCP Server Management
+
+- `mcp sync`: Synchronize MCP server configurations from `~/.mcp/servers.json` to all projects in `~/.claude.json`
+  - This addresses the limitation that Claude Code cannot install MCP servers globally
+  - Automatically updates all project configurations with centralized MCP server definitions
+  - Idempotent operation - safe to run multiple times
+  - Useful for maintaining consistent MCP configurations across multiple projects
 
 ## Configuration Requirements
 
 ### IDE Configuration
 
-The `cursor` and `surf` commands require a configuration file at `~/hsh.config.json`:
+The `cursor` and `claude` commands require a configuration file at `~/hsh.config.json`:
 
 ```json
 {
@@ -116,6 +124,34 @@ For monorepo commands, projects should have:
 - `.hsh` marker file in the root (created by `mono init`)
 - Directory structure: `<repo-name>/client/` and `<repo-name>/server/`
 
+### MCP Server Configuration
+
+MCP (Model Context Protocol) servers can be centrally managed:
+
+- Create `~/.mcp/servers.json` with your global MCP server configurations
+- Run `hsh mcp sync` to propagate configurations to all projects in `~/.claude.json`
+- Each project's `mcpServers` field will be updated with the latest configuration
+
+Example `~/.mcp/servers.json`:
+```json
+{
+  "chrome-devtools": {
+    "type": "stdio",
+    "command": "npx",
+    "args": ["chrome-devtools-mcp@latest"],
+    "env": {}
+  },
+  "GitLab communication server": {
+    "command": "npx",
+    "args": ["-y", "@zereight/mcp-gitlab"],
+    "env": {
+      "GITLAB_PERSONAL_ACCESS_TOKEN": "your-token",
+      "GITLAB_API_URL": "https://gitlab.example.com/api/v4"
+    }
+  }
+}
+```
+
 ## External Dependencies
 
 ### Required CLI Tools
@@ -123,7 +159,6 @@ For monorepo commands, projects should have:
 - **git**: For all git operations
 - **glab**: GitLab CLI for merge request creation (used in `mr create`)
 - **cursor**: Cursor editor executable (for `cursor` command)
-- **surf**: Windsurf editor executable (for `surf` command)
 
 ### Shell Integration
 

package/README.md

@@ -0,0 +1,158 @@
+# hsh - CLI Workflow Automation Tool
+
+A TypeScript-based CLI tool that provides Git workflow automation, IDE project management, and MCP server configuration synchronization.
+
+## Installation
+
+```bash
+yarn install
+yarn build:install
+```
+
+## Features
+
+### Git Workflow Automation
+- `hsh gcm <message> [--push]` - Add all, commit with message, optionally push
+- `hsh push` - Interactive branch selection for pushing to remote
+- `hsh merge <branch>` - Safe merge with branch switching and pulling
+- `hsh mr create` - Create merge requests with JIRA integration
+- `hsh branchout <branch>` - Create new branch from master
+
+### Monorepo Management
+- `hsh mono init` - Initialize workspace with `.hsh` marker file
+- `hsh mono cd <level> [--repo <name>]` - Navigate to repo directories (root/client/server)
+
+### IDE Integration
+- `hsh cursor` - Open project in Cursor editor with config-based project selection
+- `hsh claude` - Open project in Claude Code editor with config-based project selection
+
+### MCP Server Management
+
+**NEW!** Solve the problem of having to configure MCP servers individually for each project.
+
+#### The Problem
+Claude Code doesn't support global MCP server installation. You have to configure MCP servers in each project's `.claude.json` file individually, which is tedious and error-prone.
+
+#### The Solution
+`hsh mcp sync` - Synchronize MCP server configurations from a central location to all your projects
+
+#### How It Works
+
+1. Create a central MCP configuration file at `~/.mcp/servers.json`:
+
+```json
+{
+  "chrome-devtools": {
+    "type": "stdio",
+    "command": "npx",
+    "args": ["chrome-devtools-mcp@latest"],
+    "env": {}
+  },
+  "GitLab communication server": {
+    "command": "npx",
+    "args": ["-y", "@zereight/mcp-gitlab"],
+    "env": {
+      "GITLAB_PERSONAL_ACCESS_TOKEN": "your-token",
+      "GITLAB_API_URL": "https://gitlab.example.com/api/v4"
+    }
+  },
+  "jira": {
+    "command": "npx",
+    "args": ["-y", "@aashari/mcp-server-atlassian-jira"],
+    "env": {
+      "ATLASSIAN_SITE_NAME": "your-site",
+      "ATLASSIAN_USER_EMAIL": "your-email",
+      "ATLASSIAN_API_TOKEN": "your-token"
+    }
+  }
+}
+```
+
+2. Run the sync command:
+
+```bash
+hsh mcp sync
+```
+
+3. The command will:
+   - Read all MCP server configurations from `~/.mcp/servers.json`
+   - Update the `mcpServers` field for all projects in `~/.claude.json`
+   - Show you which servers were synced and how many projects were updated
+
+#### Features
+- ✅ Idempotent - Safe to run multiple times
+- ✅ Atomic updates - Updates all projects at once
+- ✅ Clear feedback - Shows which servers and projects were updated
+- ✅ Validation - Checks for file existence and valid JSON
+
+#### Example Output
+
+```bash
+$ hsh mcp sync
+✔ Successfully synced MCP servers to 21 projects
+
+MCP Servers synced:
+  • chrome-devtools
+  • Playwright
+  • figma-mcp
+  • GitLab communication server
+  • jira
+  • confluence
+
+Projects updated:
+  • /Users/you/project1
+  • /Users/you/project2
+  • /Users/you/project3
+  ... and 18 more
+```
+
+## Configuration
+
+### IDE Configuration
+Create `~/hsh.config.json` for IDE project management:
+
+```json
+{
+  "work": {
+    "project1": "/path/to/work/project1",
+    "project2": "/path/to/work/project2"
+  },
+  "personal": {
+    "project3": "/path/to/personal/project3"
+  }
+}
+```
+
+### Monorepo Setup
+For monorepo commands, projects should have:
+- `.hsh` marker file in the root (created by `hsh mono init`)
+- Directory structure: `<repo-name>/client/` and `<repo-name>/server/`
+
+## Development
+
+```bash
+# Install dependencies
+yarn install
+
+# Build the project
+yarn build
+
+# Build and install globally
+yarn build:install
+
+# Development mode
+yarn dev
+```
+
+## Requirements
+
+- Node.js with ES module support
+- Git
+- GitLab CLI (`glab`) for merge request features
+- Cursor editor (for `cursor` command)
+- Claude Code editor (for `claude` command)
+
+## License
+
+MIT
+

package/dist/commands/ide/index.d.ts

@@ -0,0 +1,2 @@
+import 'zx/globals';
+export declare const openIDE: (ideType: "cursor" | "claude", searchMode?: string) => Promise<void>;

package/dist/commands/ide/index.js

@@ -0,0 +1,161 @@
+import inquirer from 'inquirer';
+import 'zx/globals';
+import chalk from 'chalk';
+import inquirerAutocomplete from 'inquirer-autocomplete-prompt';
+import { readConfig } from '../../util.js';
+import { spawn } from 'child_process';
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', inquirerAutocomplete);
+let reposConfig;
+let currentCategory;
+async function loadConfig() {
+    const config = readConfig();
+    reposConfig = config.repos;
+}
+async function searchCategories(answers, input = '') {
+    if (!reposConfig) {
+        await loadConfig();
+    }
+    const categories = Object.keys(reposConfig);
+    if (!input) {
+        return categories;
+    }
+    return categories.filter(category => category.toLowerCase().includes(input.toLowerCase()));
+}
+async function searchProjects(answers, input = '') {
+    if (!reposConfig) {
+        await loadConfig();
+    }
+    // Get projects for the selected category
+    if (!currentCategory || !reposConfig[currentCategory]) {
+        return [];
+    }
+    const projects = Object.entries(reposConfig[currentCategory])
+        .map(([name, path]) => ({
+        name,
+        path,
+        display: `${name} (${path})`
+    }));
+    if (!input) {
+        return projects.map(p => p.name);
+    }
+    const searchTerm = input.toLowerCase();
+    return projects
+        .filter(project => project.name.toLowerCase().includes(searchTerm) ||
+        project.path.toLowerCase().includes(searchTerm))
+        .map(p => p.name);
+}
+// Flatten all projects with category context for fuzzy search
+function getAllProjects() {
+    if (!reposConfig)
+        return [];
+    return Object.entries(reposConfig).flatMap(([category, projects]) => Object.entries(projects).map(([name, path]) => ({
+        category,
+        name,
+        path,
+        display: `${name} (${category})`
+    })));
+}
+// Single-keyword fuzzy search across all projects
+async function searchAllProjects(answers, input = '') {
+    const allProjects = getAllProjects();
+    if (!input) {
+        return allProjects.map(p => ({ name: p.display, value: p }));
+    }
+    // Split input by spaces and filter projects matching ALL keywords
+    const keywords = input.toLowerCase().trim().split(/\s+/);
+    return allProjects
+        .filter(project => {
+        const searchText = `${project.name} ${project.category} ${project.path}`.toLowerCase();
+        // Check if all keywords are present in the search text
+        return keywords.every(keyword => searchText.includes(keyword));
+    })
+        .map(p => ({ name: p.display, value: p }));
+}
+// Select project using fuzzy search across all categories
+async function selectProjectWithFuzzySearch(searchMode) {
+    const answer = await inquirer.prompt([
+        {
+            type: 'autocomplete',
+            name: 'project',
+            message: `Search and select a project${searchMode ? ` (filtering: ${searchMode})` : ''}:`,
+            source: searchAllProjects,
+            pageSize: 15,
+        }
+    ]);
+    return {
+        path: answer.project.path,
+        name: answer.project.name
+    };
+}
+// Select project using two-step category then project selection
+async function selectProjectWithTwoStep() {
+    const categoryAnswer = await inquirer.prompt([
+        {
+            type: 'autocomplete',
+            name: 'category',
+            message: 'Select a category:',
+            source: searchCategories,
+            pageSize: 10,
+        }
+    ]);
+    currentCategory = categoryAnswer.category;
+    const projectAnswer = await inquirer.prompt([
+        {
+            type: 'autocomplete',
+            name: 'project',
+            message: 'Select a project:',
+            source: searchProjects,
+            pageSize: 10,
+        }
+    ]);
+    return {
+        path: reposConfig[currentCategory][projectAnswer.project],
+        name: projectAnswer.project
+    };
+}
+// Launch Claude IDE with proper TTY handling
+async function launchClaude(projectPath) {
+    const claudeProcess = spawn('claude', [], {
+        cwd: projectPath,
+        stdio: 'inherit',
+        shell: true,
+    });
+    await new Promise((resolve, reject) => {
+        claudeProcess.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Claude process exited with code ${code}`));
+            }
+        });
+        claudeProcess.on('error', (error) => {
+            reject(error);
+        });
+    });
+}
+// Launch Cursor or other IDE
+async function launchIDE(ideType, projectPath, projectName) {
+    await $ `${ideType} ${projectPath}`;
+    console.log(chalk.green(`Opening ${projectName} in ${ideType}...`));
+}
+export const openIDE = async (ideType, searchMode) => {
+    try {
+        await loadConfig();
+        // Select project using appropriate method
+        const project = searchMode !== undefined
+            ? await selectProjectWithFuzzySearch(searchMode)
+            : await selectProjectWithTwoStep();
+        // Launch IDE based on type
+        if (ideType === 'claude') {
+            await launchClaude(project.path);
+        }
+        else {
+            await launchIDE(ideType, project.path, project.name);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red(`Error opening project in ${ideType}:`, error));
+    }
+};

package/dist/commands/mcp.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Sync MCP servers from ~/.mcp/servers.json to all projects in ~/.claude.json
+ */
+export declare function syncMcpServers(): Promise<void>;

package/dist/commands/mcp.js

@@ -0,0 +1,79 @@
+import { readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+/**
+ * Sync MCP servers from ~/.mcp/servers.json to all projects in ~/.claude.json
+ */
+export async function syncMcpServers() {
+    const spinner = ora('Syncing MCP servers...').start();
+    try {
+        // Read MCP servers configuration
+        const mcpConfigPath = join(homedir(), '.mcp', 'servers.json');
+        const claudeConfigPath = join(homedir(), '.claude.json');
+        let mcpServers;
+        try {
+            const mcpConfigContent = readFileSync(mcpConfigPath, 'utf-8');
+            mcpServers = JSON.parse(mcpConfigContent);
+            spinner.text = `Found ${Object.keys(mcpServers).length} MCP servers`;
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Failed to read MCP servers from ${mcpConfigPath}`));
+            console.error(chalk.yellow(`Please ensure ${mcpConfigPath} exists and is valid JSON`));
+            return;
+        }
+        // Read Claude configuration
+        let claudeConfig;
+        try {
+            const claudeConfigContent = readFileSync(claudeConfigPath, 'utf-8');
+            claudeConfig = JSON.parse(claudeConfigContent);
+        }
+        catch (error) {
+            spinner.fail(chalk.red(`Failed to read Claude config from ${claudeConfigPath}`));
+            return;
+        }
+        // Check if there are any projects
+        if (!claudeConfig.projects || Object.keys(claudeConfig.projects).length === 0) {
+            spinner.warn(chalk.yellow('No projects found in ~/.claude.json'));
+            return;
+        }
+        // Update each project with MCP servers
+        const projectPaths = Object.keys(claudeConfig.projects);
+        spinner.text = `Updating ${projectPaths.length} projects...`;
+        let updatedCount = 0;
+        for (const projectPath of projectPaths) {
+            const project = claudeConfig.projects[projectPath];
+            // Check if mcpServers need to be updated
+            const currentServers = JSON.stringify(project.mcpServers || {});
+            const newServers = JSON.stringify(mcpServers);
+            if (currentServers !== newServers) {
+                project.mcpServers = mcpServers;
+                updatedCount++;
+            }
+        }
+        // Write back to ~/.claude.json
+        if (updatedCount > 0) {
+            writeFileSync(claudeConfigPath, JSON.stringify(claudeConfig, null, 2), 'utf-8');
+            spinner.succeed(chalk.green(`✓ Successfully synced MCP servers to ${updatedCount} project${updatedCount > 1 ? 's' : ''}`));
+            console.log(chalk.cyan('\nMCP Servers synced:'));
+            Object.keys(mcpServers).forEach(serverName => {
+                console.log(chalk.gray(`  • ${serverName}`));
+            });
+            console.log(chalk.cyan('\nProjects updated:'));
+            projectPaths.slice(0, 5).forEach(path => {
+                console.log(chalk.gray(`  • ${path}`));
+            });
+            if (projectPaths.length > 5) {
+                console.log(chalk.gray(`  ... and ${projectPaths.length - 5} more`));
+            }
+        }
+        else {
+            spinner.info(chalk.blue('All projects already have the latest MCP servers configuration'));
+        }
+    }
+    catch (error) {
+        spinner.fail(chalk.red('Failed to sync MCP servers'));
+        console.error(chalk.red(error.message));
+    }
+}

package/dist/hsh.js

@@ -3,8 +3,9 @@ import { branchout, createMR, gcm, merge, push } from './commands/git.js';
 import { Command } from 'commander';
 import { initMonoRepo, monoCd } from './commands/mono.js';
 import { getPackageJson } from './util.js';
-import { openIDE } from './commands/ide.js';
+import { openIDE } from './commands/ide/index.js';
 import { cloudLogin, cloudScp } from './commands/cloud.js';
+import { syncMcpServers } from './commands/mcp.js';
 const packageJson = getPackageJson();
 const program = new Command();
 program.usage('<command> [options]');
@@ -57,13 +58,15 @@ mono.command('cd').description('cd into repo')
 });
 program.command('cursor')
     .description('open project in Cursor')
-    .action(async () => {
-    await openIDE('cursor');
+    .argument('[search]', 'optional search keyword for fuzzy search')
+    .action(async (search) => {
+    await openIDE('cursor', search);
 });
 program.command('claude')
     .description('open project in Claude')
-    .action(async () => {
-    await openIDE('claude');
+    .argument('[search]', 'optional search keyword for fuzzy search')
+    .action(async (search) => {
+    await openIDE('claude', search);
 });
 // Cloud infrastructure management commands
 const cloudCommand = program
@@ -90,4 +93,14 @@ cloudCommand
     .action(async (localPath, remotePath, options) => {
     await cloudScp(localPath, remotePath, options);
 });
+// MCP management commands
+const mcpCommand = program
+    .command('mcp')
+    .description('MCP (Model Context Protocol) server management');
+mcpCommand
+    .command('sync')
+    .description('Sync MCP servers from ~/.mcp/servers.json to all projects in ~/.claude.json')
+    .action(async () => {
+    await syncMcpServers();
+});
 program.parse();

package/docs/FUZZY_SEARCH_FEATURE.md

@@ -0,0 +1,214 @@
+# Fuzzy Search Feature for IDE Commands
+
+## Overview
+
+This document describes the fuzzy search feature added to the `hsh cursor` and `hsh claude` commands, providing users with an optional single-step project search across all categories.
+
+## Feature Description
+
+The IDE commands now support two modes:
+
+### 1. Original Two-Step Mode (Default)
+When no argument is provided:
+```bash
+hsh cursor
+hsh claude
+```
+
+**Behavior:**
+- Step 1: Select a category from the configured categories
+- Step 2: Select a project within the chosen category
+- Maintains backward compatibility with existing workflows
+
+### 2. Fuzzy Search Mode (New)
+When a search argument is provided:
+```bash
+hsh cursor search           # Opens fuzzy search with no initial filter
+hsh cursor airwallex        # Opens fuzzy search pre-filtered with "airwallex"
+hsh claude impactful        # Opens fuzzy search pre-filtered with "impactful"
+```
+
+**Behavior:**
+- Single-step selection across ALL projects from ALL categories
+- Real-time fuzzy matching as you type
+- Searches across project name, category, and path
+- Display format: `project-name (category) - /path/to/project`
+- Supports keyboard navigation with arrow keys
+
+## Implementation Details
+
+### Modified Files
+
+#### 1. `src/hsh.ts`
+Updated command definitions to accept optional search argument:
+```typescript
+program.command('cursor')
+  .description('open project in Cursor')
+  .argument('[search]', 'optional search keyword for fuzzy search')
+  .action(async (search?: string) => {
+    await openIDE('cursor', search);
+  });
+
+program.command('claude')
+  .description('open project in Claude')
+  .argument('[search]', 'optional search keyword for fuzzy search')
+  .action(async (search?: string) => {
+    await openIDE('claude', search);
+  });
+```
+
+#### 2. `src/commands/ide.ts`
+
+**New Functions:**
+
+1. `getAllProjects()`: Flattens all projects across categories
+   - Returns array of `{category, name, path, display}` objects
+   - Display format includes category context
+
+2. `searchAllProjects()`: Fuzzy search handler for inquirer
+   - Single-keyword substring matching
+   - Searches across project name, category, and path
+   - Returns formatted choices for inquirer autocomplete
+
+**Updated Function:**
+
+3. `openIDE()`: Now accepts optional `searchMode` parameter
+   - When `searchMode !== undefined`: Uses single-step fuzzy search
+   - When `searchMode === undefined`: Uses original two-step selection
+   - Maintains all existing IDE launching logic
+
+### Key Design Decisions
+
+1. **Backward Compatibility**: Original behavior preserved when no argument provided
+2. **Single-Keyword Search**: Simple substring matching for fast performance
+3. **Context Display**: Shows category in results for disambiguation
+4. **Larger Page Size**: Fuzzy search shows 15 items vs 10 for category selection
+5. **Empty String Support**: Passing any argument (even empty string) enables fuzzy mode
+
+## Usage Examples
+
+### Example 1: Original Mode
+```bash
+$ hsh cursor
+? Select a category: › 
+  ❯ personal
+    work
+    experiments
+
+$ hsh cursor
+? Select a category: › work
+? Select a project: ›
+  ❯ awx-platform
+    awx-impactful
+    internal-tools
+```
+
+### Example 2: Fuzzy Search Mode (No Initial Filter)
+```bash
+$ hsh cursor search
+? Search and select a project: ›
+  ❯ awx-platform (work) - /Users/you/projects/awx-platform
+    awx-impactful (work) - /Users/you/projects/awx-impactful
+    personal-site (personal) - /Users/you/projects/personal-site
+    blog (personal) - /Users/you/projects/blog
+```
+
+### Example 3: Fuzzy Search Mode (With Initial Filter)
+```bash
+$ hsh cursor awx
+? Search and select a project (filtering: awx): ›
+  ❯ awx-platform (work) - /Users/you/projects/awx-platform
+    awx-impactful (work) - /Users/you/projects/awx-impactful
+```
+
+As user types "imp":
+```bash
+? Search and select a project (filtering: awx): › imp
+  ❯ awx-impactful (work) - /Users/you/projects/awx-impactful
+```
+
+## Testing
+
+### Verification Steps
+
+1. **Build the project:**
+   ```bash
+   yarn build
+   ```
+
+2. **Verify help output:**
+   ```bash
+   hsh --help
+   ```
+   Should show:
+   ```
+   cursor [search]    open project in Cursor
+   claude [search]    open project in Claude
+   ```
+
+3. **Test original mode (no argument):**
+   ```bash
+   hsh cursor
+   ```
+   - Should show two-step category → project selection
+   - Original workflow should work identically
+
+4. **Test fuzzy search mode (with 'search'):**
+   ```bash
+   hsh cursor search
+   ```
+   - Should show all projects from all categories
+   - Type a keyword and verify real-time filtering
+   - Verify display format includes category
+
+5. **Test fuzzy search with initial keyword:**
+   ```bash
+   hsh cursor <keyword>
+   ```
+   - Should open with pre-filtered results
+   - Verify keyword appears in prompt message
+   - Verify can still type to refine search
+
+6. **Test with claude command:**
+   ```bash
+   hsh claude search
+   hsh claude <keyword>
+   ```
+   - Same behavior as cursor command
+
+### Expected Behavior
+
+✅ **Original mode preserves existing UX**
+✅ **Fuzzy search provides single-step selection**
+✅ **Real-time filtering works as you type**
+✅ **Search matches project name, category, and path**
+✅ **Display shows category context for clarity**
+✅ **Keyboard navigation works with arrow keys**
+✅ **Enter key opens selected project in IDE**
+
+## Configuration Requirements
+
+Requires `~/hsh.config.json` with structure:
+```json
+{
+  "repos": {
+    "category1": {
+      "project1": "/path/to/project1",
+      "project2": "/path/to/project2"
+    },
+    "category2": {
+      "project3": "/path/to/project3"
+    }
+  }
+}
+```
+
+## Future Enhancements
+
+Potential improvements for future versions:
+- Multi-keyword matching (e.g., "awx imp" matches both keywords)
+- Fuzzy scoring algorithm (e.g., fuse.js) for typo tolerance
+- Recent projects tracking and prioritization
+- Favorites/bookmarks system
+- Project metadata display (last opened, git branch, etc.)
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hsh19900502",
-  "version": "1.0.21",
+  "version": "1.0.23",
   "type": "module",
   "description": "",
   "main": "index.js",

package/src/commands/ide/index.ts

@@ -0,0 +1,197 @@
+import inquirer from 'inquirer';
+import 'zx/globals';
+import chalk from 'chalk';
+import inquirerAutocomplete from 'inquirer-autocomplete-prompt';
+import { readConfig } from '../../util.js';
+import { spawn } from 'child_process';
+
+interface ReposConfig {
+  [key: string]: {
+    [key: string]: string;
+  };
+}
+
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', inquirerAutocomplete);
+
+let reposConfig: ReposConfig;
+let currentCategory: string;
+
+async function loadConfig() {
+  const config = readConfig();
+  reposConfig = config.repos;
+}
+
+async function searchCategories(answers: any, input = '') {
+  if (!reposConfig) {
+    await loadConfig();
+  }
+  const categories = Object.keys(reposConfig);
+
+  if (!input) {
+    return categories;
+  }
+
+  return categories.filter(category =>
+    category.toLowerCase().includes(input.toLowerCase())
+  );
+}
+
+async function searchProjects(answers: any, input = '') {
+  if (!reposConfig) {
+    await loadConfig();
+  }
+
+  // Get projects for the selected category
+  if (!currentCategory || !reposConfig[currentCategory]) {
+    return [];
+  }
+
+  const projects = Object.entries(reposConfig[currentCategory])
+    .map(([name, path]) => ({
+      name,
+      path,
+      display: `${name} (${path})`
+    }));
+
+  if (!input) {
+    return projects.map(p => p.name);
+  }
+
+  const searchTerm = input.toLowerCase();
+  return projects
+    .filter(project =>
+      project.name.toLowerCase().includes(searchTerm) ||
+      project.path.toLowerCase().includes(searchTerm)
+    )
+    .map(p => p.name);
+}
+
+// Flatten all projects with category context for fuzzy search
+function getAllProjects(): Array<{category: string, name: string, path: string, display: string}> {
+  if (!reposConfig) return [];
+  
+  return Object.entries(reposConfig).flatMap(([category, projects]) =>
+    Object.entries(projects).map(([name, path]) => ({
+      category,
+      name,
+      path,
+      display: `${name} (${category})`
+    }))
+  );
+}
+
+// Single-keyword fuzzy search across all projects
+async function searchAllProjects(answers: any, input = '') {
+  const allProjects = getAllProjects();
+  
+  if (!input) {
+    return allProjects.map(p => ({ name: p.display, value: p }));
+  }
+  
+  // Split input by spaces and filter projects matching ALL keywords
+  const keywords = input.toLowerCase().trim().split(/\s+/);
+  return allProjects
+    .filter(project => {
+      const searchText = `${project.name} ${project.category} ${project.path}`.toLowerCase();
+      // Check if all keywords are present in the search text
+      return keywords.every(keyword => searchText.includes(keyword));
+    })
+    .map(p => ({ name: p.display, value: p }));
+}
+
+// Select project using fuzzy search across all categories
+async function selectProjectWithFuzzySearch(searchMode?: string): Promise<{path: string, name: string}> {
+  const answer = await inquirer.prompt([
+    {
+      type: 'autocomplete',
+      name: 'project',
+      message: `Search and select a project${searchMode ? ` (filtering: ${searchMode})` : ''}:`,
+      source: searchAllProjects,
+      pageSize: 15,
+    }
+  ]);
+  
+  return {
+    path: answer.project.path,
+    name: answer.project.name
+  };
+}
+
+// Select project using two-step category then project selection
+async function selectProjectWithTwoStep(): Promise<{path: string, name: string}> {
+  const categoryAnswer = await inquirer.prompt([
+    {
+      type: 'autocomplete',
+      name: 'category',
+      message: 'Select a category:',
+      source: searchCategories,
+      pageSize: 10,
+    }
+  ]);
+
+  currentCategory = categoryAnswer.category;
+  
+  const projectAnswer = await inquirer.prompt([
+    {
+      type: 'autocomplete',
+      name: 'project',
+      message: 'Select a project:',
+      source: searchProjects,
+      pageSize: 10,
+    }
+  ]);
+
+  return {
+    path: reposConfig[currentCategory][projectAnswer.project],
+    name: projectAnswer.project
+  };
+}
+
+// Launch Claude IDE with proper TTY handling
+async function launchClaude(projectPath: string): Promise<void> {
+  const claudeProcess = spawn('claude', [], {
+    cwd: projectPath,
+    stdio: 'inherit',
+    shell: true,
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    claudeProcess.on('close', (code) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(new Error(`Claude process exited with code ${code}`));
+      }
+    });
+    claudeProcess.on('error', (error) => {
+      reject(error);
+    });
+  });
+}
+
+// Launch Cursor or other IDE
+async function launchIDE(ideType: string, projectPath: string, projectName: string): Promise<void> {
+  await $`${ideType} ${projectPath}`;
+  console.log(chalk.green(`Opening ${projectName} in ${ideType}...`));
+}
+
+export const openIDE = async (ideType: 'cursor' | 'claude', searchMode?: string) => {
+  try {
+    await loadConfig();
+    
+    // Select project using appropriate method
+    const project = searchMode !== undefined 
+      ? await selectProjectWithFuzzySearch(searchMode)
+      : await selectProjectWithTwoStep();
+    
+    // Launch IDE based on type
+    if (ideType === 'claude') {
+      await launchClaude(project.path);
+    } else {
+      await launchIDE(ideType, project.path, project.name);
+    }
+  } catch (error) {
+    console.error(chalk.red(`Error opening project in ${ideType}:`, error));
+  }
+}; 

package/src/commands/mcp.ts

@@ -0,0 +1,118 @@
+import { $ } from 'zx';
+import { readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+
+interface McpServerConfig {
+  [serverName: string]: {
+    type?: string;
+    command: string;
+    args: string[];
+    env?: Record<string, string>;
+  };
+}
+
+interface ClaudeConfig {
+  projects: {
+    [projectPath: string]: {
+      mcpServers?: McpServerConfig;
+      [key: string]: any;
+    };
+  };
+  [key: string]: any;
+}
+
+/**
+ * Sync MCP servers from ~/.mcp/servers.json to all projects in ~/.claude.json
+ */
+export async function syncMcpServers() {
+  const spinner = ora('Syncing MCP servers...').start();
+
+  try {
+    // Read MCP servers configuration
+    const mcpConfigPath = join(homedir(), '.mcp', 'servers.json');
+    const claudeConfigPath = join(homedir(), '.claude.json');
+
+    let mcpServers: McpServerConfig;
+    try {
+      const mcpConfigContent = readFileSync(mcpConfigPath, 'utf-8');
+      mcpServers = JSON.parse(mcpConfigContent);
+      spinner.text = `Found ${Object.keys(mcpServers).length} MCP servers`;
+    } catch (error) {
+      spinner.fail(chalk.red(`Failed to read MCP servers from ${mcpConfigPath}`));
+      console.error(chalk.yellow(`Please ensure ${mcpConfigPath} exists and is valid JSON`));
+      return;
+    }
+
+    // Read Claude configuration
+    let claudeConfig: ClaudeConfig;
+    try {
+      const claudeConfigContent = readFileSync(claudeConfigPath, 'utf-8');
+      claudeConfig = JSON.parse(claudeConfigContent);
+    } catch (error) {
+      spinner.fail(chalk.red(`Failed to read Claude config from ${claudeConfigPath}`));
+      return;
+    }
+
+    // Check if there are any projects
+    if (!claudeConfig.projects || Object.keys(claudeConfig.projects).length === 0) {
+      spinner.warn(chalk.yellow('No projects found in ~/.claude.json'));
+      return;
+    }
+
+    // Update each project with MCP servers
+    const projectPaths = Object.keys(claudeConfig.projects);
+    spinner.text = `Updating ${projectPaths.length} projects...`;
+
+    let updatedCount = 0;
+    for (const projectPath of projectPaths) {
+      const project = claudeConfig.projects[projectPath];
+      
+      // Check if mcpServers need to be updated
+      const currentServers = JSON.stringify(project.mcpServers || {});
+      const newServers = JSON.stringify(mcpServers);
+      
+      if (currentServers !== newServers) {
+        project.mcpServers = mcpServers;
+        updatedCount++;
+      }
+    }
+
+    // Write back to ~/.claude.json
+    if (updatedCount > 0) {
+      writeFileSync(
+        claudeConfigPath,
+        JSON.stringify(claudeConfig, null, 2),
+        'utf-8'
+      );
+      
+      spinner.succeed(
+        chalk.green(
+          `✓ Successfully synced MCP servers to ${updatedCount} project${updatedCount > 1 ? 's' : ''}`
+        )
+      );
+      
+      console.log(chalk.cyan('\nMCP Servers synced:'));
+      Object.keys(mcpServers).forEach(serverName => {
+        console.log(chalk.gray(`  • ${serverName}`));
+      });
+      
+      console.log(chalk.cyan('\nProjects updated:'));
+      projectPaths.slice(0, 5).forEach(path => {
+        console.log(chalk.gray(`  • ${path}`));
+      });
+      if (projectPaths.length > 5) {
+        console.log(chalk.gray(`  ... and ${projectPaths.length - 5} more`));
+      }
+    } else {
+      spinner.info(chalk.blue('All projects already have the latest MCP servers configuration'));
+    }
+
+  } catch (error: any) {
+    spinner.fail(chalk.red('Failed to sync MCP servers'));
+    console.error(chalk.red(error.message));
+  }
+}
+

package/src/hsh.ts

@@ -4,8 +4,9 @@ import { Command } from 'commander';
 import { initMonoRepo, monoCd } from './commands/mono.js';
 import { RepoDirLevel } from './types/index.js';
 import { getPackageJson } from './util.js';
-import { openIDE } from './commands/ide.js';
+import { openIDE } from './commands/ide/index.js';
 import { cloudLogin, cloudScp } from './commands/cloud.js';
+import { syncMcpServers } from './commands/mcp.js';
 
 const packageJson = getPackageJson();
 
@@ -70,14 +71,16 @@ mono.command('cd').description('cd into repo')
 
 program.command('cursor')
   .description('open project in Cursor')
-  .action(async () => {
-    await openIDE('cursor');
+  .argument('[search]', 'optional search keyword for fuzzy search')
+  .action(async (search?: string) => {
+    await openIDE('cursor', search);
   });
 
 program.command('claude')
   .description('open project in Claude')
-  .action(async () => {
-    await openIDE('claude');
+  .argument('[search]', 'optional search keyword for fuzzy search')
+  .action(async (search?: string) => {
+    await openIDE('claude', search);
   });
 
 // Cloud infrastructure management commands
@@ -108,4 +111,16 @@ cloudCommand
     await cloudScp(localPath, remotePath, options);
   });
 
+// MCP management commands
+const mcpCommand = program
+  .command('mcp')
+  .description('MCP (Model Context Protocol) server management');
+
+mcpCommand
+  .command('sync')
+  .description('Sync MCP servers from ~/.mcp/servers.json to all projects in ~/.claude.json')
+  .action(async () => {
+    await syncMcpServers();
+  });
+
 program.parse(); 

package/dist/commands/ide.d.ts

@@ -1,2 +0,0 @@
-import 'zx/globals';
-export declare const openIDE: (ideType: "cursor" | "claude") => Promise<void>;

package/dist/commands/ide.js

@@ -1,104 +0,0 @@
-import inquirer from 'inquirer';
-import 'zx/globals';
-import chalk from 'chalk';
-import inquirerAutocomplete from 'inquirer-autocomplete-prompt';
-import { readConfig } from '../util.js';
-import { spawn } from 'child_process';
-// Register autocomplete prompt
-inquirer.registerPrompt('autocomplete', inquirerAutocomplete);
-let reposConfig;
-let currentCategory;
-async function loadConfig() {
-    const config = readConfig();
-    reposConfig = config.repos;
-}
-async function searchCategories(answers, input = '') {
-    if (!reposConfig) {
-        await loadConfig();
-    }
-    const categories = Object.keys(reposConfig);
-    if (!input) {
-        return categories;
-    }
-    return categories.filter(category => category.toLowerCase().includes(input.toLowerCase()));
-}
-async function searchProjects(answers, input = '') {
-    if (!reposConfig) {
-        await loadConfig();
-    }
-    // Get projects for the selected category
-    if (!currentCategory || !reposConfig[currentCategory]) {
-        return [];
-    }
-    const projects = Object.entries(reposConfig[currentCategory])
-        .map(([name, path]) => ({
-        name,
-        path,
-        display: `${name} (${path})`
-    }));
-    if (!input) {
-        return projects.map(p => p.name);
-    }
-    const searchTerm = input.toLowerCase();
-    return projects
-        .filter(project => project.name.toLowerCase().includes(searchTerm) ||
-        project.path.toLowerCase().includes(searchTerm))
-        .map(p => p.name);
-}
-export const openIDE = async (ideType) => {
-    try {
-        await loadConfig();
-        // First level selection with search
-        const firstLevelAnswer = await inquirer.prompt([
-            {
-                type: 'autocomplete',
-                name: 'category',
-                message: 'Select a category:',
-                source: searchCategories,
-                pageSize: 10,
-            }
-        ]);
-        currentCategory = firstLevelAnswer.category;
-        // Second level selection with search
-        const secondLevelAnswer = await inquirer.prompt([
-            {
-                type: 'autocomplete',
-                name: 'project',
-                message: 'Select a project:',
-                source: searchProjects,
-                pageSize: 10,
-            }
-        ]);
-        const selectedProject = secondLevelAnswer.project;
-        const projectPath = reposConfig[currentCategory][selectedProject];
-        if (ideType === 'claude') {
-            // Use spawn with inherited stdio to support interactive TTY
-            const claudeProcess = spawn('claude', [], {
-                cwd: projectPath,
-                stdio: 'inherit', // Inherit stdin, stdout, stderr from parent process
-                shell: true,
-            });
-            // Wait for the process to exit
-            await new Promise((resolve, reject) => {
-                claudeProcess.on('close', (code) => {
-                    if (code === 0) {
-                        resolve();
-                    }
-                    else {
-                        reject(new Error(`Claude process exited with code ${code}`));
-                    }
-                });
-                claudeProcess.on('error', (error) => {
-                    reject(error);
-                });
-            });
-            return;
-        }
-        // Open project in IDE
-        await $ `${ideType} ${projectPath}`;
-        console.log(chalk.green(`Opening ${selectedProject} in ${ideType}...`));
-    }
-    catch (error) {
-        console.error(chalk.red(`Error opening project in ${ideType}:`, error));
-    }
-};

package/src/commands/ide.ts

@@ -1,130 +0,0 @@
-import inquirer from 'inquirer';
-import 'zx/globals';
-import chalk from 'chalk';
-import inquirerAutocomplete from 'inquirer-autocomplete-prompt';
-import { readConfig } from '../util.js';
-import { spawn } from 'child_process';
-
-interface ReposConfig {
-  [key: string]: {
-    [key: string]: string;
-  };
-}
-
-// Register autocomplete prompt
-inquirer.registerPrompt('autocomplete', inquirerAutocomplete);
-
-let reposConfig: ReposConfig;
-let currentCategory: string;
-
-async function loadConfig() {
-  const config = readConfig();
-  reposConfig = config.repos;
-}
-
-async function searchCategories(answers: any, input = '') {
-  if (!reposConfig) {
-    await loadConfig();
-  }
-  const categories = Object.keys(reposConfig);
-
-  if (!input) {
-    return categories;
-  }
-
-  return categories.filter(category =>
-    category.toLowerCase().includes(input.toLowerCase())
-  );
-}
-
-async function searchProjects(answers: any, input = '') {
-  if (!reposConfig) {
-    await loadConfig();
-  }
-
-  // Get projects for the selected category
-  if (!currentCategory || !reposConfig[currentCategory]) {
-    return [];
-  }
-
-  const projects = Object.entries(reposConfig[currentCategory])
-    .map(([name, path]) => ({
-      name,
-      path,
-      display: `${name} (${path})`
-    }));
-
-  if (!input) {
-    return projects.map(p => p.name);
-  }
-
-  const searchTerm = input.toLowerCase();
-  return projects
-    .filter(project =>
-      project.name.toLowerCase().includes(searchTerm) ||
-      project.path.toLowerCase().includes(searchTerm)
-    )
-    .map(p => p.name);
-}
-
-export const openIDE = async (ideType: 'cursor' | 'claude') => {
-  try {
-    await loadConfig();
-    
-    // First level selection with search
-    const firstLevelAnswer = await inquirer.prompt([
-      {
-        type: 'autocomplete',
-        name: 'category',
-        message: 'Select a category:',
-        source: searchCategories,
-        pageSize: 10,
-      }
-    ]);
-
-    currentCategory = firstLevelAnswer.category;
-    
-    // Second level selection with search
-    const secondLevelAnswer = await inquirer.prompt([
-      {
-        type: 'autocomplete',
-        name: 'project',
-        message: 'Select a project:',
-        source: searchProjects,
-        pageSize: 10,
-      }
-    ]);
-
-    const selectedProject = secondLevelAnswer.project;
-    const projectPath = reposConfig[currentCategory][selectedProject];
-
-    if(ideType === 'claude') {
-      // Use spawn with inherited stdio to support interactive TTY
-      const claudeProcess = spawn('claude', [], {
-        cwd: projectPath,
-        stdio: 'inherit', // Inherit stdin, stdout, stderr from parent process
-        shell: true,
-      });
-
-      // Wait for the process to exit
-      await new Promise<void>((resolve, reject) => {
-        claudeProcess.on('close', (code) => {
-          if (code === 0) {
-            resolve();
-          } else {
-            reject(new Error(`Claude process exited with code ${code}`));
-          }
-        });
-        claudeProcess.on('error', (error) => {
-          reject(error);
-        });
-      });
-      return;
-    }
-    // Open project in IDE
-    await $`${ideType} ${projectPath}`;
-    console.log(chalk.green(`Opening ${selectedProject} in ${ideType}...`));
-  } catch (error) {
-    console.error(chalk.red(`Error opening project in ${ideType}:`, error));
-  }
-};