# 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:
```bash
npm install
```

2. Build the project:
```bash
npm run build
```

3. Run in development mode:
```bash
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:

```json
{
  "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.