sdd-mcp-server 1.1.22 → 1.2.0

package/package.json

@@ -1,16 +1,16 @@
 {
   "name": "sdd-mcp-server",
-  "version": "1.1.22",
+  "version": "1.2.0",
   "description": "MCP server for spec-driven development workflows across AI-agent CLIs and IDEs",
   "main": "dist/index.js",
   "bin": {
-    "sdd-mcp-server": "simple-full-server.js",
+    "sdd-mcp-server": "mcp-server.js",
     "sdd-mcp": "dist/index.js"
   },
   "type": "module",
   "files": [
     "dist/**/*",
-    "simple-full-server.js",
+    "mcp-server.js",
     "README.md",
     "LICENSE",
     "package.json"

package/simple-full-server.js

@@ -1,379 +0,0 @@
-#!/usr/bin/env node
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-
-// Define all SDD tools directly (copied from SDDToolAdapter.ts)
-const SDD_TOOLS = [
-  {
-    name: 'sdd-init',
-    tool: {
-      name: 'sdd-init',
-      description: 'Initialize a new SDD project with directory structure and spec files',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          name: { type: 'string', description: 'Project name' },
-          path: { type: 'string', description: 'Project path' },
-          language: { type: 'string', enum: ['en', 'ja', 'zh-TW'], default: 'en' }
-        },
-        required: ['name', 'path']
-      }
-    },
-    handler: async ({ name, path, language = 'en' }) => {
-      return `SDD project "${name}" would be initialized at "${path}" with language "${language}".
-      
-This would create:
-- .kiro/specs/ directory
-- .kiro/steering/ directory  
-- Initial project configuration
-- Language-specific templates`;
-    }
-  },
-  {
-    name: 'sdd-status',
-    tool: {
-      name: 'sdd-status',
-      description: 'Get current project status and workflow phase information',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          projectId: { type: 'string', description: 'Project ID' },
-          projectPath: { type: 'string', description: 'Project path (alternative to ID)' }
-        }
-      }
-    },
-    handler: async ({ projectId, projectPath }) => {
-      return `SDD project status:
-      
-Project: ${projectId || projectPath || 'Current directory'}
-Phase: INIT (No active project found)
-Status: Ready to initialize
-
-Use sdd-init to create a new SDD project.`;
-    }
-  },
-  {
-    name: 'sdd-requirements',
-    tool: {
-      name: 'sdd-requirements',
-      description: 'Generate requirements document template',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          projectId: { type: 'string', description: 'Project ID' }
-        },
-        required: ['projectId']
-      }
-    },
-    handler: async ({ projectId }) => {
-      return `Requirements document template generated for project: ${projectId}
-
-# Requirements Document
-
-## 1. Functional Requirements
-- [Requirement 1]
-- [Requirement 2] 
-- [Requirement 3]
-
-## 2. Non-Functional Requirements
-- Performance requirements
-- Security requirements
-- Scalability requirements
-
-## 3. User Stories
-- As a user, I want...
-- As a developer, I need...
-
-## 4. Acceptance Criteria
-- Criteria 1
-- Criteria 2
-
-This would be saved to .kiro/specs/requirements.md`;
-    }
-  },
-  {
-    name: 'sdd-design',
-    tool: {
-      name: 'sdd-design',
-      description: 'Generate design document template',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          projectId: { type: 'string', description: 'Project ID' }
-        },
-        required: ['projectId']
-      }
-    },
-    handler: async ({ projectId }) => {
-      return `Design document template generated for project: ${projectId}
-
-# Technical Design Document
-
-## 1. Architecture Overview
-- System architecture
-- Component diagram
-- Data flow
-
-## 2. Technology Stack
-- Frontend: [Technology]
-- Backend: [Technology] 
-- Database: [Technology]
-- Infrastructure: [Technology]
-
-## 3. API Design
-- Endpoint specifications
-- Request/Response formats
-- Authentication
-
-## 4. Database Design
-- Entity relationship diagram
-- Schema definitions
-
-This would be saved to .kiro/specs/design.md`;
-    }
-  },
-  {
-    name: 'sdd-tasks',
-    tool: {
-      name: 'sdd-tasks',
-      description: 'Generate implementation tasks document',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          projectId: { type: 'string', description: 'Project ID' }
-        },
-        required: ['projectId']
-      }
-    },
-    handler: async ({ projectId }) => {
-      return `Implementation tasks generated for project: ${projectId}
-
-# Implementation Tasks
-
-## Phase 1: Foundation
-- [ ] Set up development environment
-- [ ] Configure build system
-- [ ] Set up testing framework
-
-## Phase 2: Core Features
-- [ ] Implement core functionality
-- [ ] Add data persistence
-- [ ] Create user interface
-
-## Phase 3: Integration
-- [ ] API integration
-- [ ] Third-party services
-- [ ] Error handling
-
-## Phase 4: Testing & Deployment
-- [ ] Unit tests
-- [ ] Integration tests
-- [ ] Deployment configuration
-
-This would be saved to .kiro/specs/tasks.md`;
-    }
-  },
-  {
-    name: 'sdd-quality-check',
-    tool: {
-      name: 'sdd-quality-check',
-      description: 'Perform code quality analysis with Linus-style review',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          filePath: { type: 'string', description: 'File path to analyze' },
-          codeSnippet: { type: 'string', description: 'Code snippet to analyze' }
-        }
-      }
-    },
-    handler: async ({ filePath, codeSnippet }) => {
-      return `Code quality analysis ${filePath ? `for ${filePath}` : 'for provided code'}:
-
-# Linus-Style Code Review
-
-## Layer 1: Syntax & Style
-✅ Code formatting looks acceptable
-✅ Naming conventions followed
-
-## Layer 2: Logic & Structure  
-✅ Code structure is reasonable
-✅ Logic flow is clear
-
-## Layer 3: Performance
-✅ No obvious performance issues
-✅ Efficient algorithms used
-
-## Layer 4: Security
-✅ No obvious security vulnerabilities
-✅ Input validation present
-
-## Layer 5: Maintainability
-✅ Code is readable and maintainable
-✅ Documentation is adequate
-
-## Overall Assessment
-Code quality: GOOD
-Recommended action: APPROVE
-
-${codeSnippet ? `\nAnalyzed code:\n\`\`\`\n${codeSnippet.slice(0, 200)}...\n\`\`\`` : ''}`;
-    }
-  },
-  {
-    name: 'sdd-implement',
-    tool: {
-      name: 'sdd-implement', 
-      description: 'Get implementation guidance and best practices',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          component: { type: 'string', description: 'Component or feature to implement' },
-          technology: { type: 'string', description: 'Technology stack being used' }
-        }
-      }
-    },
-    handler: async ({ component, technology }) => {
-      return `Implementation guidance for ${component || 'your component'}:
-
-# Implementation Guidelines
-
-## Best Practices
-- Follow SOLID principles
-- Write tests first (TDD)
-- Use consistent naming conventions
-- Document public APIs
-
-## ${technology || 'Technology'}-Specific Guidelines
-- Use framework best practices
-- Follow security guidelines
-- Optimize for performance
-- Handle errors gracefully
-
-## Code Structure
-- Separate concerns properly
-- Use dependency injection
-- Implement proper logging
-- Add monitoring hooks
-
-## Testing Strategy
-- Unit tests for business logic
-- Integration tests for workflows
-- End-to-end tests for user journeys
-
-Implementation steering provided based on SDD methodology.`;
-    }
-  },
-  {
-    name: 'sdd-approve',
-    tool: {
-      name: 'sdd-approve',
-      description: 'Approve workflow phases to progress through SDD stages',
-      inputSchema: {
-        type: 'object',
-        properties: {
-          phase: { 
-            type: 'string', 
-            enum: ['REQUIREMENTS', 'DESIGN', 'TASKS', 'IMPLEMENTATION'],
-            description: 'Phase to approve' 
-          },
-          projectId: { type: 'string', description: 'Project ID' }
-        },
-        required: ['phase']
-      }
-    },
-    handler: async ({ phase, projectId }) => {
-      return `Phase approval for ${projectId || 'current project'}:
-
-# Phase Approval: ${phase}
-
-✅ **${phase} APPROVED**
-
-Requirements met:
-- Documentation complete
-- Review criteria satisfied  
-- Quality gates passed
-- Stakeholder approval received
-
-**Status**: Ready to proceed to next phase
-**Next Steps**: Continue with SDD workflow
-
-Phase transition logged in project history.`;
-    }
-  }
-];
-
-async function createFullServerInstance() {
-  // Create the McpServer for Claude Code compatibility
-  const server = new McpServer({
-    name: "sdd-mcp-server",
-    version: "1.1.22",
-  }, {
-    instructions: `Complete SDD (Spec-Driven Development) MCP server with ${SDD_TOOLS.length} tools:
-
-${SDD_TOOLS.map(tool => `• ${tool.name}: ${tool.tool.description}`).join('\n')}
-
-Use these tools to implement the full 5-phase SDD workflow: INIT → REQUIREMENTS → DESIGN → TASKS → IMPLEMENTATION`,
-  });
-
-  // Register all SDD tools with the McpServer
-  for (const toolDef of SDD_TOOLS) {
-    server.registerTool(toolDef.name, {
-      title: toolDef.tool.name,
-      description: toolDef.tool.description,
-      inputSchema: toolDef.tool.inputSchema,
-    }, async (args) => {
-      try {
-        const result = await toolDef.handler(args);
-        return {
-          content: [
-            {
-              type: "text",
-              text: result
-            },
-          ],
-        };
-      } catch (error) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Error executing ${toolDef.name}: ${error.message}`
-            },
-          ],
-        };
-      }
-    });
-  }
-
-  console.error(`SDD MCP Server ready with ${SDD_TOOLS.length} tools: ${SDD_TOOLS.map(t => t.name).join(', ')}`);
-  
-  return server;
-}
-
-async function main() {
-  try {
-    const server = await createFullServerInstance();
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    console.error("SDD MCP Server running on stdio");
-    
-    // Handle graceful shutdown
-    process.on('SIGINT', async () => {
-      console.error('Shutting down SDD MCP Server...');
-      process.exit(0);
-    });
-    
-    process.on('SIGTERM', async () => {
-      console.error('Shutting down SDD MCP Server...');
-      process.exit(0);
-    });
-    
-  } catch (error) {
-    console.error("Failed to start SDD MCP Server:", error);
-    process.exit(1);
-  }
-}
-
-main().catch((error) => {
-  console.error("SDD MCP Server failed to start:", error);
-  process.exit(1);
-});