@dhvanilpansuriya/code-niyam 1.0.0

package/README.md

@@ -0,0 +1,56 @@
+# Code-Niyam MCP Server
+
+An industrial-grade Model Context Protocol (MCP) server for strict enforcement of UI consistency and architectural patterns.
+
+## 🚀 Overview
+
+**Code-Niyam** enables AI assistants to strictly follow your project's design tokens and coding conventions. Instead of giving the model vague instructions, you use MCP tools to inject high-density, formatted system prompts directly into the model's context.
+
+## ✨ Features
+
+- **Strict UI Enforcement**: Inject design tokens (HSL, spacing, grid) into every session.
+- **Architectural Guardian**: Ensure the model follows your specific coding patterns (Functional vs Class-based, Naming, etc.).
+- **Business Context Injection**: Help the model understand the high-level flow of your project.
+- **Template System**: Manage all rules in clean Markdown (`src/templates/*.md`).
+- **Industrial Standards**: Built with TypeScript, Zod, and Vitest.
+
+## 🛠️ Installation
+
+1. Clone the repository.
+2. Install dependencies:
+   ```bash
+   npm install
+   ```
+3. Build the project:
+   ```bash
+   npm run build
+   ```
+
+## 📖 Usage
+
+### Connecting to AI Clients (Cursor, Claude Desktop, etc.)
+
+Add the following command to your MCP configuration:
+```bash
+node d:/Work/MCP/bin/index.js
+```
+
+### Available Tools
+
+- `get_ui_rules`: Injects the UI design system prompts.
+- `get_code_patterns`: Injects architectural and coding convention prompts.
+- `get_project_flow`: Injects business logic and high-level context.
+
+## 🧪 Testing
+
+Run the test suite using Vitest:
+```bash
+npm test
+```
+
+## 📝 Customization
+
+To change your project's rules, simply edit the Markdown files in the `src/templates/` directory. The MCP server reads these files live on every tool call.
+
+---
+Built with ❤️ for High-Speed Developer Workflows.

package/bin/handlers/code-patterns.d.ts

@@ -0,0 +1,2 @@
+import { ToolHandler } from "./types.js";
+export declare const codePatternsHandler: ToolHandler;

package/bin/handlers/code-patterns.js

@@ -0,0 +1,15 @@
+import { loadTemplate } from "../utils/template-loader.js";
+export const codePatternsHandler = {
+    name: "get_code_patterns",
+    description: "Get strict architectural and coding pattern rules.",
+    inputSchema: {
+        type: "object",
+        properties: {},
+    },
+    handle: async () => {
+        const content = await loadTemplate("code_patterns");
+        return {
+            content: [{ type: "text", text: content }],
+        };
+    },
+};

package/bin/handlers/project-flow.d.ts

@@ -0,0 +1,2 @@
+import { ToolHandler } from "./types.js";
+export declare const projectFlowHandler: ToolHandler;

package/bin/handlers/project-flow.js

@@ -0,0 +1,15 @@
+import { loadTemplate } from "../utils/template-loader.js";
+export const projectFlowHandler = {
+    name: "get_project_flow",
+    description: "Get high-level project flow and business context rules.",
+    inputSchema: {
+        type: "object",
+        properties: {},
+    },
+    handle: async () => {
+        const content = await loadTemplate("project_flow");
+        return {
+            content: [{ type: "text", text: content }],
+        };
+    },
+};

package/bin/handlers/types.d.ts

@@ -0,0 +1,11 @@
+export interface ToolHandler {
+    name: string;
+    description: string;
+    inputSchema: any;
+    handle: (params: any) => Promise<{
+        content: Array<{
+            type: "text";
+            text: string;
+        }>;
+    }>;
+}

package/bin/handlers/types.js

@@ -0,0 +1 @@
+export {};

package/bin/handlers/ui-rules.d.ts

@@ -0,0 +1,2 @@
+import { ToolHandler } from "./types.js";
+export declare const uiRulesHandler: ToolHandler;

package/bin/handlers/ui-rules.js

@@ -0,0 +1,15 @@
+import { loadTemplate } from "../utils/template-loader.js";
+export const uiRulesHandler = {
+    name: "get_ui_rules",
+    description: "Get strict UI consistency and design system rules.",
+    inputSchema: {
+        type: "object",
+        properties: {},
+    },
+    handle: async () => {
+        const content = await loadTemplate("ui_rules");
+        return {
+            content: [{ type: "text", text: content }],
+        };
+    },
+};

package/bin/index.d.ts

@@ -0,0 +1 @@
+export {};

package/bin/index.js

@@ -0,0 +1,70 @@
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { logger } from "./utils/logger.js";
+import { uiRulesHandler } from "./handlers/ui-rules.js";
+import { codePatternsHandler } from "./handlers/code-patterns.js";
+import { projectFlowHandler } from "./handlers/project-flow.js";
+/**
+ * Industrial MCP Server: Context-Guard
+ */
+class ContextGuardServer {
+    server;
+    handlers = new Map();
+    constructor() {
+        this.server = new Server({
+            name: "code-niyam",
+            version: "1.0.0",
+        }, {
+            capabilities: {
+                tools: {},
+            },
+        });
+        // Register Handlers
+        this.registerHandler(uiRulesHandler);
+        this.registerHandler(codePatternsHandler);
+        this.registerHandler(projectFlowHandler);
+        this.server.onerror = (error) => logger.error("[MCP Error]", error);
+        this.setupHandlers();
+    }
+    registerHandler(handler) {
+        this.handlers.set(handler.name, handler);
+    }
+    setupHandlers() {
+        // List available tools
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: Array.from(this.handlers.values()).map((h) => ({
+                name: h.name,
+                description: h.description,
+                inputSchema: h.inputSchema,
+            })),
+        }));
+        // Handle tool execution
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            const { name, arguments: args } = request.params;
+            logger.info(`Executing tool: ${name}`);
+            const handler = this.handlers.get(name);
+            if (!handler) {
+                logger.warn(`Tool not found: ${name}`);
+                throw new Error(`Tool unknown: ${name}`);
+            }
+            try {
+                return await handler.handle(args);
+            }
+            catch (error) {
+                logger.error(`Error in tool ${name}:`, error);
+                throw error;
+            }
+        });
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+        logger.info("Context-Guard MCP Server running on stdio");
+    }
+}
+const server = new ContextGuardServer();
+server.run().catch((err) => {
+    logger.error("Fatal server error:", err);
+    process.exit(1);
+});

package/bin/utils/logger.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Simple structured logger for MCP.
+ * Always logs to stderr because stdio is used for JSON-RPC.
+ */
+export declare const logger: {
+    info: (message: string, meta?: any) => void;
+    error: (message: string, error?: any) => void;
+    warn: (message: string, meta?: any) => void;
+};

package/bin/utils/logger.js

@@ -0,0 +1,23 @@
+/**
+ * Simple structured logger for MCP.
+ * Always logs to stderr because stdio is used for JSON-RPC.
+ */
+export const logger = {
+    info: (message, meta) => {
+        const output = JSON.stringify({ level: "info", message, ...meta });
+        console.error(output);
+    },
+    error: (message, error) => {
+        const output = JSON.stringify({
+            level: "error",
+            message,
+            error: error instanceof Error ? error.message : error,
+            stack: error instanceof Error ? error.stack : undefined,
+        });
+        console.error(output);
+    },
+    warn: (message, meta) => {
+        const output = JSON.stringify({ level: "warn", message, ...meta });
+        console.error(output);
+    },
+};

package/bin/utils/template-loader.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Loads a markdown template from the src/templates directory.
+ * @param templateName The name of the template file (without extension).
+ * @returns The content of the template.
+ */
+export declare function loadTemplate(templateName: string): Promise<string>;

package/bin/utils/template-loader.js

@@ -0,0 +1,23 @@
+import { readFile } from "fs/promises";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const TEMPLATES_DIR = join(__dirname, "..", "templates");
+/**
+ * Loads a markdown template from the src/templates directory.
+ * @param templateName The name of the template file (without extension).
+ * @returns The content of the template.
+ */
+export async function loadTemplate(templateName) {
+    const filePath = join(TEMPLATES_DIR, `${templateName}.md`);
+    try {
+        return await readFile(filePath, "utf-8");
+    }
+    catch (error) {
+        // Avoid logging errors during tests for expected failures
+        if (process.env.NODE_ENV !== "test") {
+            console.error(`Failed to load template ${templateName}:`, error);
+        }
+        return `### Error\nTemplate ${templateName} not found.`;
+    }
+}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@dhvanilpansuriya/code-niyam",
+  "version": "1.0.0",
+  "description": "Industrial-grade MCP server for strict context and UI rule enforcement.",
+  "type": "module",
+  "main": "bin/index.js",
+  "bin": {
+    "code-niyam": "bin/index.js"
+  },
+  "files": [
+    "bin",
+    "src/templates"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc -w",
+    "start": "node bin/index.js",
+    "dev": "ts-node src/index.ts",
+    "lint": "eslint src --ext .ts",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.6.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "typescript": "^5.8.2",
+    "ts-node": "^10.9.2",
+    "eslint": "^9.22.0",
+    "vitest": "^3.0.8",
+    "prettier": "^3.5.3"
+  }
+}

package/src/templates/code_patterns.md

@@ -0,0 +1,22 @@
+### !! STRICT_FOLLOW_INSTRUCTION !!
+You are now in **ARCHITECTURAL GUARDIAN MODE**. Your primary objective is to ensure the codebase remains clean, predictable, and scalable.
+
+#### 1. Coding Standards
+- **Functional First**: Use functional components and pure functions. Avoid classes unless absolutely necessary for state management.
+- **Explicit Types**: No `any` types. Strictly define interfaces or types for all function signatures and data structures.
+- **Naming**: 
+  - Components: `PascalCase`
+  - Functions/Variables: `camelCase`
+  - Constants: `SCREAMING_SNAKE_CASE`
+
+#### 2. Error Handling
+- Use structured error responses.
+- Never swallow errors; always log them with context using the project's logging utility.
+- Use `try/catch` blocks at the boundary of external interactions (APIs, DBs).
+
+#### 3. Module Structure
+- Keep logic in `src/handlers` and utilities in `src/utils`.
+- Export only what is necessary using explicit `export` statements.
+
+---
+*Consistency is the key to velocity.*

package/src/templates/project_flow.md

@@ -0,0 +1,17 @@
+### !! STRICT_FOLLOW_INSTRUCTION !!
+You are now in **PROJECT LOGIC MODE**. Your primary objective is to maintain consistency with the high-level business goals and technical flow.
+
+#### 1. Project Overview
+- **Goal**: Build a high-speed, contextual MCP server for design consistency.
+- **Audience**: Developers looking to reduce "context-swapping" debt.
+
+#### 2. Key Flows
+- **Rule Injection**: Every task must begin by identifying which "Guardian" (UI, Architecture, or Flow) is relevant.
+- **Prompt Precedence**: Static rules in this MCP take precedence over general LLM knowledge.
+
+#### 3. Success Metrics
+- **Coding Speed**: Minimal back-and-forth for design corrections.
+- **Consistency**: 100% adherence to HSL tokens and 4px grids.
+
+---
+*Stay aligned with the mission.*

package/src/templates/ui_rules.md

@@ -0,0 +1,20 @@
+### !! STRICT_FOLLOW_INSTRUCTION !!
+You are now in **UI CONSISTENCY MODE**. Your primary objective is to maintain pixel-perfect adherence to the project's design system.
+
+#### 1. Color Palette (HSL)
+- **Background**: `hsl(220, 15%, 10%)` (Deep Space)
+- **Surface**: `hsl(220, 15%, 15%)` (Steel Gray)
+- **Primary**: `hsl(250, 70%, 60%)` (Electric Purple)
+- **Text-Base**: `hsl(0, 0%, 95%)`
+
+#### 2. Layout & Spacing
+- **Grid**: Use a 12-column flex or grid system.
+- **Spacing Scale**: 4px base (4, 8, 12, 16, 24, 32, 48, 64).
+- **Rounding**: `rounded-xl` (12px) for cards, `rounded-full` for buttons.
+
+#### 3. Component Usage
+- Prefer **Radix UI** primitives and **Lucide React** icons.
+- Avoid hardcoded hex codes; always use CSS variables or Tailwind tokens.
+
+---
+*Failure to follow these rules will result in a visual debt warning.*