Module Craft

Vision

Module Craft is a project designed to standardize and enhance the development of software modules through a robust quality control system. By leveraging a Model Control Protocol (MCP), Module Craft provides a set of tools and workflows to ensure that modules are well-planned, secure, performant, and well-documented, regardless of the development environment.

Related MCP server: code-graph-mcp

Core Concepts

The heart of Module Craft is an MCP that exposes a series of atomic "actions" that an AI agent can call. These actions cover the entire lifecycle of a module, from initial planning to final evaluation. This approach allows for the creation of standardized, automated, and intelligent workflows for module development.

Setup

1. Install dependencies:

npm install

2. Build the project:

npm run build

3. Run in development mode:

npm run dev

Usage

This MCP server can be integrated with AI assistants that support the Model Context Protocol. The server provides the following tools:

Available Tools

• plan_module - Generate detailed development plans from module descriptions

• analyze_code_quality - Analyze code for consistency, congruence, and static issues

• check_security_vulnerabilities - Scan for security vulnerabilities (planned)

• evaluate_performance - Analyze performance bottlenecks (planned)

• generate_documentation - Auto-generate code documentation (planned)

• check_accessibility - Check UI accessibility compliance (planned)

• validate_requirements - Validate implementation against requirements (planned)

• track_progress - Track development progress (planned)

Integration

To use this MCP server with an AI assistant, add it to your MCP configuration:

{
  "mcpServers": {
    "module-craft": {
      "command": "node",
      "args": ["dist/index.js"],
      "cwd": "/path/to/module-craft"
    }
  }
}

Development

• npm run dev - Run with hot reload

• npm run build - Build TypeScript to JavaScript

• npm run watch - Watch mode for development

Project Structure

src/
├── index.ts              # Main MCP server
├── types.ts              # TypeScript type definitions
└── actions/
    ├── planModule.ts     # Module planning implementation
    └── analyzeCodeQuality.ts # Code quality analysis

Currently Implemented

✅ plan_module - Fully functional module planning ✅ analyze_code_quality - Code consistency and static analysis

Planned Features

🚧 Security vulnerability scanning 🚧 Performance analysis 🚧 Documentation generation 🚧 Accessibility checking 🚧 Requirements validation 🚧 Progress tracking

MCP Actions

The following actions are available through the Module Craft MCP.

1. Module Planning & Definition

plan_module

• Description: Takes a high-level module description and generates a detailed development plan in Markdown format.

• Outputs:

  • Functional and non-functional requirements.

  • Use cases.

  • Proposed file and directory structure.

  • Potential external dependencies.

2. Quality Assurance

analyze_code_quality

• Description: Analyzes module code to ensure it adheres to best practices.

• Focus Areas:

  • Code Consistency: Naming conventions, formatting.

  • Congruence: Ensures code aligns with the initial plan.

  • Static Analysis: Uses linters to detect common errors and dead code.

check_security_vulnerabilities

• Description: A dedicated security scanner.

• Capabilities:

  • Scans for common vulnerability patterns (e.g., SQL injection, XSS).

  • Checks project dependencies for known vulnerabilities.

evaluate_performance

• Description: Focuses on performance analysis.

• Capabilities:

  • Identifies code bottlenecks.

  • Analyzes algorithmic complexity.

  • Recommends optimizations (e.g., efficient data structures, caching).

3. Documentation

generate_documentation

• Description: Automatically generates and maintains code documentation.

• Capabilities:

  • Summaries: Creates overviews of a module's purpose and functionality.

  • Function/Class Docs: Extracts docstrings to detail inputs, outputs, and purpose.

  • Usage Examples: Generates code snippets demonstrating module usage.

  • Gap Identification: Detects code sections lacking documentation.

4. Accessibility

check_accessibility

• Description: Ensures that UI-related modules are accessible to all users, including those with disabilities, by checking against standards like WCAG.

• Focus Areas:

  • Semantic Validation: Correct use of HTML tags.

  • ARIA Attributes: Proper implementation of ARIA for assistive technologies.

  • Color Contrast: Ensures text is legible.

  • Form Accessibility: Checks for proper labeling and clear instructions.

  • Keyboard Navigation: Confirms all interactive elements are keyboard-accessible.

5. Module Evaluation & Progress Tracking

validate_requirements

• Description: Compares the implemented module against its initial requirements to ensure all functional and non-functional specifications have been met.

• Capabilities:

  • Parses the plan_module output.

  • Maps implemented features back to the requirements document.

  • Identifies any deviations or unimplemented requirements.

track_progress

• Description: Provides an overview of the module's development status.

• Capabilities:

  • Analyzes commit history and code changes to measure progress.

  • Compares the current state against the proposed file structure and milestones.

  • Generates a progress report, highlighting completed, in-progress, and pending tasks.