ideconnect 1.0.0

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "ideconnect",
+  "version": "1.0.0",
+  "description": "Free, self-hosted MCP server for shared project context across AI IDEs",
+  "type": "module",
+  "bin": {
+    "ideconnect": "./scripts/setup.js"
+  },
+  "files": [
+    "server/",
+    "scripts/",
+    "adapters/",
+    "examples/",
+    "README.md"
+  ],
+  "scripts": {
+    "install": "node scripts/setup.js",
+    "setup": "node scripts/setup.js",
+    "verify": "node scripts/verify.js",
+    "init": "node scripts/init.js",
+    "inject": "node adapters/file-inject/inject.js",
+    "start": "node scripts/start-server.js"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "project-context",
+    "ai",
+    "ide",
+    "cursor",
+    "claude-desktop",
+    "ide-integration",
+    "self-hosted"
+  ],
+  "author": "bluebillshtml",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bluebillshtml/ideconnect.git"
+  }
+}
+

package/scripts/init.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+
+import { mkdir, writeFile, access } from 'fs/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const CONTEXT_DIR = '.ideconnect';
+
+const templates = {
+  'overview.md': `# Project Overview
+
+## Purpose
+
+[Describe the project's primary purpose and what problem it solves]
+
+## Scope
+
+[Define what is included and excluded from this project]
+
+## Goals
+
+[List the main objectives and success criteria]
+
+## Key Stakeholders
+
+[Identify important people, teams, or organizations involved]
+
+## Current Status
+
+[Brief description of where the project stands today]
+`,
+
+  'architecture.md': `# Architecture
+
+## System Design
+
+[High-level system architecture, component diagram, or description]
+
+## Components
+
+[Breakdown of major components and their responsibilities]
+
+## Data Flow
+
+[How data moves through the system]
+
+## Patterns & Conventions
+
+[Architectural patterns, coding conventions, design principles used]
+
+## Technology Stack
+
+[Languages, frameworks, libraries, tools used]
+
+## Dependencies
+
+[External dependencies and their purposes]
+`,
+
+  'constraints.md': `# Constraints
+
+## Technical Constraints
+
+[Hardware, software, performance, scalability limits]
+
+## Business Constraints
+
+[Budget, timeline, regulatory, compliance requirements]
+
+## Resource Constraints
+
+[Team size, expertise, time, infrastructure limitations]
+
+## Design Constraints
+
+[Platform requirements, compatibility, integration limitations]
+
+## Operational Constraints
+
+[Deployment, maintenance, monitoring requirements]
+`,
+
+  'decisions.md': `# Architectural Decisions
+
+## Decision Log
+
+[Record decisions in reverse chronological order (newest first)]
+
+### [Date] - [Decision Title]
+
+**Context**: [What situation required a decision]
+
+**Decision**: [What was decided]
+
+**Rationale**: [Why this decision was made]
+
+**Alternatives Considered**: [Other options that were evaluated]
+
+**Consequences**: [Expected impact of this decision]
+
+---
+
+[Add more decisions above this line]
+`,
+
+  'roadmap.md': `# Roadmap
+
+## Current Phase
+
+[What is being worked on now]
+
+## Upcoming Milestones
+
+[Planned milestones and target dates]
+
+## Future Considerations
+
+[Ideas, features, or improvements for later]
+
+## Known Work Items
+
+[Specific tasks or issues to address]
+`,
+};
+
+async function init() {
+  const cwd = process.cwd();
+  const contextPath = join(cwd, CONTEXT_DIR);
+
+  try {
+    // Check if already exists
+    await access(contextPath);
+    console.log(`✓ ${CONTEXT_DIR} directory already exists`);
+    console.log('  Skipping initialization. Delete the directory to reinitialize.');
+    return;
+  } catch {
+    // Directory doesn't exist, create it
+  }
+
+  try {
+    // Create directory
+    await mkdir(contextPath, { recursive: true });
+    console.log(`✓ Created ${CONTEXT_DIR} directory`);
+
+    // Create template files
+    for (const [filename, content] of Object.entries(templates)) {
+      const filePath = join(contextPath, filename);
+      await writeFile(filePath, content, 'utf-8');
+      console.log(`✓ Created ${filename}`);
+    }
+
+    console.log('\n✓ IDEConnect initialized successfully!');
+    console.log(`\nNext steps:`);
+    console.log(`  1. Edit files in ${CONTEXT_DIR}/ to document your project`);
+    console.log(`  2. Configure your IDE to use the MCP server`);
+    console.log(`  3. See docs/SETUP.md for IDE integration instructions`);
+  } catch (error) {
+    console.error(`Error initializing IDEConnect: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+init();
+

package/scripts/install.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+/**
+ * One-command installer for IDEConnect
+ * This is the main entry point for users
+ */
+
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const SETUP_SCRIPT = join(__dirname, 'setup.js');
+
+console.log('🎯 IDEConnect - Automated Installation\n');
+
+try {
+  // Run the setup script
+  execSync(`node "${SETUP_SCRIPT}"`, { stdio: 'inherit' });
+} catch (error) {
+  console.error('\n❌ Installation failed');
+  process.exit(1);
+}
+

package/scripts/setup.js

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+
+/**
+ * Automated setup script for IDEConnect
+ * Handles all configuration automatically
+ */
+
+import { mkdir, writeFile, readFile, access, copyFile } from 'fs/promises';
+import { join, dirname } from 'path';
+import { homedir } from 'os';
+import { existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { execSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PROJECT_ROOT = dirname(__dirname);
+
+const CONTEXT_DIR = '.ideconnect';
+const SERVER_PATH = join(PROJECT_ROOT, 'server', 'index.js');
+
+// IDE configuration paths
+const IDE_CONFIGS = {
+  cursor: {
+    name: 'Cursor',
+    configPath: join(homedir(), '.cursor', 'mcp.json'),
+    configDir: join(homedir(), '.cursor'),
+    configKey: 'mcpServers',
+  },
+  claude: {
+    name: 'Claude Desktop',
+    configPath: process.platform === 'darwin'
+      ? join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json')
+      : process.platform === 'win32'
+      ? join(process.env.APPDATA || homedir(), 'Claude', 'claude_desktop_config.json')
+      : join(homedir(), '.config', 'claude', 'claude_desktop_config.json'),
+    configDir: dirname(process.platform === 'darwin'
+      ? join(homedir(), 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json')
+      : process.platform === 'win32'
+      ? join(process.env.APPDATA || homedir(), 'Claude', 'claude_desktop_config.json')
+      : join(homedir(), '.config', 'claude', 'claude_desktop_config.json')),
+    configKey: 'mcpServers',
+  },
+};
+
+async function checkNodeVersion() {
+  try {
+    const version = execSync('node --version', { encoding: 'utf-8' }).trim();
+    const major = parseInt(version.replace('v', '').split('.')[0]);
+    if (major < 18) {
+      throw new Error(`Node.js 18+ required. Found: ${version}`);
+    }
+    console.log(`✓ Node.js version: ${version}`);
+    return true;
+  } catch (error) {
+    console.error(`❌ Node.js not found or version too old: ${error.message}`);
+    return false;
+  }
+}
+
+async function installDependencies() {
+  console.log('\n📦 Installing dependencies...');
+  try {
+    const serverDir = join(PROJECT_ROOT, 'server');
+    process.chdir(serverDir);
+    execSync('npm install', { stdio: 'inherit' });
+    process.chdir(PROJECT_ROOT);
+    console.log('✓ Dependencies installed');
+    return true;
+  } catch (error) {
+    console.error(`❌ Failed to install dependencies: ${error.message}`);
+    return false;
+  }
+}
+
+async function initializeContext() {
+  console.log('\n📝 Initializing context files...');
+  const contextPath = join(process.cwd(), CONTEXT_DIR);
+
+  try {
+    await access(contextPath);
+    console.log(`✓ Context directory already exists at ${CONTEXT_DIR}`);
+    return true;
+  } catch {
+    // Directory doesn't exist, create it
+  }
+
+  try {
+    await mkdir(contextPath, { recursive: true });
+    console.log(`✓ Created ${CONTEXT_DIR} directory`);
+
+    // Copy template files
+    const templates = ['overview.md', 'architecture.md', 'constraints.md', 'decisions.md', 'roadmap.md'];
+    for (const template of templates) {
+      const templatePath = join(PROJECT_ROOT, CONTEXT_DIR, template);
+      const destPath = join(contextPath, template);
+      
+      if (existsSync(templatePath)) {
+        await copyFile(templatePath, destPath);
+        console.log(`✓ Created ${template}`);
+      } else {
+        // Create minimal template if not found
+        await writeFile(destPath, `# ${template.replace('.md', '').charAt(0).toUpperCase() + template.replace('.md', '').slice(1)}\n\n[Add your content here]\n`, 'utf-8');
+        console.log(`✓ Created ${template} (template)`);
+      }
+    }
+
+    console.log(`✓ Context files initialized in ${CONTEXT_DIR}/`);
+    return true;
+  } catch (error) {
+    console.error(`❌ Failed to initialize context: ${error.message}`);
+    return false;
+  }
+}
+
+async function configureIDE(ideName) {
+  const ide = IDE_CONFIGS[ideName];
+  if (!ide) {
+    return false;
+  }
+
+  console.log(`\n🔧 Configuring ${ide.name}...`);
+
+  try {
+    // Check if config directory exists
+    if (!existsSync(ide.configDir)) {
+      console.log(`  Creating config directory: ${ide.configDir}`);
+      await mkdir(ide.configDir, { recursive: true });
+    }
+
+    // Read existing config or create new
+    let config = {};
+    if (existsSync(ide.configPath)) {
+      try {
+        const configContent = await readFile(ide.configPath, 'utf-8');
+        config = JSON.parse(configContent);
+      } catch (error) {
+        console.log(`  Warning: Could not parse existing config, creating new one`);
+        config = {};
+      }
+    }
+
+    // Ensure configKey exists
+    if (!config[ide.configKey]) {
+      config[ide.configKey] = {};
+    }
+
+    // Add IDEConnect server
+    config[ide.configKey].ideconnect = {
+      command: 'node',
+      args: [SERVER_PATH],
+    };
+
+    // Write config
+    await writeFile(ide.configPath, JSON.stringify(config, null, 2), 'utf-8');
+    console.log(`✓ ${ide.name} configured at ${ide.configPath}`);
+    return true;
+  } catch (error) {
+    console.error(`  ⚠️  Could not configure ${ide.name}: ${error.message}`);
+    console.error(`  You can manually configure it using the path: ${ide.configPath}`);
+    return false;
+  }
+}
+
+async function detectIDEs() {
+  const detected = [];
+  
+  for (const [key, ide] of Object.entries(IDE_CONFIGS)) {
+    // Check if IDE config directory exists or if we can write to it
+    try {
+      if (existsSync(ide.configDir) || key === 'cursor' || key === 'claude') {
+        detected.push(key);
+      }
+    } catch {
+      // Skip if we can't check
+    }
+  }
+
+  return detected;
+}
+
+async function runSetup() {
+  console.log('🚀 IDEConnect Automated Setup\n');
+  console.log('='.repeat(50));
+
+  // Step 1: Check prerequisites
+  console.log('\n📋 Checking prerequisites...');
+  if (!(await checkNodeVersion())) {
+    process.exit(1);
+  }
+
+  // Step 2: Install dependencies
+  if (!(await installDependencies())) {
+    process.exit(1);
+  }
+
+  // Step 3: Initialize context
+  if (!(await initializeContext())) {
+    process.exit(1);
+  }
+
+  // Step 4: Detect and configure IDEs
+  console.log('\n🔍 Detecting IDEs...');
+  const detectedIDEs = await detectIDEs();
+  
+  if (detectedIDEs.length === 0) {
+    console.log('  No IDEs detected. Will configure common IDEs anyway...');
+    detectedIDEs.push('cursor', 'claude');
+  } else {
+    console.log(`  Detected: ${detectedIDEs.map(k => IDE_CONFIGS[k].name).join(', ')}`);
+  }
+
+  let configuredCount = 0;
+  for (const ideKey of detectedIDEs) {
+    if (await configureIDE(ideKey)) {
+      configuredCount++;
+    }
+  }
+
+  // Step 5: Generate file injection
+  console.log('\n📄 Generating file injection...');
+  try {
+    const { spawn } = await import('child_process');
+    const injectScript = join(PROJECT_ROOT, 'adapters', 'file-inject', 'inject.js');
+    execSync(`node "${injectScript}"`, { stdio: 'inherit', cwd: PROJECT_ROOT });
+    console.log('✓ File injection generated');
+  } catch (error) {
+    console.log(`  ⚠️  File injection failed: ${error.message}`);
+  }
+
+  // Summary
+  console.log('\n' + '='.repeat(50));
+  console.log('✅ Setup Complete!\n');
+  console.log('Summary:');
+  console.log(`  ✓ Dependencies installed`);
+  console.log(`  ✓ Context files initialized in ${CONTEXT_DIR}/`);
+  console.log(`  ✓ ${configuredCount} IDE(s) configured`);
+  console.log(`  ✓ File injection ready\n`);
+  
+  console.log('Next steps:');
+  console.log(`  1. Edit files in ${CONTEXT_DIR}/ to document your project`);
+  console.log(`  2. Restart your IDE(s) to load IDEConnect`);
+  console.log(`  3. Start using context-aware AI assistance!\n`);
+  
+  if (configuredCount < detectedIDEs.length) {
+    console.log('Note: Some IDEs could not be auto-configured.');
+    console.log('See docs/IDE_INTEGRATION.md for manual configuration.\n');
+  }
+}
+
+runSetup().catch((error) => {
+  console.error('\n❌ Setup failed:', error.message);
+  process.exit(1);
+});
+

package/scripts/start-server.js

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+/**
+ * Start IDEConnect MCP server as a daemon/service
+ * For production hosting scenarios
+ */
+
+import { spawn } from 'child_process';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { existsSync } from 'fs';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const PROJECT_ROOT = dirname(__dirname);
+const SERVER_PATH = join(PROJECT_ROOT, 'server', 'index.js');
+
+if (!existsSync(SERVER_PATH)) {
+  console.error('❌ Server not found. Run setup first.');
+  process.exit(1);
+}
+
+console.log('🚀 Starting IDEConnect MCP Server...');
+console.log(`   Server: ${SERVER_PATH}`);
+console.log('   Press Ctrl+C to stop\n');
+
+const server = spawn('node', [SERVER_PATH], {
+  stdio: 'inherit',
+  cwd: PROJECT_ROOT,
+});
+
+server.on('error', (error) => {
+  console.error('❌ Server error:', error.message);
+  process.exit(1);
+});
+
+server.on('exit', (code) => {
+  if (code !== 0 && code !== null) {
+    console.error(`\n❌ Server exited with code ${code}`);
+    process.exit(code);
+  }
+});
+
+// Handle graceful shutdown
+process.on('SIGINT', () => {
+  console.log('\n\n🛑 Shutting down server...');
+  server.kill('SIGINT');
+  process.exit(0);
+});
+
+process.on('SIGTERM', () => {
+  server.kill('SIGTERM');
+  process.exit(0);
+});
+