mcp-ai-agent-guidelines 0.7.2 → 0.7.4

package/dist/index.js

@@ -18,20 +18,34 @@ import { CallToolRequestSchema, GetPromptRequestSchema, ListPromptsRequestSchema
 import { getPrompt, listPrompts } from "./prompts/index.js";
 // Import resources
 import { getResource, listResources } from "./resources/index.js";
+// Import tool schemas
+import { promptChainingBuilderSchema, promptFlowBuilderSchema, } from "./schemas/flow-tool-schemas.js";
 import { gapFrameworksAnalyzers } from "./tools/analysis/gap-frameworks-analyzers.js";
 import { strategyFrameworksBuilder } from "./tools/analysis/strategy-frameworks-builder.js";
+import { cleanCodeScorer } from "./tools/clean-code-scorer.js";
 import { codeHygieneAnalyzer } from "./tools/code-hygiene-analyzer.js";
 import { designAssistant, } from "./tools/design/index.js";
 import { guidelinesValidator } from "./tools/guidelines-validator.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 { modeSwitcher } from "./tools/mode-switcher.js";
 import { modelCompatibilityChecker } from "./tools/model-compatibility-checker.js";
+import { projectOnboarding } from "./tools/project-onboarding.js";
+import { architectureDesignPromptBuilder } from "./tools/prompt/architecture-design-prompt-builder.js";
+import { codeAnalysisPromptBuilder } from "./tools/prompt/code-analysis-prompt-builder.js";
+import { debuggingAssistantPromptBuilder } from "./tools/prompt/debugging-assistant-prompt-builder.js";
+import { documentationGeneratorPromptBuilder } from "./tools/prompt/documentation-generator-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 { hierarchyLevelSelector } from "./tools/prompt/hierarchy-level-selector.js";
+import { promptChainingBuilder } from "./tools/prompt/prompt-chaining-builder.js";
+import { promptFlowBuilder } from "./tools/prompt/prompt-flow-builder.js";
+import { promptingHierarchyEvaluator } from "./tools/prompt/prompting-hierarchy-evaluator.js";
 import { securityHardeningPromptBuilder } from "./tools/prompt/security-hardening-prompt-builder.js";
 import { sparkPromptBuilder } from "./tools/prompt/spark-prompt-builder.js";
+import { semanticCodeAnalyzer } from "./tools/semantic-code-analyzer.js";
 import { sprintTimelineCalculator } from "./tools/sprint-timeline-calculator.js";
 const server = new Server({
     name: "ai-agent-guidelines",
@@ -139,6 +153,128 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["context", "goal"],
                 },
             },
+            {
+                name: "code-analysis-prompt-builder",
+                description: "Generate comprehensive code analysis prompts with customizable focus areas (security, performance, maintainability)",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        codebase: {
+                            type: "string",
+                            description: "The codebase or code snippet to analyze",
+                        },
+                        focusArea: {
+                            type: "string",
+                            enum: ["security", "performance", "maintainability", "general"],
+                            description: "Specific area to focus on",
+                        },
+                        language: {
+                            type: "string",
+                            description: "Programming language of the code",
+                        },
+                        mode: { type: "string" },
+                        model: { type: "string" },
+                        tools: { type: "array", items: { type: "string" } },
+                        includeFrontmatter: { type: "boolean" },
+                        includeReferences: { type: "boolean" },
+                        includeMetadata: { type: "boolean" },
+                        inputFile: { type: "string" },
+                        forcePromptMdStyle: { type: "boolean" },
+                    },
+                    required: ["codebase"],
+                },
+            },
+            {
+                name: "architecture-design-prompt-builder",
+                description: "Generate system architecture design prompts with scale-appropriate guidance",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        systemRequirements: {
+                            type: "string",
+                            description: "System requirements and constraints",
+                        },
+                        scale: {
+                            type: "string",
+                            enum: ["small", "medium", "large"],
+                            description: "Expected system scale",
+                        },
+                        technologyStack: {
+                            type: "string",
+                            description: "Preferred or required technology stack",
+                        },
+                        mode: { type: "string" },
+                        model: { type: "string" },
+                        tools: { type: "array", items: { type: "string" } },
+                        includeFrontmatter: { type: "boolean" },
+                        includeReferences: { type: "boolean" },
+                        includeMetadata: { type: "boolean" },
+                        inputFile: { type: "string" },
+                        forcePromptMdStyle: { type: "boolean" },
+                    },
+                    required: ["systemRequirements"],
+                },
+            },
+            {
+                name: "debugging-assistant-prompt-builder",
+                description: "Generate systematic debugging and troubleshooting prompts with structured analysis",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        errorDescription: {
+                            type: "string",
+                            description: "Description of the error or issue",
+                        },
+                        context: {
+                            type: "string",
+                            description: "Additional context about the problem",
+                        },
+                        attemptedSolutions: {
+                            type: "string",
+                            description: "Solutions already attempted",
+                        },
+                        mode: { type: "string" },
+                        model: { type: "string" },
+                        tools: { type: "array", items: { type: "string" } },
+                        includeFrontmatter: { type: "boolean" },
+                        includeReferences: { type: "boolean" },
+                        includeMetadata: { type: "boolean" },
+                        inputFile: { type: "string" },
+                        forcePromptMdStyle: { type: "boolean" },
+                    },
+                    required: ["errorDescription"],
+                },
+            },
+            {
+                name: "documentation-generator-prompt-builder",
+                description: "Generate technical documentation prompts tailored to content type and audience",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        contentType: {
+                            type: "string",
+                            description: "Type of documentation (API, user guide, technical spec)",
+                        },
+                        targetAudience: {
+                            type: "string",
+                            description: "Intended audience for the documentation",
+                        },
+                        existingContent: {
+                            type: "string",
+                            description: "Any existing content to build upon",
+                        },
+                        mode: { type: "string" },
+                        model: { type: "string" },
+                        tools: { type: "array", items: { type: "string" } },
+                        includeFrontmatter: { type: "boolean" },
+                        includeReferences: { type: "boolean" },
+                        includeMetadata: { type: "boolean" },
+                        inputFile: { type: "string" },
+                        forcePromptMdStyle: { type: "boolean" },
+                    },
+                    required: ["contentType"],
+                },
+            },
             {
                 name: "strategy-frameworks-builder",
                 description: "Compose strategy analysis sections from selected frameworks (SWOT, BSC, VRIO, etc.) with compliant aliases for certain trademarks",
@@ -412,6 +548,66 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     ],
                 },
             },
+            {
+                name: "clean-code-scorer",
+                description: "Calculate comprehensive Clean Code score (0-100) based on multiple quality metrics including code hygiene, test coverage, TypeScript, linting, documentation, and security",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        projectPath: {
+                            type: "string",
+                            description: "Path to the project root directory",
+                        },
+                        codeContent: {
+                            type: "string",
+                            description: "Code content to analyze",
+                        },
+                        language: {
+                            type: "string",
+                            description: "Programming language",
+                        },
+                        framework: {
+                            type: "string",
+                            description: "Framework or technology stack",
+                        },
+                        coverageMetrics: {
+                            type: "object",
+                            description: "Test coverage metrics",
+                            properties: {
+                                statements: {
+                                    type: "number",
+                                    description: "Statement coverage percentage (0-100)",
+                                },
+                                branches: {
+                                    type: "number",
+                                    description: "Branch coverage percentage (0-100)",
+                                },
+                                functions: {
+                                    type: "number",
+                                    description: "Function coverage percentage (0-100)",
+                                },
+                                lines: {
+                                    type: "number",
+                                    description: "Line coverage percentage (0-100)",
+                                },
+                            },
+                        },
+                        includeReferences: {
+                            type: "boolean",
+                            description: "Include external best-practice links",
+                        },
+                        includeMetadata: {
+                            type: "boolean",
+                            description: "Include metadata in output",
+                        },
+                        inputFile: {
+                            type: "string",
+                            description: "Input file path for reference",
+                        },
+                    },
+                    required: [],
+                },
+            },
             {
                 name: "code-hygiene-analyzer",
                 description: "Analyze codebase for outdated patterns, unused dependencies, and code hygiene issues",
@@ -512,22 +708,50 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             {
                 name: "mermaid-diagram-generator",
-                description: "Generate Mermaid diagrams from text descriptions following best practices",
+                description: "Generate Mermaid diagrams from text descriptions following best practices. Supports advanced diagram types and customization options for richer documentation.",
                 inputSchema: {
                     type: "object",
                     properties: {
                         description: {
                             type: "string",
-                            description: "Description of the system or process to diagram",
+                            description: "Description of the system or process to diagram. Be specific and detailed for better diagram generation.",
                         },
                         diagramType: {
                             type: "string",
-                            enum: ["flowchart", "sequence", "class", "state", "gantt", "pie"],
+                            enum: [
+                                "flowchart",
+                                "sequence",
+                                "class",
+                                "state",
+                                "gantt",
+                                "pie",
+                                "er",
+                                "journey",
+                                "quadrant",
+                                "git-graph",
+                                "mindmap",
+                                "timeline",
+                            ],
                             description: "Type of diagram to generate",
                         },
                         theme: {
                             type: "string",
-                            description: "Visual theme for the diagram",
+                            description: "Visual theme for the diagram (e.g., 'default', 'dark', 'forest', 'neutral')",
+                        },
+                        direction: {
+                            type: "string",
+                            enum: ["TD", "TB", "BT", "LR", "RL"],
+                            description: "Direction for flowcharts: TD/TB (top-down), BT (bottom-top), LR (left-right), RL (right-left)",
+                        },
+                        strict: {
+                            type: "boolean",
+                            description: "If true, never emit invalid diagram; fallback to minimal diagram if needed (default: true)",
+                            default: true,
+                        },
+                        repair: {
+                            type: "boolean",
+                            description: "Attempt auto-repair on diagram validation failure (default: true)",
+                            default: true,
                         },
                         accTitle: {
                             type: "string",
@@ -537,6 +761,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                             type: "string",
                             description: "Accessibility description (added as a Mermaid comment)",
                         },
+                        customStyles: {
+                            type: "string",
+                            description: "Custom CSS/styling directives for advanced customization",
+                        },
+                        advancedFeatures: {
+                            type: "object",
+                            description: "Type-specific advanced features (e.g., {autonumber: true} for sequence diagrams)",
+                        },
                     },
                     required: ["description", "diagramType"],
                 },
@@ -846,7 +1078,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
             },
             {
                 name: "sprint-timeline-calculator",
-                description: "Calculate optimal development cycles and sprint timelines",
+                description: "Calculate optimal development cycles and sprint timelines with dependency-aware scheduling",
                 inputSchema: {
                     type: "object",
                     properties: {
@@ -864,6 +1096,19 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                             type: "number",
                             description: "Team velocity (story points per sprint)",
                         },
+                        optimizationStrategy: {
+                            type: "string",
+                            enum: ["greedy", "linear-programming"],
+                            description: "Optimization strategy: 'greedy' (default, deterministic bin-packing) or 'linear-programming' (future MILP optimization)",
+                        },
+                        includeMetadata: {
+                            type: "boolean",
+                            description: "Include metadata in output",
+                        },
+                        inputFile: {
+                            type: "string",
+                            description: "Input file reference",
+                        },
                     },
                     required: ["tasks", "teamSize"],
                 },
@@ -934,6 +1179,219 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                     required: ["practiceDescription", "category"],
                 },
             },
+            {
+                name: "semantic-code-analyzer",
+                description: "Perform semantic code analysis to identify symbols, structure, dependencies, and patterns. Inspired by Serena's language server-based approach for precise code understanding.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        codeContent: {
+                            type: "string",
+                            description: "Code content to analyze",
+                        },
+                        language: {
+                            type: "string",
+                            description: "Programming language (auto-detected if not provided)",
+                        },
+                        analysisType: {
+                            type: "string",
+                            enum: ["symbols", "structure", "dependencies", "patterns", "all"],
+                            description: "Type of semantic analysis to perform",
+                        },
+                        includeReferences: {
+                            type: "boolean",
+                            description: "Include external reference links",
+                        },
+                        includeMetadata: {
+                            type: "boolean",
+                            description: "Include metadata section",
+                        },
+                        inputFile: {
+                            type: "string",
+                            description: "Optional input file path",
+                        },
+                    },
+                    required: ["codeContent"],
+                },
+            },
+            {
+                name: "project-onboarding",
+                description: "Perform comprehensive project onboarding including structure analysis, dependency detection, and memory generation. Based on Serena's onboarding system for efficient project familiarization.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        projectPath: {
+                            type: "string",
+                            description: "Path to the project directory",
+                        },
+                        projectName: {
+                            type: "string",
+                            description: "Name of the project",
+                        },
+                        projectType: {
+                            type: "string",
+                            enum: ["library", "application", "service", "tool", "other"],
+                            description: "Type of project",
+                        },
+                        analysisDepth: {
+                            type: "string",
+                            enum: ["quick", "standard", "deep"],
+                            description: "Depth of analysis",
+                        },
+                        includeMemories: {
+                            type: "boolean",
+                            description: "Generate project memories",
+                        },
+                        includeReferences: {
+                            type: "boolean",
+                            description: "Include external reference links",
+                        },
+                        includeMetadata: {
+                            type: "boolean",
+                            description: "Include metadata section",
+                        },
+                    },
+                    required: ["projectPath"],
+                },
+            },
+            {
+                name: "mode-switcher",
+                description: "Switch between different agent operation modes (planning, editing, analysis, debugging, etc.) with tailored tool sets and prompting strategies. Based on Serena's flexible mode/context system.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        currentMode: {
+                            type: "string",
+                            enum: [
+                                "planning",
+                                "editing",
+                                "analysis",
+                                "interactive",
+                                "one-shot",
+                                "debugging",
+                                "refactoring",
+                                "documentation",
+                            ],
+                            description: "Current active mode",
+                        },
+                        targetMode: {
+                            type: "string",
+                            enum: [
+                                "planning",
+                                "editing",
+                                "analysis",
+                                "interactive",
+                                "one-shot",
+                                "debugging",
+                                "refactoring",
+                                "documentation",
+                            ],
+                            description: "Mode to switch to",
+                        },
+                        context: {
+                            type: "string",
+                            enum: [
+                                "desktop-app",
+                                "ide-assistant",
+                                "agent",
+                                "terminal",
+                                "collaborative",
+                            ],
+                            description: "Operating context",
+                        },
+                        reason: {
+                            type: "string",
+                            description: "Reason for mode switch",
+                        },
+                        includeReferences: {
+                            type: "boolean",
+                            description: "Include external reference links",
+                        },
+                        includeMetadata: {
+                            type: "boolean",
+                            description: "Include metadata section",
+                        },
+                    },
+                    required: ["targetMode"],
+                },
+            },
+            {
+                name: "prompting-hierarchy-evaluator",
+                description: "Evaluate prompts using hierarchical taxonomy and provide numeric scoring based on clarity, specificity, completeness, and cognitive complexity. Implements reinforcement learning-inspired evaluation metrics.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        promptText: {
+                            type: "string",
+                            description: "The prompt text to evaluate",
+                        },
+                        targetLevel: {
+                            type: "string",
+                            enum: [
+                                "independent",
+                                "indirect",
+                                "direct",
+                                "modeling",
+                                "scaffolding",
+                                "full-physical",
+                            ],
+                            description: "Expected hierarchy level (if known)",
+                        },
+                        context: {
+                            type: "string",
+                            description: "Additional context about the task",
+                        },
+                        includeRecommendations: {
+                            type: "boolean",
+                            description: "Include improvement recommendations",
+                        },
+                        includeReferences: {
+                            type: "boolean",
+                            description: "Include reference links",
+                        },
+                    },
+                    required: ["promptText"],
+                },
+            },
+            {
+                name: "hierarchy-level-selector",
+                description: "Select the most appropriate prompting hierarchy level (independent, indirect, direct, modeling, scaffolding, full-physical) based on task characteristics, agent capability, and autonomy preferences.",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        taskDescription: {
+                            type: "string",
+                            description: "Description of the task the prompt will address",
+                        },
+                        agentCapability: {
+                            type: "string",
+                            enum: ["novice", "intermediate", "advanced", "expert"],
+                            description: "Agent's capability level",
+                        },
+                        taskComplexity: {
+                            type: "string",
+                            enum: ["simple", "moderate", "complex", "very-complex"],
+                            description: "Complexity of the task",
+                        },
+                        autonomyPreference: {
+                            type: "string",
+                            enum: ["low", "medium", "high"],
+                            description: "Desired level of agent autonomy",
+                        },
+                        includeExamples: {
+                            type: "boolean",
+                            description: "Include example prompts for the recommended level",
+                        },
+                        includeReferences: {
+                            type: "boolean",
+                            description: "Include reference links",
+                        },
+                    },
+                    required: ["taskDescription"],
+                },
+            },
+            promptChainingBuilderSchema,
+            promptFlowBuilderSchema,
             {
                 name: "design-assistant",
                 description: "Deterministic, context-driven design assistant with constraint framework for structured design sessions",
@@ -1011,6 +1469,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
         switch (name) {
             case "hierarchical-prompt-builder":
                 return hierarchicalPromptBuilder(args);
+            case "code-analysis-prompt-builder":
+                return codeAnalysisPromptBuilder(args);
+            case "architecture-design-prompt-builder":
+                return architectureDesignPromptBuilder(args);
+            case "debugging-assistant-prompt-builder":
+                return debuggingAssistantPromptBuilder(args);
+            case "documentation-generator-prompt-builder":
+                return documentationGeneratorPromptBuilder(args);
             case "strategy-frameworks-builder":
                 return strategyFrameworksBuilder(args);
             case "gap-frameworks-analyzers":
@@ -1021,6 +1487,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return domainNeutralPromptBuilder(args);
             case "security-hardening-prompt-builder":
                 return securityHardeningPromptBuilder(args);
+            case "clean-code-scorer":
+                return cleanCodeScorer(args);
             case "code-hygiene-analyzer":
                 return codeHygieneAnalyzer(args);
             case "iterative-coverage-enhancer":
@@ -1035,6 +1503,20 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 return modelCompatibilityChecker(args);
             case "guidelines-validator":
                 return guidelinesValidator(args);
+            case "semantic-code-analyzer":
+                return semanticCodeAnalyzer(args);
+            case "project-onboarding":
+                return projectOnboarding(args);
+            case "mode-switcher":
+                return modeSwitcher(args);
+            case "prompting-hierarchy-evaluator":
+                return promptingHierarchyEvaluator(args);
+            case "hierarchy-level-selector":
+                return hierarchyLevelSelector(args);
+            case "prompt-chaining-builder":
+                return promptChainingBuilder(args);
+            case "prompt-flow-builder":
+                return promptFlowBuilder(args);
             case "design-assistant": {
                 const result = await designAssistant.processRequest(args);
                 return {