mcp-ai-agent-guidelines 0.5.0 → 0.7.0

package/README.md

@@ -1,15 +1,20 @@
-## MCP AI Agent Guidelines Server
+# MCP AI Agent Guidelines Server
 
 > [!CAUTION]
-> **Disclaimer -- Experimental / Early Stage:** This project references third‑party models, tools, pricing, and docs that evolve quickly. Treat outputs as recommendations and verify against official docs and your own benchmarks before production use.
+> **Disclaimer -- Experimental / Early Stage:** This _research demonstrator_ project references third‑party models, tools, pricing, and docs that evolve quickly. Treat outputs as recommendations and verify against official docs and your own benchmarks before production use.
 
-[![CI/CD Pipeline](https://github.com/Anselmoo/mcp-ai-agent-guidelines/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/Anselmoo/mcp-ai-agent-guidelines/actions/workflows/ci-cd.yml)
-[![codecov](https://codecov.io/gh/Anselmoo/mcp-ai-agent-guidelines/branch/main/graph/badge.svg)](https://codecov.io/gh/Anselmoo/mcp-ai-agent-guidelines)
-[![Coverage Status](https://img.shields.io/codecov/c/github/Anselmoo/mcp-ai-agent-guidelines/main?label=coverage&logo=codecov)](https://codecov.io/gh/Anselmoo/mcp-ai-agent-guidelines)
-[![NPM version](https://badge.fury.io/js/mcp-ai-agent-guidelines.svg)](https://badge.fury.io/js/mcp-ai-agent-guidelines)
-[![Node.js 20+](https://img.shields.io/badge/node-20%2B-green.svg)](https://nodejs.org/en/download/)
-[![Docker](https://img.shields.io/badge/docker-available-blue.svg)](https://github.com/Anselmoo/mcp-ai-agent-guidelines/pkgs/container/mcp-ai-agent-guidelines)
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](./LICENSE)
+[![CI/CD Pipeline](https://img.shields.io/github/actions/workflow/status/Anselmoo/mcp-ai-agent-guidelines/ci-cd.yml?branch=main&label=CI%2FCD&logo=github-actions&logoColor=white)](https://github.com/Anselmoo/mcp-ai-agent-guidelines/actions/workflows/ci-cd.yml)
+[![Coverage Status](https://img.shields.io/codecov/c/github/Anselmoo/mcp-ai-agent-guidelines/main?label=coverage&logo=codecov&logoColor=white)](https://codecov.io/gh/Anselmoo/mcp-ai-agent-guidelines)
+[![NPM Version](https://img.shields.io/npm/v/mcp-ai-agent-guidelines?label=npm&logo=npm&logoColor=white&color=red)](https://www.npmjs.com/package/mcp-ai-agent-guidelines)
+[![Node.js Version](https://img.shields.io/node/v/mcp-ai-agent-guidelines?label=node&logo=node.js&logoColor=white&color=green)](https://nodejs.org/en/download/)
+[![Docker](https://img.shields.io/badge/docker-available-blue?logo=docker&logoColor=white)](https://github.com/Anselmoo/mcp-ai-agent-guidelines/pkgs/container/mcp-ai-agent-guidelines)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow?logo=opensourceinitiative&logoColor=white)](./LICENSE)
+
+[![GitHub Stars](https://img.shields.io/github/stars/Anselmoo/mcp-ai-agent-guidelines?style=social)](https://github.com/Anselmoo/mcp-ai-agent-guidelines/stargazers)
+[![GitHub Forks](https://img.shields.io/github/forks/Anselmoo/mcp-ai-agent-guidelines?style=social)](https://github.com/Anselmoo/mcp-ai-agent-guidelines/network/members)
+[![GitHub Issues](https://img.shields.io/github/issues/Anselmoo/mcp-ai-agent-guidelines?label=issues&logo=github&logoColor=white)](https://github.com/Anselmoo/mcp-ai-agent-guidelines/issues)
+[![NPM Downloads](https://img.shields.io/npm/dt/mcp-ai-agent-guidelines?label=downloads&logo=npm&logoColor=white&color=blue)](https://www.npmjs.com/package/mcp-ai-agent-guidelines)
+[![GitHub Last Commit](https://img.shields.io/github/last-commit/Anselmoo/mcp-ai-agent-guidelines?logo=github&logoColor=white)](https://github.com/Anselmoo/mcp-ai-agent-guidelines/commits/main)
 
 A Model Context Protocol (MCP) server offering professional tools and templates for hierarchical prompting, code hygiene, visualization, memory optimization, and agile planning.
 
@@ -46,6 +51,7 @@ Explore generated demo reports in the repository:
 - Guidelines Validation: [demos/demo-code-analysis.guidelines.md](./demos/demo-code-analysis.guidelines.md)
 - Hierarchical Prompt (Refactor plan): [demos/demo-code-analysis.hierarchical.prompt.md](./demos/demo-code-analysis.hierarchical.prompt.md)
 - Domain-neutral Prompt Template: [demos/demo-code-analysis.domain-neutral.prompt.md](./demos/demo-code-analysis.domain-neutral.prompt.md)
+- Security Hardening Prompt: [demos/demo-code-analysis.security-hardening.prompt.md](./demos/demo-code-analysis.security-hardening.prompt.md)
 - Spark Prompt Card: [demos/demo-code-analysis.spark.prompt.md](./demos/demo-code-analysis.spark.prompt.md)
 - Memory Context Optimization: [demos/demo-code-analysis.memory.md](./demos/demo-code-analysis.memory.md)
 - Architecture Diagram (Mermaid): [demos/demo-code-analysis.diagram.md](./demos/demo-code-analysis.diagram.md)
@@ -78,8 +84,8 @@ Scripts:
 
 Use buttons below to add this MCP server to VS Code (User Settings → mcp.servers):
 
-[![Install with NPX in VS Code](https://img.shields.io/badge/VS_Code-NPX-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=ai-agent-guidelines&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22mcp-ai-agent-guidelines%22%5D%7D)
-[![Install with NPX in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-NPX-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=ai-agent-guidelines&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22mcp-ai-agent-guidelines%22%5D%7D&quality=insiders)
+[![Install with NPX in VS Code](https://img.shields.io/badge/VS_Code-NPX-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=ai-agent-guidelines&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22mcp-ai-agent-guidelines%3Alatest%22%5D%7D)
+[![Install with NPX in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-NPX-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=ai-agent-guidelines&config=%7B%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22mcp-ai-agent-guidelines%3Alatest%22%5D%7D&quality=insiders)
 [![Install with Docker in VS Code](https://img.shields.io/badge/VS_Code-Docker-0098FF?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=ai-agent-guidelines&config=%7B%22command%22%3A%22docker%22%2C%22args%22%3A%5B%22run%22%2C%22--rm%22%2C%22-i%22%2C%22ghcr.io%2Fanselmoo%2Fmcp-ai-agent-guidelines%3Alatest%22%5D%7D)
 [![Install with Docker in VS Code Insiders](https://img.shields.io/badge/VS_Code_Insiders-Docker-24bfa5?style=flat-square&logo=visualstudiocode&logoColor=white)](https://insiders.vscode.dev/redirect/mcp/install?name=ai-agent-guidelines&config=%7B%22command%22%3A%22docker%22%2C%22args%22%3A%5B%22run%22%2C%22--rm%22%2C%22-i%22%2C%22ghcr.io%2Fanselmoo%2Fmcp-ai-agent-guidelines%3Alatest%22%5D%7D&quality=insiders)
 
@@ -167,6 +173,33 @@ Usage: `code-hygiene-analyzer`
 
 </details>
 
+<details>
+<summary><strong>Security Hardening Prompt Builder</strong> — Build specialized security analysis and vulnerability assessment prompts</summary>
+
+Usage: `security-hardening-prompt-builder`
+
+| Parameter | Required | Description |
+| --------- | -------- | ----------- |
+| `codeContext` | ✅ | Code context or description to analyze for security |
+| `securityFocus` | ❌ | Security analysis focus (vulnerability-analysis, security-hardening, compliance-check, threat-modeling, penetration-testing) |
+| `securityRequirements` | ❌ | Specific security requirements to check |
+| `complianceStandards` | ❌ | Compliance standards (OWASP-Top-10, NIST-Cybersecurity-Framework, ISO-27001, SOC-2, GDPR, HIPAA, PCI-DSS) |
+| `language` | ❌ | Programming language of the code |
+| `riskTolerance` | ❌ | Risk tolerance level (low, medium, high) |
+| `analysisScope` | ❌ | Security areas to focus on (input-validation, authentication, authorization, etc.) |
+| `outputFormat` | ❌ | Output format (detailed, checklist, annotated-code) |
+
+**Security Focus Areas:**
+- 🔍 Vulnerability analysis with OWASP Top 10 coverage
+- 🛡️ Security hardening recommendations
+- 📋 Compliance checking against industry standards
+- ⚠️ Threat modeling and risk assessment
+- 🧪 Penetration testing guidance
+
+**Compliance Standards:** OWASP Top 10, NIST Cybersecurity Framework, ISO 27001, SOC 2, GDPR, HIPAA, PCI-DSS
+
+</details>
+
 <details>
 <summary><strong>Mermaid Diagram Generator</strong> — Generate professional diagrams from text descriptions</summary>
 
@@ -240,10 +273,21 @@ Usage: `guidelines-validator`
 
 ## Versioning
 
-- Package version: `0.1.0` (matches internal resource versions).
+- Package version: `0.7.0` (matches internal resource versions).
 - Tags `vX.Y.Z` trigger CI for NPM and Docker releases.
 - Pin exact versions for production stability.
 
+### Release Setup
+
+Use the [Release Setup Issue Form](.github/ISSUE_TEMPLATE/release-setup.yml) to streamline the release process:
+
+- **Automated version management**: Update version numbers across the codebase
+- **GitHub Copilot compatible**: Structured form enables bot automation
+- **Quality gates**: Pre-release checklist ensures reliability
+- **CI/CD integration**: Supports existing NPM and Docker publishing workflow
+
+To create a new release, [open a release setup issue](../../issues/new?template=release-setup.yml) with the target version and release details.
+
 ## Development
 
 Prerequisites:
@@ -281,6 +325,38 @@ npm run test:coverage:unit # Unit test coverage (text-summary, lcov, html)
 npm run quality          # Type-check + Biome check
 ```
 
+### Git Hooks with Lefthook 🪝
+
+This project uses [Lefthook](https://github.com/evilmartians/lefthook) for fast, reliable Git hooks that enforce code quality and security standards.
+
+**Mandatory for GitHub Copilot Agent**: All quality gates must pass before commits and pushes.
+
+Setup (automatic via `npm install`):
+```bash
+npm run hooks:install    # Install lefthook git hooks
+npm run hooks:uninstall  # Remove lefthook git hooks
+npx lefthook run pre-commit  # Run pre-commit checks manually
+npx lefthook run pre-push    # Run pre-push checks manually
+```
+
+**Pre-commit hooks** (fast, parallel execution):
+- 🔒 **Security**: Gitleaks secret detection
+- 🟨 **Code Quality**: Biome formatting & linting
+- 🔷 **Type Safety**: TypeScript type checking
+- 🧹 **Code Hygiene**: Trailing whitespace & EOF fixes
+
+**Pre-push hooks** (comprehensive validation):
+- 🧪 **Testing**: Full test suite (unit, integration, demo, MCP)
+- ⚡ **Quality**: Type checking + Biome validation
+
+**Why Lefthook?**
+- ⚡ **Fast**: Written in Go, parallel execution
+- 🔄 **Reliable**: Better error handling than pre-commit
+- 🤖 **CI Integration**: Mandatory quality gates for GitHub Copilot Agent
+- 📝 **Simple**: Single YAML configuration file
+
+Configuration: [`lefthook.yml`](./lefthook.yml)
+
 ### Coverage reporting
 
 - CI publishes a coverage summary in the job’s Summary and uploads `coverage/` as an artifact.
@@ -342,3 +418,4 @@ MIT © Anselmoo — see [LICENSE](./LICENSE).
 - Model Context Protocol team for the spec
 - Anthropic for prompt caching research
 - Mermaid community for diagram tooling
+# Test change for Docker fix

package/dist/index.js

@@ -18,15 +18,20 @@ import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema
 import { getPrompt, listPrompts } from "./prompts/index.js";
 // Import resources
 import { getResource, listResources } from "./resources/index.js";
+import { gapFrameworksAnalyzers } from "./tools/analysis/gap-frameworks-analyzers.js";
+import { strategyFrameworksBuilder } from "./tools/analysis/strategy-frameworks-builder.js";
 import { codeHygieneAnalyzer } from "./tools/code-hygiene-analyzer.js";
-import { domainNeutralPromptBuilder } from "./tools/domain-neutral-prompt-builder.js";
+import { designAssistant, } from "./tools/design/index.js";
 import { guidelinesValidator } from "./tools/guidelines-validator.js";
-// Import tool implementations
-import { hierarchicalPromptBuilder } from "./tools/hierarchical-prompt-builder.js";
+import { iterativeCoverageEnhancer } from "./tools/iterative-coverage-enhancer.js";
 import { memoryContextOptimizer } from "./tools/memory-context-optimizer.js";
 import { mermaidDiagramGenerator } from "./tools/mermaid-diagram-generator.js";
 import { modelCompatibilityChecker } from "./tools/model-compatibility-checker.js";
-import { sparkPromptBuilder } from "./tools/spark-prompt-builder.js";
+import { domainNeutralPromptBuilder } from "./tools/prompt/domain-neutral-prompt-builder.js";
+// Import tool implementations
+import { hierarchicalPromptBuilder } from "./tools/prompt/hierarchical-prompt-builder.js";
+import { securityHardeningPromptBuilder } from "./tools/prompt/security-hardening-prompt-builder.js";
+import { sparkPromptBuilder } from "./tools/prompt/spark-prompt-builder.js";
 import { sprintTimelineCalculator } from "./tools/sprint-timeline-calculator.js";
 const server = new Server({
     name: "ai-agent-guidelines",
@@ -134,6 +139,102 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["context", "goal"],
                 },
             },
+            {
+                name: "strategy-frameworks-builder",
+                description: "Compose strategy analysis sections from selected frameworks (SWOT, BSC, VRIO, etc.) with compliant aliases for certain trademarks",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        frameworks: {
+                            type: "array",
+                            items: {
+                                type: "string",
+                                enum: [
+                                    "asIsToBe",
+                                    "whereToPlayHowToWin",
+                                    "balancedScorecard",
+                                    "swot",
+                                    "objectives",
+                                    "portersFiveForces",
+                                    "mckinsey7S",
+                                    "marketAnalysis",
+                                    "strategyMap",
+                                    "visionToMission",
+                                    "stakeholderTheory",
+                                    "values",
+                                    "gapAnalysis",
+                                    "ansoffMatrix",
+                                    "pest",
+                                    "bcgMatrix",
+                                    "blueOcean",
+                                    "scenarioPlanning",
+                                    "vrio",
+                                    "goalBasedPlanning",
+                                    "gartnerQuadrant",
+                                ],
+                            },
+                            description: "Framework identifiers to include",
+                        },
+                        context: { type: "string", description: "Business context" },
+                        objectives: { type: "array", items: { type: "string" } },
+                        market: { type: "string" },
+                        stakeholders: { type: "array", items: { type: "string" } },
+                        constraints: { type: "array", items: { type: "string" } },
+                        includeReferences: { type: "boolean" },
+                        includeMetadata: { type: "boolean" },
+                        inputFile: { type: "string" },
+                    },
+                    required: ["frameworks", "context"],
+                },
+            },
+            {
+                name: "gap-frameworks-analyzers",
+                description: "Analyze gaps between current and desired states using various frameworks (capability, performance, maturity, etc.)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        frameworks: {
+                            type: "array",
+                            items: {
+                                type: "string",
+                                enum: [
+                                    "capability",
+                                    "performance",
+                                    "maturity",
+                                    "skills",
+                                    "technology",
+                                    "process",
+                                    "market",
+                                    "strategic",
+                                    "operational",
+                                    "cultural",
+                                    "security",
+                                    "compliance",
+                                ],
+                            },
+                            description: "Gap analysis framework types to include",
+                        },
+                        currentState: {
+                            type: "string",
+                            description: "Current state description",
+                        },
+                        desiredState: {
+                            type: "string",
+                            description: "Desired state description",
+                        },
+                        context: { type: "string", description: "Analysis context" },
+                        objectives: { type: "array", items: { type: "string" } },
+                        timeframe: { type: "string" },
+                        stakeholders: { type: "array", items: { type: "string" } },
+                        constraints: { type: "array", items: { type: "string" } },
+                        includeReferences: { type: "boolean" },
+                        includeMetadata: { type: "boolean" },
+                        includeActionPlan: { type: "boolean" },
+                        inputFile: { type: "string" },
+                    },
+                    required: ["frameworks", "currentState", "desiredState", "context"],
+                },
+            },
             {
                 name: "spark-prompt-builder",
                 description: "Build a generic UI/UX product prompt from structured inputs (title, features, colors, typography, etc.)",
@@ -334,6 +435,81 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["codeContent", "language"],
                 },
             },
+            {
+                name: "iterative-coverage-enhancer",
+                description: "Iteratively analyze code coverage, detect dead code, generate test suggestions, and adapt coverage thresholds for continuous improvement",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        projectPath: {
+                            type: "string",
+                            description: "Path to the project root directory",
+                        },
+                        language: {
+                            type: "string",
+                            description: "Primary programming language",
+                        },
+                        framework: {
+                            type: "string",
+                            description: "Framework or technology stack",
+                        },
+                        analyzeCoverageGaps: {
+                            type: "boolean",
+                            description: "Analyze and identify coverage gaps",
+                        },
+                        detectDeadCode: {
+                            type: "boolean",
+                            description: "Detect unused code for elimination",
+                        },
+                        generateTestSuggestions: {
+                            type: "boolean",
+                            description: "Generate test suggestions for uncovered code",
+                        },
+                        adaptThresholds: {
+                            type: "boolean",
+                            description: "Recommend adaptive coverage threshold adjustments",
+                        },
+                        currentCoverage: {
+                            type: "object",
+                            description: "Current coverage metrics",
+                            properties: {
+                                statements: { type: "number", minimum: 0, maximum: 100 },
+                                functions: { type: "number", minimum: 0, maximum: 100 },
+                                lines: { type: "number", minimum: 0, maximum: 100 },
+                                branches: { type: "number", minimum: 0, maximum: 100 },
+                            },
+                        },
+                        targetCoverage: {
+                            type: "object",
+                            description: "Target coverage goals",
+                            properties: {
+                                statements: { type: "number", minimum: 0, maximum: 100 },
+                                functions: { type: "number", minimum: 0, maximum: 100 },
+                                lines: { type: "number", minimum: 0, maximum: 100 },
+                                branches: { type: "number", minimum: 0, maximum: 100 },
+                            },
+                        },
+                        outputFormat: {
+                            type: "string",
+                            enum: ["markdown", "json", "text"],
+                            description: "Output format for the report",
+                        },
+                        includeReferences: {
+                            type: "boolean",
+                            description: "Include references and best practice links",
+                        },
+                        includeCodeExamples: {
+                            type: "boolean",
+                            description: "Include code examples in suggestions",
+                        },
+                        generateCIActions: {
+                            type: "boolean",
+                            description: "Generate CI/CD integration actions",
+                        },
+                    },
+                    required: [],
+                },
+            },
             {
                 name: "mermaid-diagram-generator",
                 description: "Generate Mermaid diagrams from text descriptions following best practices",
@@ -514,6 +690,160 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["title", "summary"],
                 },
             },
+            {
+                name: "security-hardening-prompt-builder",
+                description: "Build specialized security hardening and vulnerability analysis prompts for AI-guided security assessment",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        codeContext: {
+                            type: "string",
+                            description: "The code context or description to analyze for security",
+                        },
+                        securityFocus: {
+                            type: "string",
+                            enum: [
+                                "vulnerability-analysis",
+                                "security-hardening",
+                                "compliance-check",
+                                "threat-modeling",
+                                "penetration-testing",
+                            ],
+                            description: "Primary security analysis focus",
+                        },
+                        securityRequirements: {
+                            type: "array",
+                            items: { type: "string" },
+                            description: "Specific security requirements to check",
+                        },
+                        complianceStandards: {
+                            type: "array",
+                            items: {
+                                type: "string",
+                                enum: [
+                                    "OWASP-Top-10",
+                                    "NIST-Cybersecurity-Framework",
+                                    "ISO-27001",
+                                    "SOC-2",
+                                    "GDPR",
+                                    "HIPAA",
+                                    "PCI-DSS",
+                                ],
+                            },
+                            description: "Compliance standards to evaluate against",
+                        },
+                        language: {
+                            type: "string",
+                            description: "Programming language of the code",
+                        },
+                        framework: {
+                            type: "string",
+                            description: "Framework or technology stack",
+                        },
+                        riskTolerance: {
+                            type: "string",
+                            enum: ["low", "medium", "high"],
+                            description: "Risk tolerance level for security assessment",
+                        },
+                        analysisScope: {
+                            type: "array",
+                            items: {
+                                type: "string",
+                                enum: [
+                                    "input-validation",
+                                    "authentication",
+                                    "authorization",
+                                    "data-encryption",
+                                    "session-management",
+                                    "error-handling",
+                                    "logging-monitoring",
+                                    "dependency-security",
+                                    "configuration-security",
+                                    "api-security",
+                                ],
+                            },
+                            description: "Specific security areas to focus analysis on",
+                        },
+                        includeCodeExamples: {
+                            type: "boolean",
+                            description: "Include secure code examples in output",
+                        },
+                        includeMitigations: {
+                            type: "boolean",
+                            description: "Include specific mitigation recommendations",
+                        },
+                        includeTestCases: {
+                            type: "boolean",
+                            description: "Include security test cases",
+                        },
+                        prioritizeFindings: {
+                            type: "boolean",
+                            description: "Prioritize findings by severity",
+                        },
+                        outputFormat: {
+                            type: "string",
+                            enum: ["detailed", "checklist", "annotated-code"],
+                            description: "Preferred output format for security assessment",
+                        },
+                        mode: { type: "string" },
+                        model: { type: "string" },
+                        tools: { type: "array", items: { type: "string" } },
+                        includeFrontmatter: { type: "boolean" },
+                        includeDisclaimer: { type: "boolean" },
+                        includeReferences: { type: "boolean" },
+                        includeTechniqueHints: { type: "boolean" },
+                        includePitfalls: { type: "boolean" },
+                        includeMetadata: { type: "boolean" },
+                        inputFile: { type: "string" },
+                        forcePromptMdStyle: { type: "boolean" },
+                        techniques: {
+                            type: "array",
+                            items: {
+                                type: "string",
+                                enum: [
+                                    "zero-shot",
+                                    "few-shot",
+                                    "chain-of-thought",
+                                    "self-consistency",
+                                    "in-context-learning",
+                                    "generate-knowledge",
+                                    "prompt-chaining",
+                                    "tree-of-thoughts",
+                                    "meta-prompting",
+                                    "rag",
+                                    "react",
+                                    "art",
+                                ],
+                            },
+                            description: "Optional list of technique hints to include",
+                        },
+                        autoSelectTechniques: {
+                            type: "boolean",
+                            description: "Automatically select appropriate techniques",
+                        },
+                        provider: {
+                            type: "string",
+                            enum: [
+                                "gpt-5",
+                                "gpt-4.1",
+                                "claude-4",
+                                "claude-3.7",
+                                "gemini-2.5",
+                                "o4-mini",
+                                "o3-mini",
+                                "other",
+                            ],
+                            description: "Model family for tailored tips",
+                        },
+                        style: {
+                            type: "string",
+                            enum: ["markdown", "xml"],
+                            description: "Preferred prompt formatting style",
+                        },
+                    },
+                    required: ["codeContext"],
+                },
+            },
             {
                 name: "sprint-timeline-calculator",
                 description: "Calculate optimal development cycles and sprint timelines",
@@ -604,6 +934,74 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["practiceDescription", "category"],
                 },
             },
+            {
+                name: "design-assistant",
+                description: "Deterministic, context-driven design assistant with constraint framework for structured design sessions",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        action: {
+                            type: "string",
+                            enum: [
+                                "start-session",
+                                "advance-phase",
+                                "validate-phase",
+                                "evaluate-pivot",
+                                "generate-artifacts",
+                                "enforce-coverage",
+                                "enforce-consistency",
+                                "get-status",
+                                "load-constraints",
+                            ],
+                            description: "Action to perform",
+                        },
+                        sessionId: {
+                            type: "string",
+                            description: "Unique session identifier",
+                        },
+                        config: {
+                            type: "object",
+                            description: "Design session configuration (required for start-session)",
+                            properties: {
+                                sessionId: { type: "string" },
+                                context: { type: "string" },
+                                goal: { type: "string" },
+                                requirements: { type: "array", items: { type: "string" } },
+                                coverageThreshold: { type: "number", default: 85 },
+                                enablePivots: { type: "boolean", default: true },
+                                templateRefs: { type: "array", items: { type: "string" } },
+                                outputFormats: { type: "array", items: { type: "string" } },
+                            },
+                        },
+                        content: {
+                            type: "string",
+                            description: "Content to validate or analyze",
+                        },
+                        phaseId: {
+                            type: "string",
+                            description: "Target phase ID for advance or validate actions",
+                        },
+                        constraintId: {
+                            type: "string",
+                            description: "Specific constraint ID for consistency enforcement",
+                        },
+                        constraintConfig: {
+                            type: "object",
+                            description: "Custom constraint configuration in YAML/JSON format",
+                        },
+                        artifactTypes: {
+                            type: "array",
+                            items: {
+                                type: "string",
+                                enum: ["adr", "specification", "roadmap"],
+                            },
+                            description: "Types of artifacts to generate",
+                            default: ["adr", "specification", "roadmap"],
+                        },
+                    },
+                    required: ["action", "sessionId"],
+                },
+            },
         ],
     };
 });
@@ -613,12 +1011,20 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         switch (name) {
             case "hierarchical-prompt-builder":
                 return hierarchicalPromptBuilder(args);
+            case "strategy-frameworks-builder":
+                return strategyFrameworksBuilder(args);
+            case "gap-frameworks-analyzers":
+                return gapFrameworksAnalyzers(args);
             case "spark-prompt-builder":
                 return sparkPromptBuilder(args);
             case "domain-neutral-prompt-builder":
                 return domainNeutralPromptBuilder(args);
+            case "security-hardening-prompt-builder":
+                return securityHardeningPromptBuilder(args);
             case "code-hygiene-analyzer":
                 return codeHygieneAnalyzer(args);
+            case "iterative-coverage-enhancer":
+                return iterativeCoverageEnhancer(args);
             case "mermaid-diagram-generator":
                 return mermaidDiagramGenerator(args);
             case "memory-context-optimizer":
@@ -629,6 +1035,17 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return modelCompatibilityChecker(args);
             case "guidelines-validator":
                 return guidelinesValidator(args);
+            case "design-assistant": {
+                const result = await designAssistant.processRequest(args);
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: JSON.stringify(result, null, 2),
+                        },
+                    ],
+                };
+            }
             default:
                 throw new Error(`Unknown tool: ${name}`);
         }