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.

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.