sdd-mcp-server 1.3.10 → 1.3.11

package/README.md

@@ -6,7 +6,7 @@
 
 A Model Context Protocol (MCP) server implementing Spec-Driven Development (SDD) workflows for AI-agent CLIs and IDEs like Claude Code, Cursor, and others.
 
-> **✅ v1.3.10 Update**: AI-driven MCP server with language-agnostic workflow tools. Fixed all hardcoded templates, made tools truly universal for any programming language/framework, and added comprehensive AGENTS.md support with complete steering file descriptions and inclusion modes. Perfect for Spring Boot, React, Python, Go, and any other project!
+> **✅ v1.3.11 Update**: AI-driven MCP server with language-agnostic workflow tools. CRITICAL FIX: sdd-steering now generates actual analyzed content instead of instruction templates. Fixed all hardcoded templates, made tools truly universal for any programming language/framework. Perfect for Spring Boot, React, Python, Go, and any other project!
 
 ## 🚀 Quick Start
 

package/documentGenerator.js

@@ -26,13 +26,11 @@ export async function analyzeProject(projectPath) {
     packageManager: 'npm'
   };
 
-  console.log(`Analyzing project at: ${projectPath}`);
 
   try {
     // Check for package.json
     const packageJsonPath = path.join(projectPath, 'package.json');
     if (fs.existsSync(packageJsonPath)) {
-      console.log('Found package.json, parsing...');
       try {
         const packageJsonContent = fs.readFileSync(packageJsonPath, 'utf8');
         const packageJson = JSON.parse(packageJsonContent);
@@ -46,9 +44,7 @@ export async function analyzeProject(projectPath) {
         analysis.devDependencies = Object.keys(packageJson.devDependencies || {});
         analysis.scripts = packageJson.scripts || {};
         
-        console.log(`Extracted: name=${analysis.name}, deps=${analysis.dependencies.length}, devDeps=${analysis.devDependencies.length}`);
       } catch (parseError) {
-        console.log('Error parsing package.json:', parseError.message);
         // Use fallbacks if package.json is malformed
         analysis.name = getDirectoryBasedName(projectPath);
         analysis.description = generateSmartDescription(analysis.name);
@@ -103,17 +99,60 @@ export async function analyzeProject(projectPath) {
         analysis.buildTool = 'Rollup';
       }
     } else {
-      console.log('No package.json found, using directory-based fallbacks');
       // No package.json found, use directory-based fallbacks
       analysis.name = getDirectoryBasedName(projectPath);
       analysis.description = generateSmartDescription(analysis.name);
     }
 
-    // Check for Java/Maven/Gradle projects
+
+
+    // Check for yarn or pnpm
+    if (fs.existsSync(path.join(projectPath, 'yarn.lock'))) {
+      analysis.packageManager = 'yarn';
+    } else if (fs.existsSync(path.join(projectPath, 'pnpm-lock.yaml'))) {
+      analysis.packageManager = 'pnpm';
+    }
+
+    // Scan directory structure
+    const items = fs.readdirSync(projectPath, { withFileTypes: true });
+    for (const item of items) {
+      if (item.isDirectory() && !item.name.startsWith('.') && item.name !== 'node_modules') {
+        analysis.directories.push(item.name);
+
+        // Check for test directories
+        if (item.name === 'test' || item.name === 'tests' || item.name === '__tests__' || item.name === 'spec') {
+          analysis.hasTests = true;
+        }
+      } else if (item.isFile()) {
+        analysis.files.push(item.name);
+
+        // Check for Docker
+        if (item.name === 'Dockerfile' || item.name === 'docker-compose.yml') {
+          analysis.hasDocker = true;
+        }
+
+        // Check for CI/CD
+        if (item.name === '.gitlab-ci.yml' || item.name === '.travis.yml' || item.name === 'Jenkinsfile') {
+          analysis.hasCI = true;
+        }
+      }
+    }
+
+    // Check for Java/Maven/Gradle projects (including multi-module projects)
     const pomPath = path.join(projectPath, 'pom.xml');
     const gradlePath = path.join(projectPath, 'build.gradle');
     const gradleKtsPath = path.join(projectPath, 'build.gradle.kts');
-    if (fs.existsSync(pomPath) || fs.existsSync(gradlePath) || fs.existsSync(gradleKtsPath)) {
+
+    // Also check for Maven/Gradle projects in subdirectories (multi-module projects)
+    const hasSubmodulePom = analysis.directories.some(dir =>
+      fs.existsSync(path.join(projectPath, dir, 'pom.xml'))
+    );
+    const hasSubmoduleGradle = analysis.directories.some(dir =>
+      fs.existsSync(path.join(projectPath, dir, 'build.gradle')) ||
+      fs.existsSync(path.join(projectPath, dir, 'build.gradle.kts'))
+    );
+
+    if (fs.existsSync(pomPath) || fs.existsSync(gradlePath) || fs.existsSync(gradleKtsPath) || hasSubmodulePom || hasSubmoduleGradle) {
       analysis.language = 'java';
       if (fs.existsSync(pomPath)) {
         analysis.packageManager = 'maven';
@@ -134,6 +173,36 @@ export async function analyzeProject(projectPath) {
             analysis.hasTests = true;
           }
         } catch {}
+      } else if (hasSubmodulePom) {
+        // Analyze submodule pom.xml files for multi-module projects
+        analysis.packageManager = 'maven';
+        analysis.buildTool = 'Maven';
+        let foundSpringBoot = false;
+        let foundJUnit = false;
+
+        for (const dir of analysis.directories) {
+          const subPomPath = path.join(projectPath, dir, 'pom.xml');
+          if (fs.existsSync(subPomPath)) {
+            try {
+              const pom = fs.readFileSync(subPomPath, 'utf8');
+              if (/spring-boot/i.test(pom) || /org\.springframework\.boot/i.test(pom)) {
+                foundSpringBoot = true;
+              }
+              if (/junit|jupiter/i.test(pom)) {
+                foundJUnit = true;
+              }
+            } catch {}
+          }
+        }
+
+        if (foundSpringBoot) {
+          analysis.framework = 'Spring Boot';
+          analysis.architecture = 'Microservices (Spring Boot)';
+        }
+        if (foundJUnit) {
+          analysis.testFramework = 'JUnit';
+          analysis.hasTests = true;
+        }
       } else {
         analysis.packageManager = 'gradle';
         analysis.buildTool = 'Gradle';
@@ -159,38 +228,6 @@ export async function analyzeProject(projectPath) {
       }
     }
 
-    // Check for yarn or pnpm
-    if (fs.existsSync(path.join(projectPath, 'yarn.lock'))) {
-      analysis.packageManager = 'yarn';
-    } else if (fs.existsSync(path.join(projectPath, 'pnpm-lock.yaml'))) {
-      analysis.packageManager = 'pnpm';
-    }
-
-    // Scan directory structure
-    const items = fs.readdirSync(projectPath, { withFileTypes: true });
-    for (const item of items) {
-      if (item.isDirectory() && !item.name.startsWith('.') && item.name !== 'node_modules') {
-        analysis.directories.push(item.name);
-        
-        // Check for test directories
-        if (item.name === 'test' || item.name === 'tests' || item.name === '__tests__' || item.name === 'spec') {
-          analysis.hasTests = true;
-        }
-      } else if (item.isFile()) {
-        analysis.files.push(item.name);
-        
-        // Check for Docker
-        if (item.name === 'Dockerfile' || item.name === 'docker-compose.yml') {
-          analysis.hasDocker = true;
-        }
-        
-        // Check for CI/CD
-        if (item.name === '.gitlab-ci.yml' || item.name === '.travis.yml' || item.name === 'Jenkinsfile') {
-          analysis.hasCI = true;
-        }
-      }
-    }
-
     // Check for GitHub Actions
     if (fs.existsSync(path.join(projectPath, '.github', 'workflows'))) {
       analysis.hasCI = true;
@@ -220,8 +257,7 @@ export async function analyzeProject(projectPath) {
 
   // Validate and improve analysis results before returning
   const finalAnalysis = validateAndImproveAnalysis(analysis, projectPath);
-  console.log(`Final analysis: ${finalAnalysis.name} - ${finalAnalysis.architecture}`);
-  
+
   return finalAnalysis;
 }
 
@@ -243,7 +279,16 @@ function getDirectoryBasedName(projectPath) {
  */
 function generateSmartDescription(projectName) {
   const name = projectName.toLowerCase();
-  
+
+  if (name.includes('microservices') && name.includes('spring')) {
+    return 'Spring Boot microservices application demonstrating distributed architecture patterns and service communication';
+  }
+  if (name.includes('microservices')) {
+    return 'Microservices architecture demonstration with multiple independent services';
+  }
+  if (name.includes('spring') && name.includes('boot')) {
+    return 'Spring Boot application built with modern Java frameworks and best practices';
+  }
   if (name.includes('api')) {
     return `RESTful API service for ${projectName.replace(/api/i, '').trim()} application`;
   }
@@ -265,7 +310,7 @@ function generateSmartDescription(projectName) {
   if (name.includes('tool')) {
     return `Development tool for ${projectName.replace(/tool/i, '').trim()} workflows`;
   }
-  
+
   return `${projectName} application providing core functionality and services`;
 }
 
@@ -309,8 +354,7 @@ function validateAndImproveAnalysis(analysis, projectPath) {
 export function generateProductDocument(analysis) {
   // Validate analysis has meaningful content
   if (isAnalysisGeneric(analysis)) {
-    console.log('Analysis appears generic, enhancing with intelligent defaults');
-    analysis = enhanceGenericAnalysis(analysis);
+      analysis = enhanceGenericAnalysis(analysis);
   }
   
   const features = extractFeatures(analysis);

package/mcp-server.js

@@ -859,136 +859,13 @@ server.registerTool("sdd-steering", {
       updateMode = (productExists || techExists || structureExists) ? 'update' : 'create';
     }
     
-    // Create AI-driven steering documents with project analysis instructions
-    const productContent = `# Product Overview
+    // Generate actual analyzed content using documentGenerator functions
+    const analysis = await analyzeProject(currentPath);
+    const productContent = generateProductDocument(analysis);
+    const techContent = generateTechDocument(analysis);
+    const structureContent = generateStructureDocument(analysis);
 
-## Project Analysis Required
-
-Please analyze the current project structure and create a comprehensive product overview document. Consider:
-
-1. **Project Discovery**: Examine files, directory structure, configuration files, and documentation
-2. **Purpose Identification**: Understand what this project/product does based on code, README, and structure
-3. **Feature Analysis**: Identify key features and capabilities
-4. **User Base**: Determine who uses this product and how
-5. **Business Context**: Understand the value proposition and use cases
-
-## Instructions for AI Agent
-
-Generate a product.md document that includes:
-
-### Product Description
-- What this project/product does
-- Its primary purpose and goals
-- Key value propositions
-
-### Core Features
-- Main features and capabilities
-- What makes it unique or valuable
-
-### Target Users
-- Who uses this product
-- Primary user personas
-- Use cases and scenarios
-
-### Success Metrics
-- How success is measured
-- Key performance indicators
-- Business objectives
-
-## Current Project Information
-- Project Path: ${currentPath}
-- Mode: ${updateMode}
-- Analysis Date: ${new Date().toISOString()}
-
-**Note**: This template will be replaced by AI-generated content specific to your actual project.`;
-
-    const techContent = `# Technology Stack
-
-## Project Analysis Required
-
-Please analyze the current project's technology stack and create a comprehensive technical overview. Consider:
-
-1. **Language Detection**: Identify primary programming languages used
-2. **Framework Analysis**: Detect frameworks, libraries, and dependencies
-3. **Architecture Review**: Understand the system architecture and patterns
-4. **Build System**: Identify build tools, package managers, and deployment methods
-5. **Development Environment**: Understand development setup and requirements
-
-## Instructions for AI Agent
-
-Generate a tech.md document that includes:
-
-### Technology Stack
-- Programming languages used
-- Frameworks and libraries
-- Key dependencies and their purposes
-
-### Architecture
-- System architecture (monolith, microservices, etc.)
-- Design patterns employed
-- Database and storage solutions
-
-### Development Environment
-- Required tools and versions
-- Build and deployment processes
-- Development workflows
-
-### Dependencies
-- Production dependencies and their roles
-- Development dependencies and tooling
-- Version constraints and compatibility
-
-## Current Project Information
-- Project Path: ${currentPath}
-- Mode: ${updateMode}
-- Analysis Date: ${new Date().toISOString()}
-
-**Note**: This template will be replaced by AI-generated content specific to your actual technology stack.`;
-
-    const structureContent = `# Project Structure
-
-## Project Analysis Required
-
-Please analyze the current project's organization and create a comprehensive structure overview. Consider:
-
-1. **Directory Structure**: Examine folder organization and naming conventions
-2. **Code Organization**: Understand how code is structured and modularized
-3. **Configuration**: Identify configuration files and their purposes
-4. **Documentation**: Locate and assess existing documentation
-5. **Patterns**: Identify organizational patterns and conventions
-
-## Instructions for AI Agent
-
-Generate a structure.md document that includes:
-
-### File Organization
-- Directory structure and purpose of each folder
-- Naming conventions and patterns
-- Key files and their roles
-
-### Code Architecture
-- How code is organized and modularized
-- Separation of concerns
-- Layer structure (if applicable)
-
-### Configuration Management
-- Configuration files and their purposes
-- Environment-specific settings
-- Build and deployment configurations
-
-### Documentation Structure
-- Location of documentation
-- Types of documentation available
-- Documentation standards and conventions
-
-## Current Project Information
-- Project Path: ${currentPath}
-- Mode: ${updateMode}
-- Analysis Date: ${new Date().toISOString()}
-
-**Note**: This template will be replaced by AI-generated content specific to your actual project structure.`;
-
-    // Write the AI-driven instruction documents
+    // Write the analyzed steering documents
     await fs.writeFile(path.join(steeringPath, 'product.md'), productContent);
     await fs.writeFile(path.join(steeringPath, 'tech.md'), techContent);
     await fs.writeFile(path.join(steeringPath, 'structure.md'), structureContent);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdd-mcp-server",
-  "version": "1.3.10",
+  "version": "1.3.11",
   "description": "MCP server for spec-driven development workflows across AI-agent CLIs and IDEs",
   "main": "dist/index.js",
   "bin": {