@stackguide/mcp-server 1.0.2 → 1.1.1

package/README.md

@@ -32,48 +32,57 @@ Dynamic context loading for AI coding assistants. Works with **Cursor** and **Gi
 
 ### 2. Use
 
-Just ask your AI assistant:
-- *"Select project type react-node"*
-- *"List available rules"*
-- *"Get full context"*
-- *"Browse cursor directory for python rules"*
+Just tell your AI assistant in natural language:
+
+- *"Set up my project"* → Auto-detects and configures everything
+- *"I'm working on a Django API"* → Configures Python/Django context
+- *"Configure for React with TypeScript"* → Sets up React-TS rules
+- *"Browse Python rules from cursor directory"* → Shows community rules
+
+## Auto-Setup (NEW in 1.1.0!)
+
+StackGuide can automatically detect your project type and configure itself:
+
+```
+auto_setup projectPath:"."
+```
+
+It analyzes your `package.json`, `requirements.txt`, `Cargo.toml`, etc. and loads the right rules.
 
 ## Supported Stacks
 
 `python-django` · `python-fastapi` · `python-flask` · `react-node` · `react-typescript` · `vue-node` · `nextjs` · `express` · `nestjs` · `laravel` · `rails` · `golang` · `rust`
 
-## Tools (42 total)
+## Tools (46 total)
 
 | Category | Tools |
 |----------|-------|
+| **Smart Setup** | `auto_setup` `detect_project` `suggest_rules` `quick_start` |
 | **Project** | `list_project_types` `select_project_type` `get_current_context` |
 | **Rules** | `list_rules` `get_rule` `select_rules` `search_rules` `create_rule` `update_rule` `delete_rule` |
 | **Knowledge** | `list_knowledge` `get_knowledge` `select_knowledge` `search_knowledge` |
 | **Config** | `save_configuration` `load_configuration` `list_configurations` `export_configuration` |
 | **Web Docs** | `fetch_web_docs` `list_web_docs` `search_web_docs` `get_suggested_docs` |
-| **Cursor Directory** | `browse_cursor_directory` `search_cursor_directory` `import_cursor_directory_rule` `get_popular_cursor_rules` |
+| **Cursor Directory** | `browse_cursor_directory` `search_cursor_directory` `import_cursor_directory_rule` |
 | **Context** | `get_full_context` `add_custom_rule` |
 
+## How It Works
+
+1. **Auto-detect**: Analyzes project files to identify your stack
+2. **Load context**: Loads relevant rules, standards, and patterns
+3. **Suggest**: Recommends community rules from cursor.directory
+4. **Persist**: Saves your configuration for future sessions
+
 ## Cursor Directory Integration
 
 Import community rules from [cursor.directory](https://cursor.directory/rules/):
 
 ```
 browse_cursor_directory category:"python"
-search_cursor_directory query:"react best practices"
+search_cursor_directory query:"react hooks"
 import_cursor_directory_rule slug:"nextjs-react-typescript-cursor-rules"
 ```
 
-## Custom Rules
-
-Create your own rules that persist across sessions:
-
-```
-create_rule projectType:"react-node" name:"My Standards" category:"best-practices" content:"..."
-```
-
-Rules are stored in `~/.stackguide/rules/`.
-
 ## License
 
 GPL-3.0

package/dist/index.js

@@ -9,6 +9,7 @@ import * as knowledgeProvider from './resources/knowledgeProvider.js';
 import * as ruleManager from './services/ruleManager.js';
 import * as webDocs from './services/webDocumentation.js';
 import * as cursorDirectory from './services/cursorDirectory.js';
+import * as autoDetect from './services/autoDetect.js';
 // Server state
 const serverState = {
     activeProjectType: null,
@@ -19,7 +20,7 @@ const serverState = {
 // Create MCP server
 const server = new Server({
     name: 'stackguide-mcp',
-    version: '1.0.0',
+    version: '1.1.0',
 }, {
     capabilities: {
         tools: {},
@@ -31,6 +32,64 @@ const server = new Server({
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     return {
         tools: [
+            // Smart Setup Tools (NEW!)
+            {
+                name: 'auto_setup',
+                description: 'Automatically detect your project type, configure context, and suggest rules. Just provide your project path and StackGuide will do the rest!',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectPath: {
+                            type: 'string',
+                            description: 'Path to your project directory. Use "." for current directory.'
+                        }
+                    },
+                    required: ['projectPath']
+                }
+            },
+            {
+                name: 'detect_project',
+                description: 'Analyze a project directory to detect the framework, languages, and suggest the best configuration',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectPath: {
+                            type: 'string',
+                            description: 'Path to your project directory'
+                        }
+                    },
+                    required: ['projectPath']
+                }
+            },
+            {
+                name: 'suggest_rules',
+                description: 'Get personalized rule suggestions based on your project type and current setup',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectType: {
+                            type: 'string',
+                            description: 'Project type to get suggestions for',
+                            enum: Object.keys(SUPPORTED_PROJECTS)
+                        }
+                    },
+                    required: []
+                }
+            },
+            {
+                name: 'quick_start',
+                description: 'Get a quick start guide for your detected or selected project type. Perfect for new users!',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        projectPath: {
+                            type: 'string',
+                            description: 'Path to analyze (optional if project type already selected)'
+                        }
+                    },
+                    required: []
+                }
+            },
             // Project Type Tools
             {
                 name: 'list_project_types',
@@ -708,6 +767,174 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
     try {
         switch (name) {
+            // Smart Setup Tools
+            case 'auto_setup': {
+                const { projectPath } = args;
+                const resolvedPath = projectPath === '.' ? process.cwd() : projectPath;
+                // Detect project
+                const detection = autoDetect.detectProjectType(resolvedPath);
+                if (!detection.detected || !detection.projectType) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    message: 'Could not auto-detect project type',
+                                    hint: 'Please use select_project_type to manually choose your project type',
+                                    availableTypes: Object.keys(SUPPORTED_PROJECTS)
+                                }, null, 2)
+                            }]
+                    };
+                }
+                // Auto-configure
+                const projectType = detection.projectType;
+                const project = SUPPORTED_PROJECTS[projectType];
+                serverState.activeProjectType = projectType;
+                serverState.loadedRules = rulesProvider.getRulesForProject(projectType);
+                serverState.loadedKnowledge = knowledgeProvider.getKnowledgeForProject(projectType);
+                // Create an active configuration with all rules/knowledge selected
+                serverState.activeConfiguration = {
+                    id: `auto-${projectType}-${Date.now()}`,
+                    name: `Auto Setup - ${project.name}`,
+                    projectType: projectType,
+                    selectedRules: serverState.loadedRules.map(r => r.id),
+                    selectedKnowledge: serverState.loadedKnowledge.map(k => k.id),
+                    customRules: [],
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString()
+                };
+                const setupInstructions = autoDetect.getSetupInstructions(projectType);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `✅ Auto-configured for ${project.name}`,
+                                detection: {
+                                    projectType: detection.projectType,
+                                    confidence: detection.confidence,
+                                    languages: detection.languages,
+                                    frameworks: detection.frameworks,
+                                    indicators: detection.indicators
+                                },
+                                configured: {
+                                    rulesLoaded: serverState.loadedRules.length,
+                                    knowledgeLoaded: serverState.loadedKnowledge.length,
+                                    rules: serverState.loadedRules.map(r => r.name)
+                                },
+                                suggestions: detection.suggestions.slice(0, 5),
+                                nextSteps: [
+                                    'Use get_full_context to see all loaded rules',
+                                    'Use browse_cursor_directory to find community rules',
+                                    'Use save_configuration to save this setup'
+                                ],
+                                setupGuide: setupInstructions
+                            }, null, 2)
+                        }]
+                };
+            }
+            case 'detect_project': {
+                const { projectPath } = args;
+                const resolvedPath = projectPath === '.' ? process.cwd() : projectPath;
+                const detection = autoDetect.detectProjectType(resolvedPath);
+                const quickStart = autoDetect.generateQuickStart(detection);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                ...detection,
+                                quickStart
+                            }, null, 2)
+                        }]
+                };
+            }
+            case 'suggest_rules': {
+                const { projectType } = args;
+                const pt = projectType || serverState.activeProjectType;
+                if (!pt) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: JSON.stringify({
+                                    error: 'No project type specified or selected',
+                                    hint: 'Use auto_setup or select_project_type first, or provide projectType parameter'
+                                }, null, 2)
+                            }]
+                    };
+                }
+                const suggestions = autoDetect.getSuggestions(pt);
+                const builtInRules = rulesProvider.getRulesForProject(pt);
+                const cursorCategories = cursorDirectory.getCursorDirectoryCategories()
+                    .filter(cat => pt.toLowerCase().includes(cat) || cat.includes(pt.split('-')[0]));
+                return {
+                    content: [{
+                            type: 'text',
+                            text: JSON.stringify({
+                                projectType: pt,
+                                suggestions: suggestions,
+                                builtInRules: builtInRules.map(r => ({ id: r.id, name: r.name, category: r.category })),
+                                recommendedCursorCategories: cursorCategories.length > 0 ? cursorCategories : ['Check browse_cursor_directory for all categories'],
+                                tips: [
+                                    'Use browse_cursor_directory to import community rules',
+                                    'Use create_rule to add your own custom rules',
+                                    'Use save_configuration to persist your setup'
+                                ]
+                            }, null, 2)
+                        }]
+                };
+            }
+            case 'quick_start': {
+                const { projectPath } = args;
+                let detection = null;
+                if (projectPath) {
+                    const resolvedPath = projectPath === '.' ? process.cwd() : projectPath;
+                    detection = autoDetect.detectProjectType(resolvedPath);
+                }
+                else if (serverState.activeProjectType) {
+                    // Create a pseudo-detection from active state
+                    detection = {
+                        detected: true,
+                        projectType: serverState.activeProjectType,
+                        confidence: 'high',
+                        indicators: ['Already configured'],
+                        suggestions: autoDetect.getSuggestions(serverState.activeProjectType),
+                        frameworks: SUPPORTED_PROJECTS[serverState.activeProjectType]?.frameworks || [],
+                        languages: SUPPORTED_PROJECTS[serverState.activeProjectType]?.languages || []
+                    };
+                }
+                if (!detection) {
+                    return {
+                        content: [{
+                                type: 'text',
+                                text: `# StackGuide Quick Start
+
+Welcome! Let's get you set up.
+
+## Option 1: Auto-detect (Recommended)
+\`\`\`
+auto_setup projectPath:"."
+\`\`\`
+
+## Option 2: Manual selection
+\`\`\`
+select_project_type projectType:"react-node"
+\`\`\`
+
+## Available project types:
+${Object.values(SUPPORTED_PROJECTS).map(p => `- **${p.type}**: ${p.name}`).join('\n')}
+
+Just tell me about your project and I'll help you configure!`
+                            }]
+                    };
+                }
+                const quickStart = autoDetect.generateQuickStart(detection);
+                return {
+                    content: [{
+                            type: 'text',
+                            text: quickStart
+                        }]
+                };
+            }
             // Project Type Tools
             case 'list_project_types': {
                 const projects = Object.values(SUPPORTED_PROJECTS).map(p => ({
@@ -728,6 +955,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 serverState.activeProjectType = projectType;
                 serverState.loadedRules = rulesProvider.getRulesForProject(projectType);
                 serverState.loadedKnowledge = knowledgeProvider.getKnowledgeForProject(projectType);
+                // Create an active configuration with all rules/knowledge selected
+                serverState.activeConfiguration = {
+                    id: `manual-${projectType}-${Date.now()}`,
+                    name: `Manual Setup - ${project.name}`,
+                    projectType: projectType,
+                    selectedRules: serverState.loadedRules.map(r => r.id),
+                    selectedKnowledge: serverState.loadedKnowledge.map(k => k.id),
+                    customRules: [],
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString()
+                };
                 return {
                     content: [{
                             type: 'text',
@@ -735,7 +973,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 success: true,
                                 message: `Project type "${project.name}" activated`,
                                 rulesLoaded: serverState.loadedRules.length,
-                                knowledgeLoaded: serverState.loadedKnowledge.length
+                                knowledgeLoaded: serverState.loadedKnowledge.length,
+                                rules: serverState.loadedRules.map(r => r.name)
                             }, null, 2)
                         }]
                 };
@@ -988,23 +1227,31 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
             // Context Tools
             case 'get_full_context': {
                 if (!serverState.activeProjectType) {
-                    return { content: [{ type: 'text', text: 'Error: No project type selected.' }] };
-                }
-                const selectedRules = serverState.activeConfiguration?.selectedRules || [];
-                const selectedKnowledge = serverState.activeConfiguration?.selectedKnowledge || [];
+                    return { content: [{ type: 'text', text: 'Error: No project type selected. Use auto_setup or select_project_type first.' }] };
+                }
+                // Use configuration selection if available, otherwise use all loaded rules/knowledge
+                const selectedRules = serverState.activeConfiguration?.selectedRules ||
+                    serverState.loadedRules.map(r => r.id);
+                const selectedKnowledge = serverState.activeConfiguration?.selectedKnowledge ||
+                    serverState.loadedKnowledge.map(k => k.id);
+                // Also get user-created rules for this project type
+                const userRules = ruleManager.getUserRules(serverState.activeProjectType);
+                const userRulesContent = userRules.map((r) => `### ${r.name}\n\n${r.content}`).join('\n\n---\n\n');
                 const rulesContent = rulesProvider.getCombinedRulesContent(selectedRules);
                 const knowledgeContent = knowledgeProvider.getCombinedKnowledgeContent(selectedKnowledge);
                 const fullContext = `# Project Context: ${SUPPORTED_PROJECTS[serverState.activeProjectType].name}
 
-## Rules and Guidelines
+## Rules and Guidelines (${selectedRules.length} loaded)
 
-${rulesContent || 'No rules selected.'}
+${rulesContent || 'No rules available.'}
+
+${userRulesContent ? `---\n\n## Custom Rules\n\n${userRulesContent}` : ''}
 
 ---
 
-## Knowledge Base
+## Knowledge Base (${selectedKnowledge.length} loaded)
 
-${knowledgeContent || 'No knowledge files selected.'}
+${knowledgeContent || 'No knowledge files available.'}
 `;
                 return { content: [{ type: 'text', text: fullContext }] };
             }
@@ -1633,6 +1880,22 @@ ${webDocsContent || 'No web documentation loaded.'}
 server.setRequestHandler(ListPromptsRequestSchema, async () => {
     return {
         prompts: [
+            {
+                name: 'welcome',
+                description: 'Get started with StackGuide - interactive setup wizard',
+                arguments: []
+            },
+            {
+                name: 'configure_project',
+                description: 'Smart project configuration with auto-detection and suggestions',
+                arguments: [
+                    {
+                        name: 'projectPath',
+                        description: 'Path to your project (use "." for current directory)',
+                        required: false
+                    }
+                ]
+            },
             {
                 name: 'setup_project',
                 description: 'Initialize context for a new project',
@@ -1672,6 +1935,110 @@ server.setRequestHandler(ListPromptsRequestSchema, async () => {
 server.setRequestHandler(GetPromptRequestSchema, async (request) => {
     const { name, arguments: promptArgs } = request.params;
     switch (name) {
+        case 'welcome': {
+            const projectTypes = Object.values(SUPPORTED_PROJECTS)
+                .map(p => `- **${p.type}**: ${p.name} (${p.languages.join(', ')})`)
+                .join('\n');
+            return {
+                messages: [{
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `# Welcome to StackGuide! 👋
+
+I'm your AI coding context manager. I help you load the right rules, standards, and knowledge for your project.
+
+## Quick Start
+
+**Option 1: Auto-detect (Recommended)**
+Just tell me: "Set up my project" and I'll analyze your codebase and configure everything automatically.
+
+**Option 2: Tell me about your project**
+Say something like:
+- "I'm working on a React app with Node.js backend"
+- "This is a Django REST API project"
+- "Configure for Next.js with TypeScript"
+
+## Supported Project Types
+${projectTypes}
+
+## What I Can Do
+- 📋 Load coding standards and best practices for your stack
+- 🔍 Browse and import rules from cursor.directory
+- 📚 Provide architecture patterns and solutions
+- 💾 Save configurations for your projects
+- 🌐 Fetch and cache documentation from any URL
+
+## Ready?
+Just describe your project and I'll configure everything for you!`
+                        }
+                    }]
+            };
+        }
+        case 'configure_project': {
+            const projectPath = promptArgs?.projectPath || '.';
+            const resolvedPath = projectPath === '.' ? process.cwd() : projectPath;
+            let detection = null;
+            try {
+                detection = autoDetect.detectProjectType(resolvedPath);
+            }
+            catch {
+                // Path might not exist or not accessible
+            }
+            if (detection?.detected && detection.projectType) {
+                const suggestions = detection.suggestions.slice(0, 5);
+                return {
+                    messages: [{
+                            role: 'user',
+                            content: {
+                                type: 'text',
+                                text: `# Project Detected! 🎯
+
+**Type**: ${detection.projectType}
+**Confidence**: ${detection.confidence}
+**Languages**: ${detection.languages.join(', ')}
+**Frameworks**: ${detection.frameworks.join(', ')}
+
+## How I detected this:
+${detection.indicators.map(i => `- ${i}`).join('\n')}
+
+## Recommended Setup
+
+### Suggested Rules:
+${suggestions.map(s => `- ${s}`).join('\n')}
+
+### Next Steps:
+1. Run \`auto_setup projectPath:"${projectPath}"\` to configure automatically
+2. Or run \`select_project_type projectType:"${detection.projectType}"\` to activate manually
+3. Browse community rules: \`browse_cursor_directory category:"${detection.projectType.split('-')[0]}"\`
+
+Would you like me to set this up for you?`
+                            }
+                        }]
+                };
+            }
+            return {
+                messages: [{
+                        role: 'user',
+                        content: {
+                            type: 'text',
+                            text: `# Let's Configure Your Project 🔧
+
+I couldn't auto-detect the project type from the path provided.
+
+## Tell me about your project:
+- What framework are you using? (React, Django, Next.js, etc.)
+- What language? (TypeScript, Python, etc.)
+- Is it a full-stack app, API, or frontend-only?
+
+## Or choose from available types:
+${Object.values(SUPPORTED_PROJECTS).map(p => `- **${p.type}**: ${p.name}`).join('\n')}
+
+Just tell me and I'll set everything up!`
+                        }
+                    }]
+            };
+        }
         case 'setup_project': {
             const projectType = promptArgs?.projectType;
             const project = SUPPORTED_PROJECTS[projectType];