This is page 12 of 24. Use http://codebase.md/sparesparrow/mcp-project-orchestrator?lines=true&page={x} to view the full context.
# Directory Structure
```
├── .cursorrules
├── .env.example
├── .github
│ └── workflows
│ ├── build.yml
│ ├── ci-cd.yml
│ ├── ci.yml
│ ├── deploy.yml
│ ├── ecosystem-monitor.yml
│ ├── fan-out-orchestrator.yml
│ └── release.yml
├── .gitignore
├── .pre-commit-config.yaml
├── AUTOMOTIVE_CAMERA_SYSTEM_SUMMARY.md
├── automotive-camera-system
│ ├── docs
│ │ └── IMPLEMENTACE_CS.md
│ └── README.md
├── AWS_MCP_IMPLEMENTATION_SUMMARY.md
├── AWS_MCP_QUICKSTART.md
├── AWS_SIP_TRUNK_DEPLOYMENT_COMPLETE.md
├── aws-sip-trunk
│ ├── .gitignore
│ ├── config
│ │ ├── extensions.conf.j2
│ │ └── pjsip.conf.j2
│ ├── DEPLOYMENT_SUMMARY.md
│ ├── docs
│ │ ├── DEPLOYMENT.md
│ │ └── TROUBLESHOOTING.md
│ ├── PROJECT_INDEX.md
│ ├── pyproject.toml
│ ├── QUICKSTART.md
│ ├── README.md
│ ├── scripts
│ │ ├── deploy-asterisk-aws.sh
│ │ └── user-data.sh
│ ├── terraform
│ │ ├── ec2.tf
│ │ ├── main.tf
│ │ ├── monitoring.tf
│ │ ├── networking.tf
│ │ ├── outputs.tf
│ │ ├── storage.tf
│ │ ├── terraform.tfvars.example
│ │ └── variables.tf
│ ├── tests
│ │ └── test_sip_connectivity.py
│ └── VERIFICATION_CHECKLIST.md
├── CLAUDE.md
├── component_templates.json
├── conanfile.py
├── config
│ ├── default.json
│ └── project_orchestration.json
├── Containerfile
├── cursor-templates
│ └── openssl
│ ├── linux-dev.mdc.jinja2
│ └── shared.mdc.jinja2
├── data
│ └── prompts
│ └── templates
│ ├── advanced-multi-server-template.json
│ ├── analysis-assistant.json
│ ├── analyze-mermaid-diagram.json
│ ├── architecture-design-assistant.json
│ ├── code-diagram-documentation-creator.json
│ ├── code-refactoring-assistant.json
│ ├── code-review-assistant.json
│ ├── collaborative-development.json
│ ├── consolidated-interfaces-template.json
│ ├── could-you-interpret-the-assumed-applicat.json
│ ├── data-analysis-template.json
│ ├── database-query-assistant.json
│ ├── debugging-assistant.json
│ ├── development-system-prompt-zcna0.json
│ ├── development-system-prompt.json
│ ├── development-workflow.json
│ ├── docker-compose-prompt-combiner.json
│ ├── docker-containerization-guide.json
│ ├── docker-mcp-servers-orchestration.json
│ ├── foresight-assistant.json
│ ├── generate-different-types-of-questions-ab.json
│ ├── generate-mermaid-diagram.json
│ ├── image-1-describe-the-icon-in-one-sen.json
│ ├── initialize-project-setup-for-a-new-micro.json
│ ├── install-dependencies-build-run-test.json
│ ├── mcp-code-generator.json
│ ├── mcp-integration-assistant.json
│ ├── mcp-resources-explorer.json
│ ├── mcp-resources-integration.json
│ ├── mcp-server-configurator.json
│ ├── mcp-server-dev-prompt-combiner.json
│ ├── mcp-server-integration-template.json
│ ├── mcp-template-system.json
│ ├── mermaid-analysis-expert.json
│ ├── mermaid-class-diagram-generator.json
│ ├── mermaid-diagram-generator.json
│ ├── mermaid-diagram-modifier.json
│ ├── modify-mermaid-diagram.json
│ ├── monorepo-migration-guide.json
│ ├── multi-resource-context.json
│ ├── project-analysis-assistant.json
│ ├── prompt-combiner-interface.json
│ ├── prompt-templates.json
│ ├── repository-explorer.json
│ ├── research-assistant.json
│ ├── sequential-data-analysis.json
│ ├── solid-code-analysis-visualizer.json
│ ├── task-list-helper-8ithy.json
│ ├── template-based-mcp-integration.json
│ ├── templates.json
│ ├── test-prompt.json
│ └── you-are-limited-to-respond-yes-or-no-onl.json
├── docs
│ ├── AWS_MCP.md
│ ├── AWS.md
│ ├── CONAN.md
│ └── integration.md
├── elevenlabs-agents
│ ├── agent-prompts.json
│ └── README.md
├── IMPLEMENTATION_STATUS.md
├── integration_plan.md
├── LICENSE
├── MANIFEST.in
├── mcp-project-orchestrator
│ └── openssl
│ ├── .github
│ │ └── workflows
│ │ └── validate-cursor-config.yml
│ ├── conanfile.py
│ ├── CURSOR_DEPLOYMENT_POLISH.md
│ ├── cursor-rules
│ │ ├── mcp.json.jinja2
│ │ ├── prompts
│ │ │ ├── fips-compliance.md.jinja2
│ │ │ ├── openssl-coding-standards.md.jinja2
│ │ │ └── pr-review.md.jinja2
│ │ └── rules
│ │ ├── ci-linux.mdc.jinja2
│ │ ├── linux-dev.mdc.jinja2
│ │ ├── macos-dev.mdc.jinja2
│ │ ├── shared.mdc.jinja2
│ │ └── windows-dev.mdc.jinja2
│ ├── docs
│ │ └── cursor-configuration-management.md
│ ├── examples
│ │ └── example-workspace
│ │ ├── .cursor
│ │ │ ├── mcp.json
│ │ │ └── rules
│ │ │ ├── linux-dev.mdc
│ │ │ └── shared.mdc
│ │ ├── .gitignore
│ │ ├── CMakeLists.txt
│ │ ├── conanfile.py
│ │ ├── profiles
│ │ │ ├── linux-gcc-debug.profile
│ │ │ └── linux-gcc-release.profile
│ │ ├── README.md
│ │ └── src
│ │ ├── crypto_utils.cpp
│ │ ├── crypto_utils.h
│ │ └── main.cpp
│ ├── IMPLEMENTATION_SUMMARY.md
│ ├── mcp_orchestrator
│ │ ├── __init__.py
│ │ ├── cli.py
│ │ ├── conan_integration.py
│ │ ├── cursor_config.py
│ │ ├── cursor_deployer.py
│ │ ├── deploy_cursor.py
│ │ ├── env_config.py
│ │ ├── platform_detector.py
│ │ └── yaml_validator.py
│ ├── openssl-cursor-example-workspace-20251014_121133.zip
│ ├── pyproject.toml
│ ├── README.md
│ ├── requirements.txt
│ ├── scripts
│ │ └── create_example_workspace.py
│ ├── setup.py
│ ├── test_deployment.py
│ └── tests
│ ├── __init__.py
│ ├── test_cursor_deployer.py
│ └── test_template_validation.py
├── printcast-agent
│ ├── .env.example
│ ├── config
│ │ └── asterisk
│ │ └── extensions.conf
│ ├── Containerfile
│ ├── docker-compose.yml
│ ├── pyproject.toml
│ ├── README.md
│ ├── scripts
│ │ └── docker-entrypoint.sh
│ ├── src
│ │ ├── integrations
│ │ │ ├── __init__.py
│ │ │ ├── asterisk.py
│ │ │ ├── content.py
│ │ │ ├── delivery.py
│ │ │ ├── elevenlabs.py
│ │ │ └── printing.py
│ │ ├── mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── main.py
│ │ │ └── server.py
│ │ └── orchestration
│ │ ├── __init__.py
│ │ └── workflow.py
│ └── tests
│ └── test_mcp_server.py
├── project_orchestration.json
├── project_templates.json
├── pyproject.toml
├── README.md
├── REFACTORING_COMPLETED.md
├── REFACTORING_RECOMMENDATIONS.md
├── requirements.txt
├── scripts
│ ├── archive
│ │ ├── init_claude_test.sh
│ │ ├── init_postgres.sh
│ │ ├── start_mcp_servers.sh
│ │ └── test_claude_desktop.sh
│ ├── consolidate_mermaid.py
│ ├── consolidate_prompts.py
│ ├── consolidate_resources.py
│ ├── consolidate_templates.py
│ ├── INSTRUCTIONS.md
│ ├── README.md
│ ├── setup_aws_mcp.sh
│ ├── setup_mcp.sh
│ ├── setup_orchestrator.sh
│ ├── setup_project.py
│ └── test_mcp.sh
├── src
│ └── mcp_project_orchestrator
│ ├── __init__.py
│ ├── __main__.py
│ ├── aws_mcp.py
│ ├── cli
│ │ └── __init__.py
│ ├── cli.py
│ ├── commands
│ │ └── openssl_cli.py
│ ├── core
│ │ ├── __init__.py
│ │ ├── base.py
│ │ ├── config.py
│ │ ├── exceptions.py
│ │ ├── fastmcp.py
│ │ ├── logging.py
│ │ └── managers.py
│ ├── cursor_deployer.py
│ ├── ecosystem_monitor.py
│ ├── fan_out_orchestrator.py
│ ├── fastmcp.py
│ ├── mcp-py
│ │ ├── AggregateVersions.py
│ │ ├── CustomBashTool.py
│ │ ├── FileAnnotator.py
│ │ ├── mcp-client.py
│ │ ├── mcp-server.py
│ │ ├── MermaidDiagramGenerator.py
│ │ ├── NamingAgent.py
│ │ └── solid-analyzer-agent.py
│ ├── mermaid
│ │ ├── __init__.py
│ │ ├── generator.py
│ │ ├── mermaid_orchestrator.py
│ │ ├── renderer.py
│ │ ├── templates
│ │ │ ├── AbstractFactory-diagram.json
│ │ │ ├── Adapter-diagram.json
│ │ │ ├── Analyze_Mermaid_Diagram.json
│ │ │ ├── Builder-diagram.json
│ │ │ ├── Chain-diagram.json
│ │ │ ├── Code_Diagram_Documentation_Creator.json
│ │ │ ├── Command-diagram.json
│ │ │ ├── Decorator-diagram.json
│ │ │ ├── Facade-diagram.json
│ │ │ ├── Factory-diagram.json
│ │ │ ├── flowchart
│ │ │ │ ├── AbstractFactory-diagram.json
│ │ │ │ ├── Adapter-diagram.json
│ │ │ │ ├── Analyze_Mermaid_Diagram.json
│ │ │ │ ├── Builder-diagram.json
│ │ │ │ ├── Chain-diagram.json
│ │ │ │ ├── Code_Diagram_Documentation_Creator.json
│ │ │ │ ├── Command-diagram.json
│ │ │ │ ├── Decorator-diagram.json
│ │ │ │ ├── Facade-diagram.json
│ │ │ │ ├── Factory-diagram.json
│ │ │ │ ├── Generate_Mermaid_Diagram.json
│ │ │ │ ├── generated_diagram.json
│ │ │ │ ├── integration.json
│ │ │ │ ├── Iterator-diagram.json
│ │ │ │ ├── Mediator-diagram.json
│ │ │ │ ├── Memento-diagram.json
│ │ │ │ ├── Mermaid_Analysis_Expert.json
│ │ │ │ ├── Mermaid_Class_Diagram_Generator.json
│ │ │ │ ├── Mermaid_Diagram_Generator.json
│ │ │ │ ├── Mermaid_Diagram_Modifier.json
│ │ │ │ ├── Modify_Mermaid_Diagram.json
│ │ │ │ ├── Observer-diagram.json
│ │ │ │ ├── Prototype-diagram.json
│ │ │ │ ├── Proxy-diagram.json
│ │ │ │ ├── README.json
│ │ │ │ ├── Singleton-diagram.json
│ │ │ │ ├── State-diagram.json
│ │ │ │ ├── Strategy-diagram.json
│ │ │ │ ├── TemplateMethod-diagram.json
│ │ │ │ ├── theme_dark.json
│ │ │ │ ├── theme_default.json
│ │ │ │ ├── theme_pastel.json
│ │ │ │ ├── theme_vibrant.json
│ │ │ │ └── Visitor-diagram.json
│ │ │ ├── Generate_Mermaid_Diagram.json
│ │ │ ├── generated_diagram.json
│ │ │ ├── index.json
│ │ │ ├── integration.json
│ │ │ ├── Iterator-diagram.json
│ │ │ ├── Mediator-diagram.json
│ │ │ ├── Memento-diagram.json
│ │ │ ├── Mermaid_Analysis_Expert.json
│ │ │ ├── Mermaid_Class_Diagram_Generator.json
│ │ │ ├── Mermaid_Diagram_Generator.json
│ │ │ ├── Mermaid_Diagram_Modifier.json
│ │ │ ├── Modify_Mermaid_Diagram.json
│ │ │ ├── Observer-diagram.json
│ │ │ ├── Prototype-diagram.json
│ │ │ ├── Proxy-diagram.json
│ │ │ ├── README.json
│ │ │ ├── Singleton-diagram.json
│ │ │ ├── State-diagram.json
│ │ │ ├── Strategy-diagram.json
│ │ │ ├── TemplateMethod-diagram.json
│ │ │ ├── theme_dark.json
│ │ │ ├── theme_default.json
│ │ │ ├── theme_pastel.json
│ │ │ ├── theme_vibrant.json
│ │ │ └── Visitor-diagram.json
│ │ └── types.py
│ ├── project_orchestration.py
│ ├── prompt_manager
│ │ ├── __init__.py
│ │ ├── loader.py
│ │ ├── manager.py
│ │ └── template.py
│ ├── prompts
│ │ ├── __dirname.json
│ │ ├── __image_1___describe_the_icon_in_one_sen___.json
│ │ ├── __init__.py
│ │ ├── __type.json
│ │ ├── _.json
│ │ ├── _DEFAULT_OPEN_DELIMITER.json
│ │ ├── _emojiRegex.json
│ │ ├── _UUID_CHARS.json
│ │ ├── a.json
│ │ ├── A.json
│ │ ├── Aa.json
│ │ ├── aAnnotationPadding.json
│ │ ├── absoluteThresholdGroup.json
│ │ ├── add.json
│ │ ├── ADDITIONAL_PROPERTY_FLAG.json
│ │ ├── Advanced_Multi-Server_Integration_Template.json
│ │ ├── allOptionsList.json
│ │ ├── analysis
│ │ │ ├── Data_Analysis_Template.json
│ │ │ ├── index.json
│ │ │ ├── Mermaid_Analysis_Expert.json
│ │ │ ├── Sequential_Data_Analysis_with_MCP_Integration.json
│ │ │ └── SOLID_Code_Analysis_Visualizer.json
│ │ ├── Analysis_Assistant.json
│ │ ├── Analyze_Mermaid_Diagram.json
│ │ ├── ANDROID_EVERGREEN_FIRST.json
│ │ ├── ANSI_ESCAPE_BELL.json
│ │ ├── architecture
│ │ │ ├── index.json
│ │ │ └── PromptCombiner_Interface.json
│ │ ├── Architecture_Design_Assistant.json
│ │ ├── argsTag.json
│ │ ├── ARROW.json
│ │ ├── assistant
│ │ │ ├── Analysis_Assistant.json
│ │ │ ├── Architecture_Design_Assistant.json
│ │ │ ├── Code_Refactoring_Assistant.json
│ │ │ ├── Code_Review_Assistant.json
│ │ │ ├── Database_Query_Assistant.json
│ │ │ ├── Debugging_Assistant.json
│ │ │ ├── Foresight_Assistant.json
│ │ │ ├── index.json
│ │ │ ├── MCP_Integration_Assistant.json
│ │ │ ├── Project_Analysis_Assistant.json
│ │ │ └── Research_Assistant.json
│ │ ├── astralRange.json
│ │ ├── at.json
│ │ ├── authorization_endpoint.json
│ │ ├── b.json
│ │ ├── BABELIGNORE_FILENAME.json
│ │ ├── BACKSLASH.json
│ │ ├── backupId.json
│ │ ├── BANG.json
│ │ ├── BASE64_MAP.json
│ │ ├── baseFlags.json
│ │ ├── Basic_Template.json
│ │ ├── bgModel.json
│ │ ├── bignum.json
│ │ ├── blockKeywordsStr.json
│ │ ├── BOMChar.json
│ │ ├── boundary.json
│ │ ├── brackets.json
│ │ ├── BROWSER_VAR.json
│ │ ├── bt.json
│ │ ├── BUILTIN.json
│ │ ├── BULLET.json
│ │ ├── c.json
│ │ ├── C.json
│ │ ├── CACHE_VERSION.json
│ │ ├── cacheControl.json
│ │ ├── cacheProp.json
│ │ ├── category.py
│ │ ├── CHANGE_EVENT.json
│ │ ├── CHAR_CODE_0.json
│ │ ├── chars.json
│ │ ├── cjsPattern.json
│ │ ├── cKeywords.json
│ │ ├── classForPercent.json
│ │ ├── classStr.json
│ │ ├── clientFirstMessageBare.json
│ │ ├── cmd.json
│ │ ├── Code_Diagram_Documentation_Creator.json
│ │ ├── Code_Refactoring_Assistant.json
│ │ ├── Code_Review_Assistant.json
│ │ ├── code.json
│ │ ├── coding
│ │ │ ├── __dirname.json
│ │ │ ├── _.json
│ │ │ ├── _DEFAULT_OPEN_DELIMITER.json
│ │ │ ├── _emojiRegex.json
│ │ │ ├── _UUID_CHARS.json
│ │ │ ├── a.json
│ │ │ ├── A.json
│ │ │ ├── aAnnotationPadding.json
│ │ │ ├── absoluteThresholdGroup.json
│ │ │ ├── add.json
│ │ │ ├── ADDITIONAL_PROPERTY_FLAG.json
│ │ │ ├── allOptionsList.json
│ │ │ ├── ANDROID_EVERGREEN_FIRST.json
│ │ │ ├── ANSI_ESCAPE_BELL.json
│ │ │ ├── argsTag.json
│ │ │ ├── ARROW.json
│ │ │ ├── astralRange.json
│ │ │ ├── at.json
│ │ │ ├── authorization_endpoint.json
│ │ │ ├── BABELIGNORE_FILENAME.json
│ │ │ ├── BACKSLASH.json
│ │ │ ├── BANG.json
│ │ │ ├── BASE64_MAP.json
│ │ │ ├── baseFlags.json
│ │ │ ├── bgModel.json
│ │ │ ├── bignum.json
│ │ │ ├── blockKeywordsStr.json
│ │ │ ├── BOMChar.json
│ │ │ ├── boundary.json
│ │ │ ├── brackets.json
│ │ │ ├── BROWSER_VAR.json
│ │ │ ├── bt.json
│ │ │ ├── BUILTIN.json
│ │ │ ├── BULLET.json
│ │ │ ├── c.json
│ │ │ ├── C.json
│ │ │ ├── CACHE_VERSION.json
│ │ │ ├── cacheControl.json
│ │ │ ├── cacheProp.json
│ │ │ ├── CHANGE_EVENT.json
│ │ │ ├── CHAR_CODE_0.json
│ │ │ ├── chars.json
│ │ │ ├── cjsPattern.json
│ │ │ ├── cKeywords.json
│ │ │ ├── classForPercent.json
│ │ │ ├── classStr.json
│ │ │ ├── clientFirstMessageBare.json
│ │ │ ├── cmd.json
│ │ │ ├── code.json
│ │ │ ├── colorCode.json
│ │ │ ├── comma.json
│ │ │ ├── command.json
│ │ │ ├── configJsContent.json
│ │ │ ├── connectionString.json
│ │ │ ├── cssClassStr.json
│ │ │ ├── currentBoundaryParse.json
│ │ │ ├── d.json
│ │ │ ├── data.json
│ │ │ ├── DATA.json
│ │ │ ├── dataWebpackPrefix.json
│ │ │ ├── debug.json
│ │ │ ├── decodeStateVectorV2.json
│ │ │ ├── DEFAULT_DELIMITER.json
│ │ │ ├── DEFAULT_DIAGRAM_DIRECTION.json
│ │ │ ├── DEFAULT_JS_PATTERN.json
│ │ │ ├── DEFAULT_LOG_TARGET.json
│ │ │ ├── defaultHelpOpt.json
│ │ │ ├── defaultHost.json
│ │ │ ├── deferY18nLookupPrefix.json
│ │ │ ├── DELIM.json
│ │ │ ├── delimiter.json
│ │ │ ├── DEPRECATION.json
│ │ │ ├── destMain.json
│ │ │ ├── DID_NOT_THROW.json
│ │ │ ├── direction.json
│ │ │ ├── displayValue.json
│ │ │ ├── DNS.json
│ │ │ ├── doc.json
│ │ │ ├── DOCUMENTATION_NOTE.json
│ │ │ ├── DOT.json
│ │ │ ├── DOTS.json
│ │ │ ├── dummyCompoundId.json
│ │ │ ├── e.json
│ │ │ ├── E.json
│ │ │ ├── earlyHintsLink.json
│ │ │ ├── elide.json
│ │ │ ├── EMPTY.json
│ │ │ ├── end.json
│ │ │ ├── endpoint.json
│ │ │ ├── environment.json
│ │ │ ├── ERR_CODE.json
│ │ │ ├── errMessage.json
│ │ │ ├── errMsg.json
│ │ │ ├── ERROR_MESSAGE.json
│ │ │ ├── error.json
│ │ │ ├── ERROR.json
│ │ │ ├── ERRORCLASS.json
│ │ │ ├── errorMessage.json
│ │ │ ├── es6Default.json
│ │ │ ├── ESC.json
│ │ │ ├── Escapable.json
│ │ │ ├── escapedChar.json
│ │ │ ├── escapeFuncStr.json
│ │ │ ├── escSlash.json
│ │ │ ├── ev.json
│ │ │ ├── event.json
│ │ │ ├── execaMessage.json
│ │ │ ├── EXPECTED_LABEL.json
│ │ │ ├── expected.json
│ │ │ ├── expectedString.json
│ │ │ ├── expression1.json
│ │ │ ├── EXTENSION.json
│ │ │ ├── f.json
│ │ │ ├── FAIL_TEXT.json
│ │ │ ├── FILE_BROWSER_FACTORY.json
│ │ │ ├── fill.json
│ │ │ ├── findPackageJson.json
│ │ │ ├── fnKey.json
│ │ │ ├── FORMAT.json
│ │ │ ├── formatted.json
│ │ │ ├── from.json
│ │ │ ├── fullpaths.json
│ │ │ ├── FUNC_ERROR_TEXT.json
│ │ │ ├── GenStateSuspendedStart.json
│ │ │ ├── GENSYNC_EXPECTED_START.json
│ │ │ ├── gutter.json
│ │ │ ├── h.json
│ │ │ ├── handlerFuncName.json
│ │ │ ├── HASH_UNDEFINED.json
│ │ │ ├── head.json
│ │ │ ├── helpMessage.json
│ │ │ ├── HINT_ARG.json
│ │ │ ├── HOOK_RETURNED_NOTHING_ERROR_MESSAGE.json
│ │ │ ├── i.json
│ │ │ ├── id.json
│ │ │ ├── identifier.json
│ │ │ ├── Identifier.json
│ │ │ ├── INDENT.json
│ │ │ ├── indentation.json
│ │ │ ├── index.json
│ │ │ ├── INDIRECTION_FRAGMENT.json
│ │ │ ├── input.json
│ │ │ ├── inputText.json
│ │ │ ├── insert.json
│ │ │ ├── insertPromptQuery.json
│ │ │ ├── INSPECT_MAX_BYTES.json
│ │ │ ├── intToCharMap.json
│ │ │ ├── IS_ITERABLE_SENTINEL.json
│ │ │ ├── IS_KEYED_SENTINEL.json
│ │ │ ├── isConfigType.json
│ │ │ ├── isoSentinel.json
│ │ │ ├── isSourceNode.json
│ │ │ ├── j.json
│ │ │ ├── JAKE_CMD.json
│ │ │ ├── JEST_GLOBAL_NAME.json
│ │ │ ├── JEST_GLOBALS_MODULE_NAME.json
│ │ │ ├── JSON_SYNTAX_CHAR.json
│ │ │ ├── json.json
│ │ │ ├── jsonType.json
│ │ │ ├── jupyter_namespaceObject.json
│ │ │ ├── JUPYTERLAB_DOCMANAGER_PLUGIN_ID.json
│ │ │ ├── k.json
│ │ │ ├── KERNEL_STATUS_ERROR_CLASS.json
│ │ │ ├── key.json
│ │ │ ├── l.json
│ │ │ ├── labelId.json
│ │ │ ├── LATEST_PROTOCOL_VERSION.json
│ │ │ ├── LETTERDASHNUMBER.json
│ │ │ ├── LF.json
│ │ │ ├── LIMIT_REPLACE_NODE.json
│ │ │ ├── logTime.json
│ │ │ ├── lstatkey.json
│ │ │ ├── lt.json
│ │ │ ├── m.json
│ │ │ ├── maliciousPayload.json
│ │ │ ├── mask.json
│ │ │ ├── match.json
│ │ │ ├── matchingDelim.json
│ │ │ ├── MAXIMUM_MESSAGE_SIZE.json
│ │ │ ├── mdcContent.json
│ │ │ ├── MERMAID_DOM_ID_PREFIX.json
│ │ │ ├── message.json
│ │ │ ├── messages.json
│ │ │ ├── meth.json
│ │ │ ├── minimatch.json
│ │ │ ├── MOCK_CONSTRUCTOR_NAME.json
│ │ │ ├── MOCKS_PATTERN.json
│ │ │ ├── moduleDirectory.json
│ │ │ ├── msg.json
│ │ │ ├── mtr.json
│ │ │ ├── multipartType.json
│ │ │ ├── n.json
│ │ │ ├── N.json
│ │ │ ├── name.json
│ │ │ ├── NATIVE_PLATFORM.json
│ │ │ ├── newUrl.json
│ │ │ ├── NM.json
│ │ │ ├── NO_ARGUMENTS.json
│ │ │ ├── NO_DIFF_MESSAGE.json
│ │ │ ├── NODE_MODULES.json
│ │ │ ├── nodeInternalPrefix.json
│ │ │ ├── nonASCIIidentifierStartChars.json
│ │ │ ├── nonKey.json
│ │ │ ├── NOT_A_DOT.json
│ │ │ ├── notCharacterOrDash.json
│ │ │ ├── notebookURL.json
│ │ │ ├── notSelector.json
│ │ │ ├── nullTag.json
│ │ │ ├── num.json
│ │ │ ├── NUMBER.json
│ │ │ ├── o.json
│ │ │ ├── O.json
│ │ │ ├── octChar.json
│ │ │ ├── octetStreamType.json
│ │ │ ├── operators.json
│ │ │ ├── out.json
│ │ │ ├── OUTSIDE_JEST_VM_PROTOCOL.json
│ │ │ ├── override.json
│ │ │ ├── p.json
│ │ │ ├── PACKAGE_FILENAME.json
│ │ │ ├── PACKAGE_JSON.json
│ │ │ ├── packageVersion.json
│ │ │ ├── paddedNumber.json
│ │ │ ├── page.json
│ │ │ ├── parseClass.json
│ │ │ ├── path.json
│ │ │ ├── pathExt.json
│ │ │ ├── pattern.json
│ │ │ ├── PatternBoolean.json
│ │ │ ├── pBuiltins.json
│ │ │ ├── pFloatForm.json
│ │ │ ├── pkg.json
│ │ │ ├── PLUGIN_ID_DOC_MANAGER.json
│ │ │ ├── plusChar.json
│ │ │ ├── PN_CHARS.json
│ │ │ ├── point.json
│ │ │ ├── prefix.json
│ │ │ ├── PRETTY_PLACEHOLDER.json
│ │ │ ├── property_prefix.json
│ │ │ ├── pubkey256.json
│ │ │ ├── Q.json
│ │ │ ├── qmark.json
│ │ │ ├── QO.json
│ │ │ ├── query.json
│ │ │ ├── querystringType.json
│ │ │ ├── queryText.json
│ │ │ ├── r.json
│ │ │ ├── R.json
│ │ │ ├── rangeStart.json
│ │ │ ├── re.json
│ │ │ ├── reI.json
│ │ │ ├── REQUIRED_FIELD_SYMBOL.json
│ │ │ ├── reserve.json
│ │ │ ├── resolvedDestination.json
│ │ │ ├── resolverDir.json
│ │ │ ├── responseType.json
│ │ │ ├── result.json
│ │ │ ├── ROOT_DESCRIBE_BLOCK_NAME.json
│ │ │ ├── ROOT_NAMESPACE_NAME.json
│ │ │ ├── ROOT_TASK_NAME.json
│ │ │ ├── route.json
│ │ │ ├── RUNNING_TEXT.json
│ │ │ ├── s.json
│ │ │ ├── SCHEMA_PATH.json
│ │ │ ├── se.json
│ │ │ ├── SEARCHABLE_CLASS.json
│ │ │ ├── secret.json
│ │ │ ├── selector.json
│ │ │ ├── SEMVER_SPEC_VERSION.json
│ │ │ ├── sensitiveHeaders.json
│ │ │ ├── sep.json
│ │ │ ├── separator.json
│ │ │ ├── SHAPE_STATE.json
│ │ │ ├── shape.json
│ │ │ ├── SHARED.json
│ │ │ ├── short.json
│ │ │ ├── side.json
│ │ │ ├── SNAPSHOT_VERSION.json
│ │ │ ├── SOURCE_MAPPING_PREFIX.json
│ │ │ ├── source.json
│ │ │ ├── sourceMapContent.json
│ │ │ ├── SPACE_SYMBOL.json
│ │ │ ├── SPACE.json
│ │ │ ├── sqlKeywords.json
│ │ │ ├── sranges.json
│ │ │ ├── st.json
│ │ │ ├── ST.json
│ │ │ ├── stack.json
│ │ │ ├── START_HIDING.json
│ │ │ ├── START_OF_LINE.json
│ │ │ ├── startNoTraversal.json
│ │ │ ├── STATES.json
│ │ │ ├── stats.json
│ │ │ ├── statSync.json
│ │ │ ├── storageStatus.json
│ │ │ ├── storageType.json
│ │ │ ├── str.json
│ │ │ ├── stringifiedObject.json
│ │ │ ├── stringPath.json
│ │ │ ├── stringResult.json
│ │ │ ├── stringTag.json
│ │ │ ├── strValue.json
│ │ │ ├── style.json
│ │ │ ├── SUB_NAME.json
│ │ │ ├── subkey.json
│ │ │ ├── SUBPROTOCOL.json
│ │ │ ├── SUITE_NAME.json
│ │ │ ├── symbolPattern.json
│ │ │ ├── symbolTag.json
│ │ │ ├── t.json
│ │ │ ├── T.json
│ │ │ ├── templateDir.json
│ │ │ ├── tempName.json
│ │ │ ├── text.json
│ │ │ ├── time.json
│ │ │ ├── titleSeparator.json
│ │ │ ├── tmpl.json
│ │ │ ├── tn.json
│ │ │ ├── toValue.json
│ │ │ ├── transform.json
│ │ │ ├── trustProxyDefaultSymbol.json
│ │ │ ├── typeArgumentsKey.json
│ │ │ ├── typeKey.json
│ │ │ ├── typeMessage.json
│ │ │ ├── typesRegistryPackageName.json
│ │ │ ├── u.json
│ │ │ ├── UNDEFINED.json
│ │ │ ├── unit.json
│ │ │ ├── UNMATCHED_SURROGATE_PAIR_REPLACE.json
│ │ │ ├── ur.json
│ │ │ ├── USAGE.json
│ │ │ ├── value.json
│ │ │ ├── Vr.json
│ │ │ ├── watchmanURL.json
│ │ │ ├── webkit.json
│ │ │ ├── xhtml.json
│ │ │ ├── XP_DEFAULT_PATHEXT.json
│ │ │ └── y.json
│ │ ├── Collaborative_Development_with_MCP_Integration.json
│ │ ├── colorCode.json
│ │ ├── comma.json
│ │ ├── command.json
│ │ ├── completionShTemplate.json
│ │ ├── configJsContent.json
│ │ ├── connectionString.json
│ │ ├── Consolidated_TypeScript_Interfaces_Template.json
│ │ ├── Could_you_interpret_the_assumed_applicat___.json
│ │ ├── cssClassStr.json
│ │ ├── currentBoundaryParse.json
│ │ ├── d.json
│ │ ├── Data_Analysis_Template.json
│ │ ├── data.json
│ │ ├── DATA.json
│ │ ├── Database_Query_Assistant.json
│ │ ├── dataWebpackPrefix.json
│ │ ├── debug.json
│ │ ├── Debugging_Assistant.json
│ │ ├── decodeStateVectorV2.json
│ │ ├── DEFAULT_DELIMITER.json
│ │ ├── DEFAULT_DIAGRAM_DIRECTION.json
│ │ ├── DEFAULT_INDENT.json
│ │ ├── DEFAULT_JS_PATTERN.json
│ │ ├── DEFAULT_LOG_TARGET.json
│ │ ├── defaultHelpOpt.json
│ │ ├── defaultHost.json
│ │ ├── deferY18nLookupPrefix.json
│ │ ├── DELIM.json
│ │ ├── delimiter.json
│ │ ├── DEPRECATION.json
│ │ ├── DESCENDING.json
│ │ ├── destMain.json
│ │ ├── development
│ │ │ ├── Collaborative_Development_with_MCP_Integration.json
│ │ │ ├── Consolidated_TypeScript_Interfaces_Template.json
│ │ │ ├── Development_Workflow.json
│ │ │ ├── index.json
│ │ │ ├── MCP_Server_Development_Prompt_Combiner.json
│ │ │ └── Monorepo_Migration_and_Code_Organization_Guide.json
│ │ ├── Development_System_Prompt.json
│ │ ├── Development_Workflow.json
│ │ ├── devops
│ │ │ ├── Docker_Compose_Prompt_Combiner.json
│ │ │ ├── Docker_Containerization_Guide.json
│ │ │ └── index.json
│ │ ├── DID_NOT_THROW.json
│ │ ├── direction.json
│ │ ├── displayValue.json
│ │ ├── DNS.json
│ │ ├── doc.json
│ │ ├── Docker_Compose_Prompt_Combiner.json
│ │ ├── Docker_Containerization_Guide.json
│ │ ├── Docker_MCP_Servers_Orchestration_Guide.json
│ │ ├── DOCUMENTATION_NOTE.json
│ │ ├── DOT.json
│ │ ├── DOTS.json
│ │ ├── dummyCompoundId.json
│ │ ├── e.json
│ │ ├── E.json
│ │ ├── earlyHintsLink.json
│ │ ├── elide.json
│ │ ├── EMPTY.json
│ │ ├── encoded.json
│ │ ├── end.json
│ │ ├── endpoint.json
│ │ ├── environment.json
│ │ ├── ERR_CODE.json
│ │ ├── errMessage.json
│ │ ├── errMsg.json
│ │ ├── ERROR_MESSAGE.json
│ │ ├── error.json
│ │ ├── ERROR.json
│ │ ├── ERRORCLASS.json
│ │ ├── errorMessage.json
│ │ ├── es6Default.json
│ │ ├── ESC.json
│ │ ├── Escapable.json
│ │ ├── escapedChar.json
│ │ ├── escapeFuncStr.json
│ │ ├── escSlash.json
│ │ ├── ev.json
│ │ ├── event.json
│ │ ├── execaMessage.json
│ │ ├── EXPECTED_LABEL.json
│ │ ├── expected.json
│ │ ├── expectedString.json
│ │ ├── expression1.json
│ │ ├── EXTENSION.json
│ │ ├── f.json
│ │ ├── FAIL_TEXT.json
│ │ ├── FILE_BROWSER_FACTORY.json
│ │ ├── fill.json
│ │ ├── findPackageJson.json
│ │ ├── fnKey.json
│ │ ├── Foresight_Assistant.json
│ │ ├── FORMAT.json
│ │ ├── formatted.json
│ │ ├── from.json
│ │ ├── fullpaths.json
│ │ ├── FUNC_ERROR_TEXT.json
│ │ ├── general
│ │ │ └── index.json
│ │ ├── Generate_different_types_of_questions_ab___.json
│ │ ├── Generate_Mermaid_Diagram.json
│ │ ├── GenStateSuspendedStart.json
│ │ ├── GENSYNC_EXPECTED_START.json
│ │ ├── GitHub_Repository_Explorer.json
│ │ ├── gutter.json
│ │ ├── h.json
│ │ ├── handlerFuncName.json
│ │ ├── HASH_UNDEFINED.json
│ │ ├── head.json
│ │ ├── helpMessage.json
│ │ ├── HINT_ARG.json
│ │ ├── HOOK_RETURNED_NOTHING_ERROR_MESSAGE.json
│ │ ├── i.json
│ │ ├── id.json
│ │ ├── identifier.json
│ │ ├── Identifier.json
│ │ ├── INDENT.json
│ │ ├── indentation.json
│ │ ├── index.json
│ │ ├── INDIRECTION_FRAGMENT.json
│ │ ├── Initialize_project_setup_for_a_new_micro___.json
│ │ ├── input.json
│ │ ├── inputText.json
│ │ ├── insert.json
│ │ ├── insertPromptQuery.json
│ │ ├── INSPECT_MAX_BYTES.json
│ │ ├── install_dependencies__build__run__test____.json
│ │ ├── intToCharMap.json
│ │ ├── IS_ITERABLE_SENTINEL.json
│ │ ├── IS_KEYED_SENTINEL.json
│ │ ├── isConfigType.json
│ │ ├── isoSentinel.json
│ │ ├── isSourceNode.json
│ │ ├── j.json
│ │ ├── J.json
│ │ ├── JAKE_CMD.json
│ │ ├── JEST_GLOBAL_NAME.json
│ │ ├── JEST_GLOBALS_MODULE_NAME.json
│ │ ├── JSON_SYNTAX_CHAR.json
│ │ ├── json.json
│ │ ├── jsonType.json
│ │ ├── jupyter_namespaceObject.json
│ │ ├── JUPYTERLAB_DOCMANAGER_PLUGIN_ID.json
│ │ ├── k.json
│ │ ├── KERNEL_STATUS_ERROR_CLASS.json
│ │ ├── key.json
│ │ ├── l.json
│ │ ├── labelId.json
│ │ ├── LATEST_PROTOCOL_VERSION.json
│ │ ├── LETTERDASHNUMBER.json
│ │ ├── LF.json
│ │ ├── LIMIT_REPLACE_NODE.json
│ │ ├── LINE_FEED.json
│ │ ├── logTime.json
│ │ ├── lstatkey.json
│ │ ├── lt.json
│ │ ├── m.json
│ │ ├── maliciousPayload.json
│ │ ├── manager.py
│ │ ├── marker.json
│ │ ├── mask.json
│ │ ├── match.json
│ │ ├── matchingDelim.json
│ │ ├── MAXIMUM_MESSAGE_SIZE.json
│ │ ├── MCP_Integration_Assistant.json
│ │ ├── MCP_Resources_Explorer.json
│ │ ├── MCP_Resources_Integration_Guide.json
│ │ ├── MCP_Server_Development_Prompt_Combiner.json
│ │ ├── MCP_Server_Integration_Guide.json
│ │ ├── mcp-code-generator.json
│ │ ├── mdcContent.json
│ │ ├── Mermaid_Analysis_Expert.json
│ │ ├── Mermaid_Class_Diagram_Generator.json
│ │ ├── Mermaid_Diagram_Generator.json
│ │ ├── Mermaid_Diagram_Modifier.json
│ │ ├── MERMAID_DOM_ID_PREFIX.json
│ │ ├── message.json
│ │ ├── messages.json
│ │ ├── meth.json
│ │ ├── minimatch.json
│ │ ├── MOBILE_QUERY.json
│ │ ├── MOCK_CONSTRUCTOR_NAME.json
│ │ ├── MOCKS_PATTERN.json
│ │ ├── Modify_Mermaid_Diagram.json
│ │ ├── moduleDirectory.json
│ │ ├── Monorepo_Migration_and_Code_Organization_Guide.json
│ │ ├── msg.json
│ │ ├── mtr.json
│ │ ├── Multi-Resource_Context_Assistant.json
│ │ ├── multipartType.json
│ │ ├── n.json
│ │ ├── N.json
│ │ ├── name.json
│ │ ├── NATIVE_PLATFORM.json
│ │ ├── newUrl.json
│ │ ├── NM.json
│ │ ├── NO_ARGUMENTS.json
│ │ ├── NO_DIFF_MESSAGE.json
│ │ ├── NODE_MODULES.json
│ │ ├── nodeInternalPrefix.json
│ │ ├── nonASCIIidentifierStartChars.json
│ │ ├── nonKey.json
│ │ ├── NOT_A_DOT.json
│ │ ├── notCharacterOrDash.json
│ │ ├── notebookURL.json
│ │ ├── notSelector.json
│ │ ├── nullTag.json
│ │ ├── num.json
│ │ ├── NUMBER.json
│ │ ├── o.json
│ │ ├── O.json
│ │ ├── octChar.json
│ │ ├── octetStreamType.json
│ │ ├── operators.json
│ │ ├── other
│ │ │ ├── __image_1___describe_the_icon_in_one_sen___.json
│ │ │ ├── __type.json
│ │ │ ├── Advanced_Multi-Server_Integration_Template.json
│ │ │ ├── Analyze_Mermaid_Diagram.json
│ │ │ ├── Basic_Template.json
│ │ │ ├── Code_Diagram_Documentation_Creator.json
│ │ │ ├── Collaborative_Development_with_MCP_Integration.json
│ │ │ ├── completionShTemplate.json
│ │ │ ├── Could_you_interpret_the_assumed_applicat___.json
│ │ │ ├── DEFAULT_INDENT.json
│ │ │ ├── Docker_MCP_Servers_Orchestration_Guide.json
│ │ │ ├── Generate_different_types_of_questions_ab___.json
│ │ │ ├── Generate_Mermaid_Diagram.json
│ │ │ ├── GitHub_Repository_Explorer.json
│ │ │ ├── index.json
│ │ │ ├── Initialize_project_setup_for_a_new_micro___.json
│ │ │ ├── install_dependencies__build__run__test____.json
│ │ │ ├── LINE_FEED.json
│ │ │ ├── MCP_Resources_Explorer.json
│ │ │ ├── MCP_Resources_Integration_Guide.json
│ │ │ ├── MCP_Server_Integration_Guide.json
│ │ │ ├── mcp-code-generator.json
│ │ │ ├── Mermaid_Class_Diagram_Generator.json
│ │ │ ├── Mermaid_Diagram_Generator.json
│ │ │ ├── Mermaid_Diagram_Modifier.json
│ │ │ ├── Modify_Mermaid_Diagram.json
│ │ │ ├── Multi-Resource_Context_Assistant.json
│ │ │ ├── output.json
│ │ │ ├── sseUrl.json
│ │ │ ├── string.json
│ │ │ ├── Task_List_Helper.json
│ │ │ ├── Template-Based_MCP_Integration.json
│ │ │ ├── Test_Prompt.json
│ │ │ ├── type.json
│ │ │ ├── VERSION.json
│ │ │ ├── WIN_SLASH.json
│ │ │ └── You_are_limited_to_respond_Yes_or_No_onl___.json
│ │ ├── out.json
│ │ ├── output.json
│ │ ├── OUTSIDE_JEST_VM_PROTOCOL.json
│ │ ├── override.json
│ │ ├── p.json
│ │ ├── PACKAGE_FILENAME.json
│ │ ├── PACKAGE_JSON.json
│ │ ├── packageVersion.json
│ │ ├── paddedNumber.json
│ │ ├── page.json
│ │ ├── parseClass.json
│ │ ├── PATH_NODE_MODULES.json
│ │ ├── path.json
│ │ ├── pathExt.json
│ │ ├── pattern.json
│ │ ├── PatternBoolean.json
│ │ ├── pBuiltins.json
│ │ ├── pFloatForm.json
│ │ ├── pkg.json
│ │ ├── PLUGIN_ID_DOC_MANAGER.json
│ │ ├── plusChar.json
│ │ ├── PN_CHARS.json
│ │ ├── point.json
│ │ ├── prefix.json
│ │ ├── PRETTY_PLACEHOLDER.json
│ │ ├── Project_Analysis_Assistant.json
│ │ ├── ProjectsUpdatedInBackgroundEvent.json
│ │ ├── PromptCombiner_Interface.json
│ │ ├── promptId.json
│ │ ├── property_prefix.json
│ │ ├── pubkey256.json
│ │ ├── Q.json
│ │ ├── qmark.json
│ │ ├── QO.json
│ │ ├── query.json
│ │ ├── querystringType.json
│ │ ├── queryText.json
│ │ ├── r.json
│ │ ├── R.json
│ │ ├── rangeStart.json
│ │ ├── re.json
│ │ ├── reI.json
│ │ ├── REQUIRED_FIELD_SYMBOL.json
│ │ ├── Research_Assistant.json
│ │ ├── reserve.json
│ │ ├── resolvedDestination.json
│ │ ├── resolverDir.json
│ │ ├── responseType.json
│ │ ├── result.json
│ │ ├── ROOT_DESCRIBE_BLOCK_NAME.json
│ │ ├── ROOT_NAMESPACE_NAME.json
│ │ ├── ROOT_TASK_NAME.json
│ │ ├── route.json
│ │ ├── RUNNING_TEXT.json
│ │ ├── RXstyle.json
│ │ ├── s.json
│ │ ├── SCHEMA_PATH.json
│ │ ├── schemaQuery.json
│ │ ├── se.json
│ │ ├── SEARCHABLE_CLASS.json
│ │ ├── secret.json
│ │ ├── selector.json
│ │ ├── SEMVER_SPEC_VERSION.json
│ │ ├── sensitiveHeaders.json
│ │ ├── sep.json
│ │ ├── separator.json
│ │ ├── Sequential_Data_Analysis_with_MCP_Integration.json
│ │ ├── SHAPE_STATE.json
│ │ ├── shape.json
│ │ ├── SHARED.json
│ │ ├── short.json
│ │ ├── side.json
│ │ ├── SNAPSHOT_VERSION.json
│ │ ├── SOLID_Code_Analysis_Visualizer.json
│ │ ├── SOURCE_MAPPING_PREFIX.json
│ │ ├── source.json
│ │ ├── sourceMapContent.json
│ │ ├── SPACE_SYMBOL.json
│ │ ├── SPACE.json
│ │ ├── sqlKeywords.json
│ │ ├── sranges.json
│ │ ├── sseUrl.json
│ │ ├── st.json
│ │ ├── ST.json
│ │ ├── stack.json
│ │ ├── START_HIDING.json
│ │ ├── START_OF_LINE.json
│ │ ├── startNoTraversal.json
│ │ ├── STATES.json
│ │ ├── stats.json
│ │ ├── statSync.json
│ │ ├── status.json
│ │ ├── storageStatus.json
│ │ ├── storageType.json
│ │ ├── str.json
│ │ ├── string.json
│ │ ├── stringifiedObject.json
│ │ ├── stringPath.json
│ │ ├── stringResult.json
│ │ ├── stringTag.json
│ │ ├── strValue.json
│ │ ├── style.json
│ │ ├── SUB_NAME.json
│ │ ├── subkey.json
│ │ ├── SUBPROTOCOL.json
│ │ ├── SUITE_NAME.json
│ │ ├── symbolPattern.json
│ │ ├── symbolTag.json
│ │ ├── system
│ │ │ ├── Aa.json
│ │ │ ├── b.json
│ │ │ ├── Development_System_Prompt.json
│ │ │ ├── index.json
│ │ │ ├── marker.json
│ │ │ ├── PATH_NODE_MODULES.json
│ │ │ ├── ProjectsUpdatedInBackgroundEvent.json
│ │ │ ├── RXstyle.json
│ │ │ ├── status.json
│ │ │ └── versionMajorMinor.json
│ │ ├── t.json
│ │ ├── T.json
│ │ ├── Task_List_Helper.json
│ │ ├── Template-Based_MCP_Integration.json
│ │ ├── template.py
│ │ ├── templateDir.json
│ │ ├── tempName.json
│ │ ├── Test_Prompt.json
│ │ ├── text.json
│ │ ├── time.json
│ │ ├── titleSeparator.json
│ │ ├── tmpl.json
│ │ ├── tn.json
│ │ ├── TOPBAR_FACTORY.json
│ │ ├── toValue.json
│ │ ├── transform.json
│ │ ├── trustProxyDefaultSymbol.json
│ │ ├── txt.json
│ │ ├── type.json
│ │ ├── typeArgumentsKey.json
│ │ ├── typeKey.json
│ │ ├── typeMessage.json
│ │ ├── typesRegistryPackageName.json
│ │ ├── u.json
│ │ ├── UNDEFINED.json
│ │ ├── unit.json
│ │ ├── UNMATCHED_SURROGATE_PAIR_REPLACE.json
│ │ ├── ur.json
│ │ ├── usage.json
│ │ ├── USAGE.json
│ │ ├── user
│ │ │ ├── backupId.json
│ │ │ ├── DESCENDING.json
│ │ │ ├── encoded.json
│ │ │ ├── index.json
│ │ │ ├── J.json
│ │ │ ├── MOBILE_QUERY.json
│ │ │ ├── promptId.json
│ │ │ ├── schemaQuery.json
│ │ │ ├── TOPBAR_FACTORY.json
│ │ │ ├── txt.json
│ │ │ └── usage.json
│ │ ├── value.json
│ │ ├── VERSION.json
│ │ ├── version.py
│ │ ├── versionMajorMinor.json
│ │ ├── Vr.json
│ │ ├── watchmanURL.json
│ │ ├── webkit.json
│ │ ├── WIN_SLASH.json
│ │ ├── xhtml.json
│ │ ├── XP_DEFAULT_PATHEXT.json
│ │ ├── y.json
│ │ └── You_are_limited_to_respond_Yes_or_No_onl___.json
│ ├── resources
│ │ ├── __init__.py
│ │ ├── code_examples
│ │ │ └── index.json
│ │ ├── config
│ │ │ └── index.json
│ │ ├── documentation
│ │ │ └── index.json
│ │ ├── images
│ │ │ └── index.json
│ │ ├── index.json
│ │ └── other
│ │ └── index.json
│ ├── server.py
│ ├── templates
│ │ ├── __init__.py
│ │ ├── AbstractFactory.json
│ │ ├── Adapter.json
│ │ ├── base.py
│ │ ├── Builder.json
│ │ ├── Chain.json
│ │ ├── Command.json
│ │ ├── component
│ │ │ ├── AbstractFactory.json
│ │ │ ├── Adapter.json
│ │ │ ├── Builder.json
│ │ │ ├── Chain.json
│ │ │ ├── Command.json
│ │ │ ├── Decorator.json
│ │ │ ├── Facade.json
│ │ │ ├── Factory.json
│ │ │ ├── Iterator.json
│ │ │ ├── Mediator.json
│ │ │ ├── Memento.json
│ │ │ ├── Observer.json
│ │ │ ├── Prototype.json
│ │ │ ├── Proxy.json
│ │ │ ├── Singleton.json
│ │ │ ├── State.json
│ │ │ ├── Strategy.json
│ │ │ ├── TemplateMethod.json
│ │ │ └── Visitor.json
│ │ ├── component.py
│ │ ├── Decorator.json
│ │ ├── Facade.json
│ │ ├── Factory.json
│ │ ├── index.json
│ │ ├── Iterator.json
│ │ ├── manager.py
│ │ ├── Mediator.json
│ │ ├── Memento.json
│ │ ├── Observer.json
│ │ ├── project.py
│ │ ├── Prototype.json
│ │ ├── Proxy.json
│ │ ├── renderer.py
│ │ ├── Singleton.json
│ │ ├── State.json
│ │ ├── Strategy.json
│ │ ├── template_manager.py
│ │ ├── TemplateMethod.json
│ │ ├── types.py
│ │ └── Visitor.json
│ └── utils
│ └── __init__.py
├── SUMMARY.md
├── TASK_COMPLETION_SUMMARY.md
├── templates
│ └── openssl
│ ├── files
│ │ ├── CMakeLists.txt.jinja2
│ │ ├── conanfile.py.jinja2
│ │ ├── main.cpp.jinja2
│ │ └── README.md.jinja2
│ ├── openssl-consumer.json
│ └── template.json
├── test_openssl_integration.sh
├── test_package
│ └── conanfile.py
└── tests
├── __init__.py
├── conftest.py
├── integration
│ ├── test_core_integration.py
│ ├── test_mermaid_integration.py
│ ├── test_prompt_manager_integration.py
│ └── test_server_integration.py
├── test_aws_mcp.py
├── test_base_classes.py
├── test_config.py
├── test_exceptions.py
├── test_mermaid.py
├── test_prompts.py
└── test_templates.py
```
# Files
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/devops/Docker_Containerization_Guide.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "Docker Containerization Guide",
3 | "description": "A template for setting up Docker containers for Node.js applications with best practices for multi-stage builds, security, and configuration",
4 | "type": "prompt",
5 | "category": "devops",
6 | "content": "# Docker Containerization Guide for {{project_name}}\n\n## Overview\n\nThis guide outlines best practices for containerizing {{project_type}} applications using Docker, focusing on performance, security, and maintainability.\n\n## Dockerfile Best Practices\n\n### Multi-Stage Build Configuration\n\n```dockerfile\n# Build stage\nFROM node:{{node_version}}-alpine AS build\n\nWORKDIR /app\n\n# Set build-specific environment variables\nENV NODE_ENV=production \\\n DOCKER_BUILD=true\n\n# Copy package files first for better layer caching\nCOPY package*.json ./\n\n# Install dependencies with appropriate locking\nRUN {{package_manager_install_command}}\n\n# Copy source code\nCOPY . .\n\n# Build the application\nRUN npm run build\n\n# Verify build success\nRUN if [ ! -f \"./{{build_output_file}}\" ]; then \\\n echo \"\u274c Build verification failed\"; \\\n exit 1; \\\n else \\\n echo \"\u2705 Build verification successful\"; \\\n fi\n\n# Production stage\nFROM node:{{node_version}}-alpine\n\nWORKDIR /app\n\n# Set production environment variables\nENV NODE_ENV=production \\\n {{additional_env_variables}}\n\n# Copy only necessary files from build stage\nCOPY --from=build /app/{{build_dir}} ./{{build_dir}}\nCOPY --from=build /app/package*.json ./\nCOPY --from=build /app/node_modules ./node_modules\n{{additional_copy_commands}}\n\n# Create a non-root user\nRUN adduser -D -h /home/{{service_user}} {{service_user}}\n\n# Create necessary directories with appropriate permissions\nRUN mkdir -p {{data_directories}} && \\\n chown -R {{service_user}}:{{service_user}} {{data_directories}}\n\n# Set the user\nUSER {{service_user}}\n\n# Create volume for data persistence\nVOLUME [\"{{data_volume}}\"] \n\n# Add image metadata\nLABEL org.opencontainers.image.authors=\"{{image_authors}}\"\nLABEL org.opencontainers.image.title=\"{{image_title}}\"\nLABEL org.opencontainers.image.description=\"{{image_description}}\"\nLABEL org.opencontainers.image.documentation=\"{{documentation_url}}\"\nLABEL org.opencontainers.image.vendor=\"{{vendor}}\"\nLABEL org.opencontainers.image.licenses=\"{{license}}\"\n\n# Expose ports\nEXPOSE {{exposed_ports}}\n\n# Health check\nHEALTHCHECK --interval=30s --timeout=10s --retries=3 \\\n CMD {{health_check_command}} || exit 1\n\n# Run the application\nCMD [\"{{run_command}}\", \"{{run_args}}\"] \n```\n\n## Docker Compose Configuration\n\n### Basic Configuration\n\n```yaml\nname: {{project_name}}\n\nservices:\n # Main application service\n {{service_name}}:\n image: {{image_name}}:{{image_tag}}\n container_name: {{container_name}}\n environment:\n - NODE_ENV=production\n {{environment_variables}}\n volumes:\n - {{service_data_volume}}:{{container_data_path}}\n ports:\n - \"{{host_port}}:{{container_port}}\"\n healthcheck:\n test: [\"CMD\", {{healthcheck_command}}]\n interval: 30s\n timeout: 10s\n retries: 3\n start_period: 5s\n restart: unless-stopped\n\nvolumes:\n {{service_data_volume}}:\n name: {{volume_name}}\n```\n\n### Extended Configuration with Database\n\n```yaml\nname: {{project_name}}\n\nservices:\n # Database service\n {{database_service}}:\n image: {{database_image}}:{{database_version}}\n container_name: {{database_container_name}}\n environment:\n {{database_environment_variables}}\n ports:\n - \"{{database_host_port}}:{{database_container_port}}\"\n volumes:\n - {{database_data_volume}}:/{{database_data_path}}\n healthcheck:\n test: {{database_healthcheck_command}}\n interval: 10s\n timeout: 5s\n retries: 5\n restart: unless-stopped\n\n # Main application service\n {{service_name}}:\n image: {{image_name}}:{{image_tag}}\n container_name: {{container_name}}\n depends_on:\n {{database_service}}:\n condition: service_healthy\n environment:\n - NODE_ENV=production\n - {{database_connection_env_var}}=\n {{environment_variables}}\n volumes:\n - {{service_data_volume}}:{{container_data_path}}\n ports:\n - \"{{host_port}}:{{container_port}}\"\n healthcheck:\n test: [\"CMD\", {{healthcheck_command}}]\n interval: 30s\n timeout: 10s\n retries: 3\n start_period: 5s\n restart: unless-stopped\n\nvolumes:\n {{database_data_volume}}:\n name: {{database_volume_name}}\n {{service_data_volume}}:\n name: {{volume_name}}\n```\n\n## Container Security Best Practices\n\n1. **Use Specific Version Tags**: Always specify exact versions for base images (e.g., `node:20.5.1-alpine` instead of `node:latest`)\n\n2. **Run as Non-Root User**: Create and use a dedicated non-root user for running the application\n\n3. **Minimize Container Privileges**: Apply the principle of least privilege\n\n4. **Secure Secrets Management**: Use environment variables, secret management tools, or Docker secrets for sensitive information\n\n5. **Image Scanning**: Regularly scan images for vulnerabilities\n\n6. **Multi-Stage Builds**: Use multi-stage builds to reduce attack surface\n\n7. **Distroless or Alpine Images**: Use minimal base images\n\n8. **Health Checks**: Implement health checks for monitoring container status\n\n## Containerized Testing\n\n### Test-Specific Dockerfile\n\n```dockerfile\nFROM node:{{node_version}}-alpine\n\nWORKDIR /test\n\n# Install test dependencies\nRUN {{test_dependencies_install}}\n\n# Set environment variables for testing\nENV NODE_ENV=test \\\n {{test_environment_variables}}\n\n# Create test directories\nRUN mkdir -p {{test_directories}}\n\n# Add healthcheck\nHEALTHCHECK --interval=30s --timeout=10s --retries=3 --start-period=5s \\\n CMD {{test_healthcheck_command}} || exit 1\n\n# Test command\nCMD [\"{{test_command}}\", \"{{test_args}}\"] \n```\n\n### Test Docker Compose\n\n```yaml\nname: {{project_name}}-test\n\nservices:\n # Test database\n {{test_database_service}}:\n image: {{database_image}}:{{database_version}}\n container_name: {{test_database_container}}\n environment:\n {{test_database_environment}}\n healthcheck:\n test: {{database_healthcheck_command}}\n interval: 10s\n timeout: 5s\n retries: 5\n networks:\n - test-network\n\n # Test application\n {{test_service_name}}:\n build:\n context: .\n dockerfile: Dockerfile.test\n container_name: {{test_container_name}}\n depends_on:\n {{test_database_service}}:\n condition: service_healthy\n environment:\n - NODE_ENV=test\n - {{database_connection_env_var}}=\n {{test_environment_variables}}\n volumes:\n - ./tests:/test/tests\n networks:\n - test-network\n\nnetworks:\n test-network:\n name: {{test_network_name}}\n```\n\n## Production Deployment Considerations\n\n1. **Resource Limits**: Set appropriate CPU and memory limits for containers\n\n2. **Logging Configuration**: Configure appropriate logging drivers and rotation policies\n\n3. **Container Orchestration**: Consider using Kubernetes, Docker Swarm, or similar tools for production deployments\n\n4. **Backup Strategy**: Implement a strategy for backing up data volumes\n\n5. **Monitoring**: Set up appropriate monitoring and alerting for containers\n\n6. **Network Security**: Configure network policies and firewall rules for container communication\n\n7. **Scaling Strategy**: Plan for horizontal and vertical scaling as needed\n\n## Implementation Notes\n\n{{implementation_notes}}\n",
7 | "variables": [
8 | "project_name",
9 | "project_type",
10 | "node_version",
11 | "package_manager_install_command",
12 | "build_output_file",
13 | "build_dir",
14 | "additional_env_variables",
15 | "additional_copy_commands",
16 | "service_user",
17 | "data_directories",
18 | "data_volume",
19 | "image_authors",
20 | "image_title",
21 | "image_description",
22 | "documentation_url",
23 | "vendor",
24 | "license",
25 | "exposed_ports",
26 | "health_check_command",
27 | "run_command",
28 | "run_args",
29 | "service_name",
30 | "image_name",
31 | "image_tag",
32 | "container_name",
33 | "environment_variables",
34 | "service_data_volume",
35 | "container_data_path",
36 | "host_port",
37 | "container_port",
38 | "healthcheck_command",
39 | "volume_name",
40 | "database_service",
41 | "database_image",
42 | "database_version",
43 | "database_container_name",
44 | "database_environment_variables",
45 | "database_host_port",
46 | "database_container_port",
47 | "database_data_volume",
48 | "database_data_path",
49 | "database_healthcheck_command",
50 | "database_connection_env_var",
51 | "database_volume_name",
52 | "test_dependencies_install",
53 | "test_environment_variables",
54 | "test_directories",
55 | "test_healthcheck_command",
56 | "test_command",
57 | "test_args",
58 | "test_database_service",
59 | "test_database_container",
60 | "test_database_environment",
61 | "test_service_name",
62 | "test_container_name",
63 | "test_network_name",
64 | "implementation_notes"
65 | ],
66 | "metadata": {
67 | "source": "/home/sparrow/projects/mcp-prompts/prompts/docker-containerization-guide.json",
68 | "imported": true
69 | }
70 | }
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/Docker_Containerization_Guide.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "Docker Containerization Guide",
3 | "description": "A template for setting up Docker containers for Node.js applications with best practices for multi-stage builds, security, and configuration",
4 | "type": "prompt",
5 | "category": "devops",
6 | "content": "# Docker Containerization Guide for {{project_name}}\n\n## Overview\n\nThis guide outlines best practices for containerizing {{project_type}} applications using Docker, focusing on performance, security, and maintainability.\n\n## Dockerfile Best Practices\n\n### Multi-Stage Build Configuration\n\n```dockerfile\n# Build stage\nFROM node:{{node_version}}-alpine AS build\n\nWORKDIR /app\n\n# Set build-specific environment variables\nENV NODE_ENV=production \\\n DOCKER_BUILD=true\n\n# Copy package files first for better layer caching\nCOPY package*.json ./\n\n# Install dependencies with appropriate locking\nRUN {{package_manager_install_command}}\n\n# Copy source code\nCOPY . .\n\n# Build the application\nRUN npm run build\n\n# Verify build success\nRUN if [ ! -f \"./{{build_output_file}}\" ]; then \\\n echo \"\u274c Build verification failed\"; \\\n exit 1; \\\n else \\\n echo \"\u2705 Build verification successful\"; \\\n fi\n\n# Production stage\nFROM node:{{node_version}}-alpine\n\nWORKDIR /app\n\n# Set production environment variables\nENV NODE_ENV=production \\\n {{additional_env_variables}}\n\n# Copy only necessary files from build stage\nCOPY --from=build /app/{{build_dir}} ./{{build_dir}}\nCOPY --from=build /app/package*.json ./\nCOPY --from=build /app/node_modules ./node_modules\n{{additional_copy_commands}}\n\n# Create a non-root user\nRUN adduser -D -h /home/{{service_user}} {{service_user}}\n\n# Create necessary directories with appropriate permissions\nRUN mkdir -p {{data_directories}} && \\\n chown -R {{service_user}}:{{service_user}} {{data_directories}}\n\n# Set the user\nUSER {{service_user}}\n\n# Create volume for data persistence\nVOLUME [\"{{data_volume}}\"] \n\n# Add image metadata\nLABEL org.opencontainers.image.authors=\"{{image_authors}}\"\nLABEL org.opencontainers.image.title=\"{{image_title}}\"\nLABEL org.opencontainers.image.description=\"{{image_description}}\"\nLABEL org.opencontainers.image.documentation=\"{{documentation_url}}\"\nLABEL org.opencontainers.image.vendor=\"{{vendor}}\"\nLABEL org.opencontainers.image.licenses=\"{{license}}\"\n\n# Expose ports\nEXPOSE {{exposed_ports}}\n\n# Health check\nHEALTHCHECK --interval=30s --timeout=10s --retries=3 \\\n CMD {{health_check_command}} || exit 1\n\n# Run the application\nCMD [\"{{run_command}}\", \"{{run_args}}\"] \n```\n\n## Docker Compose Configuration\n\n### Basic Configuration\n\n```yaml\nname: {{project_name}}\n\nservices:\n # Main application service\n {{service_name}}:\n image: {{image_name}}:{{image_tag}}\n container_name: {{container_name}}\n environment:\n - NODE_ENV=production\n {{environment_variables}}\n volumes:\n - {{service_data_volume}}:{{container_data_path}}\n ports:\n - \"{{host_port}}:{{container_port}}\"\n healthcheck:\n test: [\"CMD\", {{healthcheck_command}}]\n interval: 30s\n timeout: 10s\n retries: 3\n start_period: 5s\n restart: unless-stopped\n\nvolumes:\n {{service_data_volume}}:\n name: {{volume_name}}\n```\n\n### Extended Configuration with Database\n\n```yaml\nname: {{project_name}}\n\nservices:\n # Database service\n {{database_service}}:\n image: {{database_image}}:{{database_version}}\n container_name: {{database_container_name}}\n environment:\n {{database_environment_variables}}\n ports:\n - \"{{database_host_port}}:{{database_container_port}}\"\n volumes:\n - {{database_data_volume}}:/{{database_data_path}}\n healthcheck:\n test: {{database_healthcheck_command}}\n interval: 10s\n timeout: 5s\n retries: 5\n restart: unless-stopped\n\n # Main application service\n {{service_name}}:\n image: {{image_name}}:{{image_tag}}\n container_name: {{container_name}}\n depends_on:\n {{database_service}}:\n condition: service_healthy\n environment:\n - NODE_ENV=production\n - {{database_connection_env_var}}=\n {{environment_variables}}\n volumes:\n - {{service_data_volume}}:{{container_data_path}}\n ports:\n - \"{{host_port}}:{{container_port}}\"\n healthcheck:\n test: [\"CMD\", {{healthcheck_command}}]\n interval: 30s\n timeout: 10s\n retries: 3\n start_period: 5s\n restart: unless-stopped\n\nvolumes:\n {{database_data_volume}}:\n name: {{database_volume_name}}\n {{service_data_volume}}:\n name: {{volume_name}}\n```\n\n## Container Security Best Practices\n\n1. **Use Specific Version Tags**: Always specify exact versions for base images (e.g., `node:20.5.1-alpine` instead of `node:latest`)\n\n2. **Run as Non-Root User**: Create and use a dedicated non-root user for running the application\n\n3. **Minimize Container Privileges**: Apply the principle of least privilege\n\n4. **Secure Secrets Management**: Use environment variables, secret management tools, or Docker secrets for sensitive information\n\n5. **Image Scanning**: Regularly scan images for vulnerabilities\n\n6. **Multi-Stage Builds**: Use multi-stage builds to reduce attack surface\n\n7. **Distroless or Alpine Images**: Use minimal base images\n\n8. **Health Checks**: Implement health checks for monitoring container status\n\n## Containerized Testing\n\n### Test-Specific Dockerfile\n\n```dockerfile\nFROM node:{{node_version}}-alpine\n\nWORKDIR /test\n\n# Install test dependencies\nRUN {{test_dependencies_install}}\n\n# Set environment variables for testing\nENV NODE_ENV=test \\\n {{test_environment_variables}}\n\n# Create test directories\nRUN mkdir -p {{test_directories}}\n\n# Add healthcheck\nHEALTHCHECK --interval=30s --timeout=10s --retries=3 --start-period=5s \\\n CMD {{test_healthcheck_command}} || exit 1\n\n# Test command\nCMD [\"{{test_command}}\", \"{{test_args}}\"] \n```\n\n### Test Docker Compose\n\n```yaml\nname: {{project_name}}-test\n\nservices:\n # Test database\n {{test_database_service}}:\n image: {{database_image}}:{{database_version}}\n container_name: {{test_database_container}}\n environment:\n {{test_database_environment}}\n healthcheck:\n test: {{database_healthcheck_command}}\n interval: 10s\n timeout: 5s\n retries: 5\n networks:\n - test-network\n\n # Test application\n {{test_service_name}}:\n build:\n context: .\n dockerfile: Dockerfile.test\n container_name: {{test_container_name}}\n depends_on:\n {{test_database_service}}:\n condition: service_healthy\n environment:\n - NODE_ENV=test\n - {{database_connection_env_var}}=\n {{test_environment_variables}}\n volumes:\n - ./tests:/test/tests\n networks:\n - test-network\n\nnetworks:\n test-network:\n name: {{test_network_name}}\n```\n\n## Production Deployment Considerations\n\n1. **Resource Limits**: Set appropriate CPU and memory limits for containers\n\n2. **Logging Configuration**: Configure appropriate logging drivers and rotation policies\n\n3. **Container Orchestration**: Consider using Kubernetes, Docker Swarm, or similar tools for production deployments\n\n4. **Backup Strategy**: Implement a strategy for backing up data volumes\n\n5. **Monitoring**: Set up appropriate monitoring and alerting for containers\n\n6. **Network Security**: Configure network policies and firewall rules for container communication\n\n7. **Scaling Strategy**: Plan for horizontal and vertical scaling as needed\n\n## Implementation Notes\n\n{{implementation_notes}}\n",
7 | "variables": [
8 | "project_name",
9 | "project_type",
10 | "node_version",
11 | "package_manager_install_command",
12 | "build_output_file",
13 | "build_dir",
14 | "additional_env_variables",
15 | "additional_copy_commands",
16 | "service_user",
17 | "data_directories",
18 | "data_volume",
19 | "image_authors",
20 | "image_title",
21 | "image_description",
22 | "documentation_url",
23 | "vendor",
24 | "license",
25 | "exposed_ports",
26 | "health_check_command",
27 | "run_command",
28 | "run_args",
29 | "service_name",
30 | "image_name",
31 | "image_tag",
32 | "container_name",
33 | "environment_variables",
34 | "service_data_volume",
35 | "container_data_path",
36 | "host_port",
37 | "container_port",
38 | "healthcheck_command",
39 | "volume_name",
40 | "database_service",
41 | "database_image",
42 | "database_version",
43 | "database_container_name",
44 | "database_environment_variables",
45 | "database_host_port",
46 | "database_container_port",
47 | "database_data_volume",
48 | "database_data_path",
49 | "database_healthcheck_command",
50 | "database_connection_env_var",
51 | "database_volume_name",
52 | "test_dependencies_install",
53 | "test_environment_variables",
54 | "test_directories",
55 | "test_healthcheck_command",
56 | "test_command",
57 | "test_args",
58 | "test_database_service",
59 | "test_database_container",
60 | "test_database_environment",
61 | "test_service_name",
62 | "test_container_name",
63 | "test_network_name",
64 | "implementation_notes"
65 | ],
66 | "metadata": {
67 | "source": "/home/sparrow/projects/mcp-prompts/prompts/docker-containerization-guide.json",
68 | "imported": true
69 | }
70 | }
```
--------------------------------------------------------------------------------
/scripts/consolidate_mermaid.py:
--------------------------------------------------------------------------------
```python
1 | #!/usr/bin/env python3
2 | """
3 | Mermaid Template Consolidation Script for MCP Project Orchestrator.
4 |
5 | This script consolidates Mermaid diagram templates from various sources into a standardized format
6 | and stores them in the target project's mermaid directory.
7 |
8 | Sources:
9 | 1. /home/sparrow/projects/mcp-servers/src/mermaid
10 | 2. Component templates in /home/sparrow/projects/mcp-project-orchestrator/component_templates.json
11 | 3. Mermaid templates from /home/sparrow/mcp/data/prompts
12 |
13 | Target:
14 | /home/sparrow/projects/mcp-project-orchestrator/src/mcp_project_orchestrator/mermaid/templates
15 | """
16 |
17 | import os
18 | import sys
19 | import json
20 | import shutil
21 | from pathlib import Path
22 | from typing import Dict, Any, List, Optional
23 |
24 |
25 | # Source directories and files
26 | SOURCES = [
27 | Path("/home/sparrow/projects/mcp-servers/src/mermaid/demo_output"),
28 | Path("/home/sparrow/projects/mcp-servers/src/mermaid"),
29 | Path("/home/sparrow/projects/mcp-project-orchestrator/component_templates.json"),
30 | Path("/home/sparrow/mcp/data/prompts")
31 | ]
32 |
33 | # Target directory
34 | TARGET = Path("/home/sparrow/projects/mcp-project-orchestrator/src/mcp_project_orchestrator/mermaid/templates")
35 |
36 |
37 | def ensure_target_directory():
38 | """Ensure the target directory exists."""
39 | TARGET.mkdir(parents=True, exist_ok=True)
40 | (TARGET / "flowchart").mkdir(exist_ok=True)
41 | (TARGET / "class").mkdir(exist_ok=True)
42 | (TARGET / "sequence").mkdir(exist_ok=True)
43 | (TARGET / "er").mkdir(exist_ok=True)
44 | (TARGET / "gantt").mkdir(exist_ok=True)
45 | (TARGET / "pie").mkdir(exist_ok=True)
46 |
47 |
48 | def get_mermaid_files(source_dir: Path) -> List[Path]:
49 | """Get all mermaid diagram files from a source directory."""
50 | if not source_dir.exists():
51 | print(f"Source directory does not exist: {source_dir}")
52 | return []
53 |
54 | # Look for mermaid diagram files
55 | extensions = [".mmd", ".mermaid", ".md"]
56 |
57 | files = []
58 | for ext in extensions:
59 | files.extend(list(source_dir.glob(f"**/*{ext}")))
60 |
61 | # Also look for specific Mermaid JSON files
62 | json_files = [
63 | f for f in source_dir.glob("**/*.json")
64 | if "mermaid" in f.stem.lower() or "diagram" in f.stem.lower()
65 | ]
66 |
67 | return files + json_files
68 |
69 |
70 | def extract_mermaid_from_json(file_path: Path) -> List[Dict[str, Any]]:
71 | """Extract mermaid templates from JSON files."""
72 | templates = []
73 |
74 | try:
75 | with open(file_path, 'r') as f:
76 | data = json.load(f)
77 |
78 | # Handle component templates format
79 | if file_path.name == "component_templates.json" and "component_templates" in data:
80 | for component in data["component_templates"]:
81 | if "mermaid" in component and component["mermaid"]:
82 | # Extract the mermaid prompt as a template
83 | templates.append({
84 | "name": f"{component['name']}-diagram",
85 | "description": f"Mermaid diagram for {component['name']} pattern",
86 | "type": "flowchart", # Default to flowchart
87 | "content": component["mermaid"],
88 | "variables": {}
89 | })
90 |
91 | # Handle mermaid diagram templates in prompts
92 | elif "template" in data or "content" in data:
93 | content = data.get("template", data.get("content", ""))
94 | if "mermaid" in content.lower() or "flowchart" in content.lower() or "classDiagram" in content.lower():
95 | templates.append({
96 | "name": data.get("name", file_path.stem),
97 | "description": data.get("description", ""),
98 | "type": detect_diagram_type(content),
99 | "content": content,
100 | "variables": data.get("variables", {})
101 | })
102 |
103 | except Exception as e:
104 | print(f"Error extracting mermaid from {file_path}: {str(e)}")
105 |
106 | return templates
107 |
108 |
109 | def extract_mermaid_from_file(file_path: Path) -> Optional[Dict[str, Any]]:
110 | """Extract mermaid diagram from a file."""
111 | try:
112 | with open(file_path, 'r') as f:
113 | content = f.read()
114 |
115 | # Detect diagram type
116 | diagram_type = detect_diagram_type(content)
117 |
118 | return {
119 | "name": file_path.stem,
120 | "description": f"Mermaid {diagram_type} diagram",
121 | "type": diagram_type,
122 | "content": content,
123 | "variables": {}
124 | }
125 |
126 | except Exception as e:
127 | print(f"Error reading mermaid file {file_path}: {str(e)}")
128 | return None
129 |
130 |
131 | def detect_diagram_type(content: str) -> str:
132 | """Detect the type of mermaid diagram from content."""
133 | content = content.lower()
134 |
135 | if "flowchart" in content or "graph " in content:
136 | return "flowchart"
137 | elif "classDiagram" in content:
138 | return "class"
139 | elif "sequenceDiagram" in content:
140 | return "sequence"
141 | elif "erDiagram" in content:
142 | return "er"
143 | elif "gantt" in content:
144 | return "gantt"
145 | elif "pie" in content:
146 | return "pie"
147 | else:
148 | return "flowchart" # Default
149 |
150 |
151 | def normalize_template(template: Dict[str, Any]) -> Dict[str, Any]:
152 | """Normalize a mermaid template to the standard format."""
153 | # Create standardized template structure
154 | normalized = {
155 | "name": template["name"],
156 | "description": template.get("description", ""),
157 | "type": template.get("type", "flowchart"),
158 | "content": template.get("content", ""),
159 | "variables": template.get("variables", {}),
160 | "metadata": {
161 | "imported": True
162 | }
163 | }
164 |
165 | return normalized
166 |
167 |
168 | def save_template(template: Dict[str, Any]):
169 | """Save a normalized template to the target directory."""
170 | name = template["name"]
171 | diagram_type = template["type"]
172 |
173 | # Generate safe filename
174 | safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in name)
175 |
176 | # Save to both the main directory and the type-specific directory
177 | for save_path in [TARGET / f"{safe_name}.json", TARGET / diagram_type / f"{safe_name}.json"]:
178 | with open(save_path, 'w') as f:
179 | json.dump(template, f, indent=2)
180 |
181 | return safe_name
182 |
183 |
184 | def process_all_sources():
185 | """Process all source files and consolidate mermaid templates."""
186 | ensure_target_directory()
187 |
188 | # Track processed templates by name
189 | processed = {}
190 |
191 | # Process each source
192 | for source in SOURCES:
193 | print(f"Processing source: {source}")
194 |
195 | if source.is_file() and source.suffix == '.json':
196 | # Handle JSON files directly
197 | templates = extract_mermaid_from_json(source)
198 | for template in templates:
199 | name = template["name"]
200 | if name in processed:
201 | print(f" Skipping duplicate template: {name}")
202 | continue
203 |
204 | normalized = normalize_template(template)
205 | safe_name = save_template(normalized)
206 | processed[name] = safe_name
207 | print(f" Processed template: {name} -> {safe_name}.json")
208 |
209 | elif source.is_dir():
210 | # Handle directories
211 | mermaid_files = get_mermaid_files(source)
212 |
213 | for file_path in mermaid_files:
214 | if file_path.suffix == '.json':
215 | templates = extract_mermaid_from_json(file_path)
216 | for template in templates:
217 | name = template["name"]
218 | if name in processed:
219 | print(f" Skipping duplicate template: {name}")
220 | continue
221 |
222 | normalized = normalize_template(template)
223 | safe_name = save_template(normalized)
224 | processed[name] = safe_name
225 | print(f" Processed JSON template: {name} -> {safe_name}.json")
226 | else:
227 | # Handle mermaid files directly
228 | template = extract_mermaid_from_file(file_path)
229 | if template:
230 | name = template["name"]
231 | if name in processed:
232 | print(f" Skipping duplicate template: {name}")
233 | continue
234 |
235 | normalized = normalize_template(template)
236 | safe_name = save_template(normalized)
237 | processed[name] = safe_name
238 | print(f" Processed mermaid file: {name} -> {safe_name}.json")
239 |
240 | # Generate an index file
241 | index = {
242 | "templates": list(processed.keys()),
243 | "count": len(processed),
244 | "types": {}
245 | }
246 |
247 | # Build type index
248 | type_dirs = TARGET.glob("*")
249 | for type_dir in [d for d in type_dirs if d.is_dir()]:
250 | type_name = type_dir.name
251 | templates = list(type_dir.glob("*.json"))
252 | index["types"][type_name] = {
253 | "templates": [t.stem for t in templates],
254 | "count": len(templates)
255 | }
256 |
257 | # Save index file
258 | with open(TARGET / "index.json", 'w') as f:
259 | json.dump(index, f, indent=2)
260 |
261 | print(f"\nConsolidation complete. Processed {len(processed)} templates.")
262 | print(f"Types: {', '.join(index['types'].keys())}")
263 |
264 |
265 | if __name__ == "__main__":
266 | process_all_sources()
```
--------------------------------------------------------------------------------
/data/prompts/templates/docker-containerization-guide.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "id": "docker-containerization-guide",
3 | "name": "Docker Containerization Guide",
4 | "description": "A template for setting up Docker containers for Node.js applications with best practices for multi-stage builds, security, and configuration",
5 | "content": "# Docker Containerization Guide for {{project_name}}\n\n## Overview\n\nThis guide outlines best practices for containerizing {{project_type}} applications using Docker, focusing on performance, security, and maintainability.\n\n## Dockerfile Best Practices\n\n### Multi-Stage Build Configuration\n\n```dockerfile\n# Build stage\nFROM node:{{node_version}}-alpine AS build\n\nWORKDIR /app\n\n# Set build-specific environment variables\nENV NODE_ENV=production \\\n DOCKER_BUILD=true\n\n# Copy package files first for better layer caching\nCOPY package*.json ./\n\n# Install dependencies with appropriate locking\nRUN {{package_manager_install_command}}\n\n# Copy source code\nCOPY . .\n\n# Build the application\nRUN npm run build\n\n# Verify build success\nRUN if [ ! -f \"./{{build_output_file}}\" ]; then \\\n echo \"❌ Build verification failed\"; \\\n exit 1; \\\n else \\\n echo \"✅ Build verification successful\"; \\\n fi\n\n# Production stage\nFROM node:{{node_version}}-alpine\n\nWORKDIR /app\n\n# Set production environment variables\nENV NODE_ENV=production \\\n {{additional_env_variables}}\n\n# Copy only necessary files from build stage\nCOPY --from=build /app/{{build_dir}} ./{{build_dir}}\nCOPY --from=build /app/package*.json ./\nCOPY --from=build /app/node_modules ./node_modules\n{{additional_copy_commands}}\n\n# Create a non-root user\nRUN adduser -D -h /home/{{service_user}} {{service_user}}\n\n# Create necessary directories with appropriate permissions\nRUN mkdir -p {{data_directories}} && \\\n chown -R {{service_user}}:{{service_user}} {{data_directories}}\n\n# Set the user\nUSER {{service_user}}\n\n# Create volume for data persistence\nVOLUME [\"{{data_volume}}\"] \n\n# Add image metadata\nLABEL org.opencontainers.image.authors=\"{{image_authors}}\"\nLABEL org.opencontainers.image.title=\"{{image_title}}\"\nLABEL org.opencontainers.image.description=\"{{image_description}}\"\nLABEL org.opencontainers.image.documentation=\"{{documentation_url}}\"\nLABEL org.opencontainers.image.vendor=\"{{vendor}}\"\nLABEL org.opencontainers.image.licenses=\"{{license}}\"\n\n# Expose ports\nEXPOSE {{exposed_ports}}\n\n# Health check\nHEALTHCHECK --interval=30s --timeout=10s --retries=3 \\\n CMD {{health_check_command}} || exit 1\n\n# Run the application\nCMD [\"{{run_command}}\", \"{{run_args}}\"] \n```\n\n## Docker Compose Configuration\n\n### Basic Configuration\n\n```yaml\nname: {{project_name}}\n\nservices:\n # Main application service\n {{service_name}}:\n image: {{image_name}}:{{image_tag}}\n container_name: {{container_name}}\n environment:\n - NODE_ENV=production\n {{environment_variables}}\n volumes:\n - {{service_data_volume}}:{{container_data_path}}\n ports:\n - \"{{host_port}}:{{container_port}}\"\n healthcheck:\n test: [\"CMD\", {{healthcheck_command}}]\n interval: 30s\n timeout: 10s\n retries: 3\n start_period: 5s\n restart: unless-stopped\n\nvolumes:\n {{service_data_volume}}:\n name: {{volume_name}}\n```\n\n### Extended Configuration with Database\n\n```yaml\nname: {{project_name}}\n\nservices:\n # Database service\n {{database_service}}:\n image: {{database_image}}:{{database_version}}\n container_name: {{database_container_name}}\n environment:\n {{database_environment_variables}}\n ports:\n - \"{{database_host_port}}:{{database_container_port}}\"\n volumes:\n - {{database_data_volume}}:/{{database_data_path}}\n healthcheck:\n test: {{database_healthcheck_command}}\n interval: 10s\n timeout: 5s\n retries: 5\n restart: unless-stopped\n\n # Main application service\n {{service_name}}:\n image: {{image_name}}:{{image_tag}}\n container_name: {{container_name}}\n depends_on:\n {{database_service}}:\n condition: service_healthy\n environment:\n - NODE_ENV=production\n - {{database_connection_env_var}}=\n {{environment_variables}}\n volumes:\n - {{service_data_volume}}:{{container_data_path}}\n ports:\n - \"{{host_port}}:{{container_port}}\"\n healthcheck:\n test: [\"CMD\", {{healthcheck_command}}]\n interval: 30s\n timeout: 10s\n retries: 3\n start_period: 5s\n restart: unless-stopped\n\nvolumes:\n {{database_data_volume}}:\n name: {{database_volume_name}}\n {{service_data_volume}}:\n name: {{volume_name}}\n```\n\n## Container Security Best Practices\n\n1. **Use Specific Version Tags**: Always specify exact versions for base images (e.g., `node:20.5.1-alpine` instead of `node:latest`)\n\n2. **Run as Non-Root User**: Create and use a dedicated non-root user for running the application\n\n3. **Minimize Container Privileges**: Apply the principle of least privilege\n\n4. **Secure Secrets Management**: Use environment variables, secret management tools, or Docker secrets for sensitive information\n\n5. **Image Scanning**: Regularly scan images for vulnerabilities\n\n6. **Multi-Stage Builds**: Use multi-stage builds to reduce attack surface\n\n7. **Distroless or Alpine Images**: Use minimal base images\n\n8. **Health Checks**: Implement health checks for monitoring container status\n\n## Containerized Testing\n\n### Test-Specific Dockerfile\n\n```dockerfile\nFROM node:{{node_version}}-alpine\n\nWORKDIR /test\n\n# Install test dependencies\nRUN {{test_dependencies_install}}\n\n# Set environment variables for testing\nENV NODE_ENV=test \\\n {{test_environment_variables}}\n\n# Create test directories\nRUN mkdir -p {{test_directories}}\n\n# Add healthcheck\nHEALTHCHECK --interval=30s --timeout=10s --retries=3 --start-period=5s \\\n CMD {{test_healthcheck_command}} || exit 1\n\n# Test command\nCMD [\"{{test_command}}\", \"{{test_args}}\"] \n```\n\n### Test Docker Compose\n\n```yaml\nname: {{project_name}}-test\n\nservices:\n # Test database\n {{test_database_service}}:\n image: {{database_image}}:{{database_version}}\n container_name: {{test_database_container}}\n environment:\n {{test_database_environment}}\n healthcheck:\n test: {{database_healthcheck_command}}\n interval: 10s\n timeout: 5s\n retries: 5\n networks:\n - test-network\n\n # Test application\n {{test_service_name}}:\n build:\n context: .\n dockerfile: Dockerfile.test\n container_name: {{test_container_name}}\n depends_on:\n {{test_database_service}}:\n condition: service_healthy\n environment:\n - NODE_ENV=test\n - {{database_connection_env_var}}=\n {{test_environment_variables}}\n volumes:\n - ./tests:/test/tests\n networks:\n - test-network\n\nnetworks:\n test-network:\n name: {{test_network_name}}\n```\n\n## Production Deployment Considerations\n\n1. **Resource Limits**: Set appropriate CPU and memory limits for containers\n\n2. **Logging Configuration**: Configure appropriate logging drivers and rotation policies\n\n3. **Container Orchestration**: Consider using Kubernetes, Docker Swarm, or similar tools for production deployments\n\n4. **Backup Strategy**: Implement a strategy for backing up data volumes\n\n5. **Monitoring**: Set up appropriate monitoring and alerting for containers\n\n6. **Network Security**: Configure network policies and firewall rules for container communication\n\n7. **Scaling Strategy**: Plan for horizontal and vertical scaling as needed\n\n## Implementation Notes\n\n{{implementation_notes}}\n",
6 | "isTemplate": true,
7 | "variables": [
8 | "project_name",
9 | "project_type",
10 | "node_version",
11 | "package_manager_install_command",
12 | "build_output_file",
13 | "build_dir",
14 | "additional_env_variables",
15 | "additional_copy_commands",
16 | "service_user",
17 | "data_directories",
18 | "data_volume",
19 | "image_authors",
20 | "image_title",
21 | "image_description",
22 | "documentation_url",
23 | "vendor",
24 | "license",
25 | "exposed_ports",
26 | "health_check_command",
27 | "run_command",
28 | "run_args",
29 | "service_name",
30 | "image_name",
31 | "image_tag",
32 | "container_name",
33 | "environment_variables",
34 | "service_data_volume",
35 | "container_data_path",
36 | "host_port",
37 | "container_port",
38 | "healthcheck_command",
39 | "volume_name",
40 | "database_service",
41 | "database_image",
42 | "database_version",
43 | "database_container_name",
44 | "database_environment_variables",
45 | "database_host_port",
46 | "database_container_port",
47 | "database_data_volume",
48 | "database_data_path",
49 | "database_healthcheck_command",
50 | "database_connection_env_var",
51 | "database_volume_name",
52 | "test_dependencies_install",
53 | "test_environment_variables",
54 | "test_directories",
55 | "test_healthcheck_command",
56 | "test_command",
57 | "test_args",
58 | "test_database_service",
59 | "test_database_container",
60 | "test_database_environment",
61 | "test_service_name",
62 | "test_container_name",
63 | "test_network_name",
64 | "implementation_notes"
65 | ],
66 | "tags": [
67 | "development",
68 | "docker",
69 | "containerization",
70 | "devops",
71 | "deployment",
72 | "template"
73 | ],
74 | "category": "devops",
75 | "createdAt": "2024-08-08T16:00:00.000Z",
76 | "updatedAt": "2024-08-08T16:00:00.000Z",
77 | "version": 1
78 | }
```
--------------------------------------------------------------------------------
/scripts/setup_mcp.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 | # MCP Project Orchestrator - Unified Setup Script
3 | # Consolidates multiple setup scripts for easier management
4 |
5 | set -e
6 |
7 | # Color definitions
8 | COLOR_GREEN='\033[0;32m'
9 | COLOR_YELLOW='\033[0;33m'
10 | COLOR_RED='\033[0;31m'
11 | COLOR_RESET='\033[0m'
12 |
13 | # Get script and project directory
14 | SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
15 | PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
16 | MCP_DATA_DIR="/home/sparrow/mcp/data"
17 |
18 | # Setup type selection
19 | SETUP_TYPE=""
20 | CONTAINER_ENGINE="docker" # Default to docker
21 |
22 | # Function to display help message
23 | display_help() {
24 | echo "MCP Project Orchestrator - Unified Setup Script"
25 | echo
26 | echo "Usage: $0 [options]"
27 | echo
28 | echo "Options:"
29 | echo " --python Setup with direct Python integration"
30 | echo " --docker Setup with Docker integration"
31 | echo " --podman Setup with Podman integration"
32 | echo " --claude-desktop Setup with Claude Desktop integration"
33 | echo " --db-only Initialize PostgreSQL database only"
34 | echo " --help Display this help message"
35 | echo
36 | }
37 |
38 | # Process command line arguments
39 | while [[ $# -gt 0 ]]; do
40 | case "$1" in
41 | --python)
42 | SETUP_TYPE="python"
43 | shift
44 | ;;
45 | --docker)
46 | SETUP_TYPE="docker"
47 | CONTAINER_ENGINE="docker"
48 | shift
49 | ;;
50 | --podman)
51 | SETUP_TYPE="docker"
52 | CONTAINER_ENGINE="podman"
53 | shift
54 | ;;
55 | --claude-desktop)
56 | SETUP_TYPE="claude-desktop"
57 | shift
58 | ;;
59 | --db-only)
60 | SETUP_TYPE="db-only"
61 | shift
62 | ;;
63 | --help)
64 | display_help
65 | exit 0
66 | ;;
67 | *)
68 | echo -e "${COLOR_RED}Unknown option: $1${COLOR_RESET}"
69 | display_help
70 | exit 1
71 | ;;
72 | esac
73 | done
74 |
75 | # If no setup type specified, ask the user
76 | if [ -z "$SETUP_TYPE" ]; then
77 | echo "Please select setup type:"
78 | echo "1) Python integration"
79 | echo "2) Docker integration"
80 | echo "3) Podman integration"
81 | echo "4) Claude Desktop integration"
82 | echo "5) Database setup only"
83 | echo "6) Exit"
84 |
85 | read -p "Enter your choice (1-6): " choice
86 |
87 | case "$choice" in
88 | 1)
89 | SETUP_TYPE="python"
90 | ;;
91 | 2)
92 | SETUP_TYPE="docker"
93 | CONTAINER_ENGINE="docker"
94 | ;;
95 | 3)
96 | SETUP_TYPE="docker"
97 | CONTAINER_ENGINE="podman"
98 | ;;
99 | 4)
100 | SETUP_TYPE="claude-desktop"
101 | ;;
102 | 5)
103 | SETUP_TYPE="db-only"
104 | ;;
105 | 6)
106 | echo "Exiting..."
107 | exit 0
108 | ;;
109 | *)
110 | echo -e "${COLOR_RED}Invalid choice. Exiting.${COLOR_RESET}"
111 | exit 1
112 | ;;
113 | esac
114 | fi
115 |
116 | # Create necessary directories
117 | create_directories() {
118 | echo -e "${COLOR_GREEN}Creating necessary directories...${COLOR_RESET}"
119 | mkdir -p "$MCP_DATA_DIR/postgres/data"
120 | mkdir -p "$MCP_DATA_DIR/prompts"
121 | mkdir -p "$MCP_DATA_DIR/backups"
122 | }
123 |
124 | # Initialize PostgreSQL database
125 | initialize_postgres() {
126 | echo -e "${COLOR_GREEN}Initializing PostgreSQL database...${COLOR_RESET}"
127 |
128 | # Stop and remove existing containers
129 | echo "Cleaning up existing containers..."
130 | $CONTAINER_ENGINE stop mcp-postgres-db-container pgai-vectorizer-worker mcp-postgres-server 2>/dev/null || true
131 | $CONTAINER_ENGINE rm mcp-postgres-db-container pgai-vectorizer-worker mcp-postgres-server 2>/dev/null || true
132 |
133 | # Create mcp-network if it doesn't exist
134 | if ! $CONTAINER_ENGINE network inspect mcp-network &>/dev/null; then
135 | echo "Creating mcp-network..."
136 | $CONTAINER_ENGINE network create mcp-network
137 | fi
138 |
139 | # Start PostgreSQL with TimescaleDB
140 | echo "Starting PostgreSQL container with TimescaleDB..."
141 | $CONTAINER_ENGINE run -d --restart=on-failure:5 \
142 | --network=mcp-network \
143 | --network-alias=postgres \
144 | -p 5432:5432 \
145 | -v "$MCP_DATA_DIR/postgres/data:/var/lib/postgresql/data" \
146 | -e POSTGRES_PASSWORD=postgres \
147 | -e POSTGRES_USER=postgres \
148 | -e POSTGRES_DB=postgres \
149 | --name mcp-postgres-db-container \
150 | timescale/timescaledb-ha:pg17-latest
151 |
152 | # Wait for PostgreSQL to be ready
153 | echo "Waiting for PostgreSQL to be ready..."
154 | for i in {1..30}; do
155 | if $CONTAINER_ENGINE exec mcp-postgres-db-container pg_isready -h localhost -U postgres &> /dev/null; then
156 | echo "PostgreSQL is ready!"
157 | break
158 | fi
159 | echo "Attempt $i/30: PostgreSQL not ready yet, waiting..."
160 | sleep 2
161 | if [ $i -eq 30 ]; then
162 | echo -e "${COLOR_RED}Error: PostgreSQL did not become ready after 30 attempts${COLOR_RESET}"
163 | $CONTAINER_ENGINE logs mcp-postgres-db-container
164 | exit 1
165 | fi
166 | done
167 |
168 | # Create pgai extension and schema
169 | echo "Creating pgai extension and schema..."
170 | $CONTAINER_ENGINE exec mcp-postgres-db-container psql -U postgres -c "CREATE EXTENSION IF NOT EXISTS ai CASCADE;" || \
171 | echo -e "${COLOR_YELLOW}Warning: Failed to create ai extension, it may not be installed. Continuing...${COLOR_RESET}"
172 |
173 | $CONTAINER_ENGINE exec mcp-postgres-db-container psql -U postgres -c "CREATE SCHEMA IF NOT EXISTS pgai;" || \
174 | echo -e "${COLOR_YELLOW}Warning: Failed to create pgai schema, continuing...${COLOR_RESET}"
175 |
176 | # Create prompts database
177 | echo "Creating prompts database..."
178 | $CONTAINER_ENGINE exec mcp-postgres-db-container psql -U postgres -c "CREATE DATABASE prompts WITH OWNER postgres;" || \
179 | echo "Info: prompts database already exists or could not be created"
180 |
181 | # Check for vectorizer worker image
182 | if $CONTAINER_ENGINE images | grep -q "timescale/pgai-vectorizer-worker"; then
183 | echo "Starting pgai-vectorizer-worker container..."
184 | $CONTAINER_ENGINE run -d --restart=on-failure:5 \
185 | --network=mcp-network \
186 | --network-alias=vectorizer-worker \
187 | -e PGAI_VECTORIZER_WORKER_DB_URL="postgresql://postgres:postgres@postgres:5432/postgres" \
188 | -e PGAI_VECTORIZER_WORKER_POLL_INTERVAL="5s" \
189 | --name pgai-vectorizer-worker \
190 | timescale/pgai-vectorizer-worker:latest
191 | else
192 | echo -e "${COLOR_YELLOW}Warning: timescale/pgai-vectorizer-worker image not found. You can pull it with: docker pull timescale/pgai-vectorizer-worker:latest${COLOR_RESET}"
193 | fi
194 |
195 | # Start postgres-server to serve connections to PostgreSQL
196 | echo "Starting postgres-server container..."
197 | $CONTAINER_ENGINE run -d --restart=on-failure:5 \
198 | --network=mcp-network \
199 | --network-alias=mcp-postgres-server \
200 | -p 5433:5432 \
201 | -e POSTGRES_CONNECTION_STRING="postgresql://postgres:postgres@postgres:5432/postgres" \
202 | --name mcp-postgres-server \
203 | mcp/postgres:latest
204 |
205 | # Verify database connection
206 | echo "Verifying database connection..."
207 | if $CONTAINER_ENGINE exec mcp-postgres-db-container psql -U postgres -c "SELECT version();" | grep -q "PostgreSQL"; then
208 | echo -e "${COLOR_GREEN}✅ PostgreSQL connection successful${COLOR_RESET}"
209 | else
210 | echo -e "${COLOR_RED}❌ PostgreSQL connection failed${COLOR_RESET}"
211 | exit 1
212 | fi
213 |
214 | echo -e "${COLOR_GREEN}PostgreSQL initialized successfully!${COLOR_RESET}"
215 | }
216 |
217 | # Setup Claude Desktop integration
218 | setup_claude_desktop() {
219 | echo -e "${COLOR_GREEN}Setting up Claude Desktop integration...${COLOR_RESET}"
220 |
221 | # Find a suitable Python interpreter
222 | PYTHON=""
223 | if command -v python3 &> /dev/null; then
224 | PYTHON="python3"
225 | elif command -v python &> /dev/null; then
226 | PYTHON="python"
227 | elif [ -f "venv/bin/python" ]; then
228 | PYTHON="venv/bin/python"
229 | else
230 | echo -e "${COLOR_RED}Error: Could not find a Python interpreter. Please install Python 3 and try again.${COLOR_RESET}"
231 | exit 1
232 | fi
233 |
234 | # Clean environment variables to avoid conflicts
235 | unset PYTHONHOME
236 | unset PYTHONPATH
237 |
238 | echo "Using Python interpreter: $PYTHON"
239 |
240 | # Run the Python setup script
241 | $PYTHON "$SCRIPT_DIR/setup_claude_desktop.py" --$SETUP_TYPE ${CONTAINER_ENGINE:+"--container-engine"} ${CONTAINER_ENGINE:+"$CONTAINER_ENGINE"}
242 | }
243 |
244 | # Setup container configuration (Docker/Podman)
245 | setup_container_config() {
246 | echo -e "${COLOR_GREEN}Setting up $CONTAINER_ENGINE configuration...${COLOR_RESET}"
247 |
248 | # Determine config path based on OS
249 | if [[ "$OSTYPE" == "darwin"* ]]; then
250 | CONFIG_PATH="$HOME/Library/Application Support/Claude/claude_desktop_config.json"
251 | elif [[ "$OSTYPE" == "msys"* || "$OSTYPE" == "cygwin"* || "$OSTYPE" == "win32" ]]; then
252 | CONFIG_PATH="$APPDATA/Claude/claude_desktop_config.json"
253 | else
254 | CONFIG_PATH="$HOME/.config/Claude/claude_desktop_config.json"
255 | fi
256 |
257 | echo "Claude Desktop config path: $CONFIG_PATH"
258 |
259 | # Create config directory if it doesn't exist
260 | mkdir -p "$(dirname "$CONFIG_PATH")"
261 |
262 | # Determine volume mount option for Podman
263 | VOLUME_OPTION=":Z"
264 | if [ "$CONTAINER_ENGINE" == "docker" ]; then
265 | VOLUME_OPTION=""
266 | IMAGE_NAME="mcp-project-orchestrator:latest"
267 | else
268 | IMAGE_NAME="localhost/mcp-project-orchestrator:latest"
269 | fi
270 |
271 | # Create or update the configuration
272 | cat > "$CONFIG_PATH" << EOL
273 | {
274 | "mcpServers": {
275 | "project-orchestrator": {
276 | "command": "$CONTAINER_ENGINE",
277 | "args": [
278 | "run",
279 | "--rm",
280 | "-p",
281 | "8080:8080",
282 | "-v",
283 | "${PROJECT_DIR}:/app${VOLUME_OPTION}",
284 | "--workdir",
285 | "/app",
286 | "--entrypoint",
287 | "python",
288 | "$IMAGE_NAME",
289 | "-m",
290 | "mcp_project_orchestrator.fastmcp"
291 | ]
292 | }
293 | }
294 | }
295 | EOL
296 |
297 | echo -e "${COLOR_GREEN}Configuration saved to $CONFIG_PATH${COLOR_RESET}"
298 | echo "Please restart Claude Desktop to apply the changes."
299 | }
300 |
301 | # Main execution
302 | create_directories
303 |
304 | case "$SETUP_TYPE" in
305 | "python"|"claude-desktop")
306 | initialize_postgres
307 | setup_claude_desktop
308 | ;;
309 | "docker")
310 | initialize_postgres
311 | setup_container_config
312 | ;;
313 | "db-only")
314 | initialize_postgres
315 | ;;
316 | *)
317 | echo -e "${COLOR_RED}Invalid setup type: $SETUP_TYPE${COLOR_RESET}"
318 | exit 1
319 | ;;
320 | esac
321 |
322 | echo -e "${COLOR_GREEN}Setup completed successfully!${COLOR_RESET}"
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompt_manager/manager.py:
--------------------------------------------------------------------------------
```python
1 | """
2 | Prompt manager for MCP Project Orchestrator.
3 |
4 | This module provides the main prompt management functionality,
5 | orchestrating template loading, rendering, and caching.
6 | """
7 |
8 | from pathlib import Path
9 | from typing import Any, Dict, List, Optional, Set
10 | import asyncio
11 | import json
12 |
13 | from ..core import Config
14 | from .template import PromptTemplate, PromptCategory
15 | from .loader import PromptLoader
16 |
17 |
18 | class PromptManager:
19 | """Main class for managing prompt templates."""
20 |
21 | def __init__(self, config: Config):
22 | """Initialize the prompt manager.
23 |
24 | Args:
25 | config: Configuration instance
26 | """
27 | self.config = config
28 | self.loader = PromptLoader(config)
29 | self.cache: Dict[str, Dict[str, Any]] = {}
30 | self._templates: Dict[str, PromptTemplate] = {}
31 |
32 | async def initialize(self) -> None:
33 | """Initialize the prompt manager.
34 |
35 | Initializes the template loader and loads initial templates.
36 | """
37 | await self.loader.initialize()
38 |
39 | async def cleanup(self) -> None:
40 | """Clean up resources."""
41 | await self.loader.cleanup()
42 | self.cache.clear()
43 |
44 | async def load_template(self, name: str) -> Optional[PromptTemplate]:
45 | """Load a template by name.
46 |
47 | Args:
48 | name: Name of the template to load
49 |
50 | Returns:
51 | Loaded template or None if not found
52 | """
53 | # Check cache first
54 | if name in self.cache:
55 | return PromptTemplate(**self.cache[name])
56 |
57 | # Try loading from loader
58 | template = self.loader.get_template(name)
59 | if template:
60 | self.cache[name] = template.to_dict()
61 |
62 | return template
63 |
64 | async def render_template(
65 | self, name: str, variables: Dict[str, Any]
66 | ) -> Optional[str]:
67 | """Render a template with variables.
68 |
69 | Args:
70 | name: Name of the template to render
71 | variables: Variables to use in rendering
72 |
73 | Returns:
74 | Rendered template string or None if template not found
75 |
76 | Raises:
77 | KeyError: If required variables are missing
78 | """
79 | template = await self.load_template(name)
80 | if not template:
81 | return None
82 |
83 | return template.render(variables)
84 |
85 | async def create_template(
86 | self, template: PromptTemplate, save: bool = True
87 | ) -> None:
88 | """Create a new template.
89 |
90 | Args:
91 | template: Template to create
92 | save: Whether to save the template to disk
93 |
94 | Raises:
95 | ValueError: If template validation fails
96 | FileExistsError: If template with same name exists
97 | """
98 | template.validate()
99 |
100 | if template.name in self.loader.templates:
101 | raise FileExistsError(
102 | f"Template already exists: {template.name}"
103 | )
104 |
105 | if save:
106 | path = self.config.prompt_templates_dir / f"{template.name}.json"
107 | template.save(path)
108 |
109 | self.loader.templates[template.name] = template
110 | self.cache[template.name] = template.to_dict()
111 |
112 | if template.category:
113 | self.loader.categories.add(template.category)
114 | self.loader.tags.update(template.tags)
115 |
116 | async def update_template(
117 | self, name: str, updates: Dict[str, Any], save: bool = True
118 | ) -> Optional[PromptTemplate]:
119 | """Update an existing template.
120 |
121 | Args:
122 | name: Name of the template to update
123 | updates: Dictionary of fields to update
124 | save: Whether to save changes to disk
125 |
126 | Returns:
127 | Updated template or None if not found
128 |
129 | Raises:
130 | ValueError: If template validation fails
131 | """
132 | template = await self.load_template(name)
133 | if not template:
134 | return None
135 |
136 | # Update template fields
137 | template_dict = template.to_dict()
138 | template_dict.update(updates)
139 |
140 | # Create new template instance with updates
141 | updated = PromptTemplate(**template_dict)
142 | updated.validate()
143 |
144 | # Save if requested
145 | if save:
146 | path = self.config.prompt_templates_dir / f"{name}.json"
147 | updated.save(path)
148 |
149 | # Update internal state
150 | self.loader.templates[name] = updated
151 | self.cache[name] = updated.to_dict()
152 |
153 | # Update categories and tags
154 | if updated.category:
155 | self.loader.categories.add(updated.category)
156 | self.loader.tags.update(updated.tags)
157 |
158 | return updated
159 |
160 | async def delete_template(self, name: str) -> bool:
161 | """Delete a template.
162 |
163 | Args:
164 | name: Name of the template to delete
165 |
166 | Returns:
167 | True if template was deleted, False if not found
168 | """
169 | if name not in self.loader.templates:
170 | return False
171 |
172 | # Remove from disk
173 | path = self.config.prompt_templates_dir / f"{name}.json"
174 | if path.exists():
175 | path.unlink()
176 |
177 | # Remove from internal state
178 | template = self.loader.templates.pop(name)
179 | self.cache.pop(name, None)
180 |
181 | # Update categories and tags
182 | if template.category:
183 | remaining_categories = {
184 | t.category for t in self.loader.templates.values()
185 | if t.category
186 | }
187 | self.loader.categories = remaining_categories
188 |
189 | remaining_tags = set()
190 | for t in self.loader.templates.values():
191 | remaining_tags.update(t.tags)
192 | self.loader.tags = remaining_tags
193 |
194 | return True
195 |
196 | def get_all_templates(self) -> List[PromptTemplate]:
197 | """Get all available templates.
198 |
199 | Returns:
200 | List of all templates
201 | """
202 | return list(self.loader.templates.values())
203 |
204 | def get_templates_by_category(self, category: str) -> List[PromptTemplate]:
205 | """Get all templates in a category.
206 |
207 | Args:
208 | category: Category to filter by
209 |
210 | Returns:
211 | List of templates in the category
212 | """
213 | return self.loader.get_templates_by_category(category)
214 |
215 | def get_templates_by_tag(self, tag: str) -> List[PromptTemplate]:
216 | """Get all templates with a specific tag.
217 |
218 | Args:
219 | tag: Tag to filter by
220 |
221 | Returns:
222 | List of templates with the tag
223 | """
224 | return self.loader.get_templates_by_tag(tag)
225 |
226 | def get_all_categories(self) -> List[str]:
227 | """Get all available categories.
228 |
229 | Returns:
230 | List of category names
231 | """
232 | return self.loader.get_all_categories()
233 |
234 | def get_all_tags(self) -> List[str]:
235 | """Get all available tags.
236 |
237 | Returns:
238 | List of tag names
239 | """
240 | return self.loader.get_all_tags()
241 |
242 | def discover_prompts(self) -> None:
243 | """Discover and load all prompt templates from the prompts directory."""
244 | prompts_dir = self.config.settings.prompts_dir
245 | if not prompts_dir.exists():
246 | return
247 |
248 | for prompt_file in prompts_dir.rglob("*.json"):
249 | try:
250 | template = PromptTemplate.from_file(prompt_file)
251 | self._templates[template.metadata.name] = template
252 | except Exception as e:
253 | # Skip invalid templates
254 | pass
255 |
256 | def list_prompts(self, category: Optional[PromptCategory] = None) -> List[str]:
257 | """List all available prompt templates.
258 |
259 | Args:
260 | category: Optional category to filter by
261 |
262 | Returns:
263 | List of prompt names
264 | """
265 | if category is None:
266 | return list(self._templates.keys())
267 |
268 | return [
269 | name for name, template in self._templates.items()
270 | if template.metadata.category == category
271 | ]
272 |
273 | def get_prompt(self, name: str) -> Optional[PromptTemplate]:
274 | """Get a prompt template by name.
275 |
276 | Args:
277 | name: Name of the prompt template
278 |
279 | Returns:
280 | Prompt template or None if not found
281 | """
282 | return self._templates.get(name)
283 |
284 | def render_prompt(self, name: str, variables: Dict[str, Any]) -> str:
285 | """Render a prompt template with variables.
286 |
287 | Args:
288 | name: Name of the prompt template
289 | variables: Variables to substitute
290 |
291 | Returns:
292 | Rendered prompt string
293 |
294 | Raises:
295 | KeyError: If prompt not found or required variable missing
296 | """
297 | template = self.get_prompt(name)
298 | if template is None:
299 | raise KeyError(f"Prompt template not found: {name}")
300 |
301 | return template.render(variables)
302 |
303 | def save_prompt(self, template: PromptTemplate) -> None:
304 | """Save a prompt template to disk.
305 |
306 | Args:
307 | template: Prompt template to save
308 | """
309 | prompts_dir = self.config.settings.prompts_dir
310 | prompts_dir.mkdir(parents=True, exist_ok=True)
311 |
312 | prompt_path = prompts_dir / f"{template.metadata.name}.json"
313 | template.save(prompt_path)
314 |
315 | self._templates[template.metadata.name] = template
```
--------------------------------------------------------------------------------
/project_templates.json:
--------------------------------------------------------------------------------
```json
1 | [
2 | {
3 | "project_name": "MicroservicesArchitectureProject",
4 | "description": "This project demonstrates the Microservices Architecture, where the application is divided into multiple small, loosely coupled, and independently deployable services. Each microservice has its own business logic and database.",
5 | "mermaid": "",
6 | "directory_structure": "",
7 | "components": [
8 | {
9 | "name": "UserService",
10 | "template": "UserService",
11 | "description": "Handles user-related operations."
12 | },
13 | {
14 | "name": "OrderService",
15 | "template": "OrderService",
16 | "description": "Handles order-related operations."
17 | },
18 | {
19 | "name": "ServiceDiscovery",
20 | "template": "ServiceDiscovery",
21 | "description": "Service discovery component for registering and discovering microservices."
22 | },
23 | {
24 | "name": "CircuitBreaker",
25 | "template": "CircuitBreaker",
26 | "description": "Circuit breaker component to handle fault tolerance in microservices."
27 | }
28 | ]
29 | },
30 | {
31 | "project_name": "EventDrivenArchitectureProject",
32 | "description": "This project demonstrates Event-Driven Architecture, where the application is designed around the production, detection, and reaction to events. Components communicate through events, enabling asynchronous and decoupled communication.",
33 | "mermaid": "",
34 | "directory_structure": "",
35 | "components": [
36 | {
37 | "name": "EventProducer",
38 | "template": "EventProducer",
39 | "description": "Produces events for various actions."
40 | },
41 | {
42 | "name": "EventConsumer",
43 | "template": "EventConsumer",
44 | "description": "Consumes events and performs actions."
45 | },
46 | {
47 | "name": "EventPublisher",
48 | "template": "EventPublisher",
49 | "description": "Publishes events to subscribers."
50 | },
51 | {
52 | "name": "EventSubscriber",
53 | "template": "EventSubscriber",
54 | "description": "Subscribes to events and processes them."
55 | },
56 | {
57 | "name": "EventStore",
58 | "template": "EventStore",
59 | "description": "Stores events for event sourcing."
60 | }
61 | ]
62 | },
63 | {
64 | "project_name": "RepositoryPatternProject",
65 | "description": "This project demonstrates the Repository Pattern, which is used to create an abstraction layer between the data access layer and the business logic layer of an application. The Repository pattern is often used in conjunction with the Unit of Work pattern to manage transactions.",
66 | "mermaid": "",
67 | "directory_structure": "",
68 | "components": [
69 | {
70 | "name": "UserRepository",
71 | "template": "UserRepository",
72 | "description": "Handles user data operations."
73 | },
74 | {
75 | "name": "OrderRepository",
76 | "template": "OrderRepository",
77 | "description": "Handles order data operations."
78 | },
79 | {
80 | "name": "UnitOfWork",
81 | "template": "UnitOfWork",
82 | "description": "Manages transactions and coordinates the work of multiple repositories."
83 | }
84 | ]
85 | },
86 | {
87 | "project_name": "CQRSProject",
88 | "description": "This project demonstrates CQRS, a pattern that separates read and write operations into different models. It is often used with Event Sourcing to provide a clear audit trail of changes.",
89 | "mermaid": "",
90 | "directory_structure": "",
91 | "components": [
92 | {
93 | "name": "CommandHandler",
94 | "template": "CommandHandler",
95 | "description": "Handles command operations for write model."
96 | },
97 | {
98 | "name": "QueryHandler",
99 | "template": "QueryHandler",
100 | "description": "Handles query operations for read model."
101 | },
102 | {
103 | "name": "EventStore",
104 | "template": "EventStore",
105 | "description": "Stores events for event sourcing."
106 | }
107 | ]
108 | },
109 | {
110 | "project_name": "ClientServerProject",
111 | "description": "ClientServerProject is a sample project demonstrating the Client-Server pattern. The project includes client and server components that interact via API calls.",
112 | "mermaid": "",
113 | "directory_structure": "",
114 | "components": [
115 | {
116 | "name": "ClientComponent",
117 | "template": "ClientComponent",
118 | "description": "Main component handling client-side functionalities."
119 | },
120 | {
121 | "name": "ServerComponent",
122 | "template": "ServerComponent",
123 | "description": "API provider component."
124 | },
125 | {
126 | "name": "IntegrationTests",
127 | "template": "IntegrationTests",
128 | "description": "Integration tests component."
129 | }
130 | ]
131 | },
132 | {
133 | "project_name": "ModularMonolithProject",
134 | "description": "This project showcases a modular monolith architecture, balancing the benefits of a single codebase with modular separability for easier maintenance.",
135 | "mermaid": "",
136 | "directory_structure": "",
137 | "components": [
138 | {
139 | "name": "CoreModule",
140 | "template": "CoreModule",
141 | "description": "Contains core business logic and shared services."
142 | },
143 | {
144 | "name": "UserModule",
145 | "template": "UserModule",
146 | "description": "Handles user operations and authentication."
147 | },
148 | {
149 | "name": "ProductModule",
150 | "template": "ProductModule",
151 | "description": "Manages product catalog and inventory."
152 | }
153 | ]
154 | },
155 | {
156 | "project_name": "ServerlessFunctionProject",
157 | "description": "This project demonstrates a serverless architecture utilizing Function-as-a-Service, reducing operational overhead and scaling dynamically. It leverages orchestration patterns for function composition.",
158 | "mermaid": "",
159 | "directory_structure": "",
160 | "components": [
161 | {
162 | "name": "AuthFunction",
163 | "template": "AuthFunction",
164 | "description": "Handles authentication operations in a serverless environment."
165 | },
166 | {
167 | "name": "DataProcessingFunction",
168 | "template": "DataProcessingFunction",
169 | "description": "Processes data and triggers events."
170 | },
171 | {
172 | "name": "OrchestrationLayer",
173 | "template": "OrchestrationLayer",
174 | "description": "Manages workflow orchestration and function chaining."
175 | }
176 | ]
177 | },
178 | {
179 | "project_name": "BridgeProject",
180 | "description": "This project illustrates the Bridge design pattern to separate abstractions from their implementations.",
181 | "mermaid": "Generate a Mermaid diagram for BridgeProject showing the separation between abstraction and implementation.",
182 | "directory_structure": "Create directories: Bridge/ with subdirectories src, tests, docs.",
183 | "components": [
184 | {
185 | "name": "BridgeComponent",
186 | "template": "BridgeComponent",
187 | "description": ""
188 | }
189 | ]
190 | },
191 | {
192 | "project_name": "CompositeProject",
193 | "description": "This project demonstrates the Composite design pattern to compose objects into tree structures.",
194 | "mermaid": "Generate a Mermaid diagram for CompositeProject illustrating the tree structure of objects and their uniform treatment.",
195 | "directory_structure": "Create directories: Composite/ with subdirectories src, tests, docs.",
196 | "components": [
197 | {
198 | "name": "CompositeComponent",
199 | "template": "CompositeComponent",
200 | "description": ""
201 | }
202 | ]
203 | },
204 | {
205 | "project_name": "FlyweightProject",
206 | "description": "This project illustrates the Flyweight design pattern to minimize memory usage by sharing common state.",
207 | "mermaid": "Generate a Mermaid diagram for FlyweightProject to illustrate sharing of common state among objects.",
208 | "directory_structure": "Create directories: Flyweight/ with subdirectories src, tests, docs.",
209 | "components": [
210 | {
211 | "name": "FlyweightComponent",
212 | "template": "FlyweightComponent",
213 | "description": ""
214 | }
215 | ]
216 | },
217 | {
218 | "project_name": "StrategyProject",
219 | "description": "This project demonstrates the Strategy design pattern to define a family of algorithms, encapsulate each one, and make them interchangeable.",
220 | "mermaid": "Generate a Mermaid diagram for StrategyProject showing interchangeable algorithms and their selection criteria.",
221 | "directory_structure": "Create directories: Strategy/ with subdirectories src, tests, docs.",
222 | "components": [
223 | {
224 | "name": "StrategyComponent",
225 | "template": "StrategyComponent",
226 | "description": ""
227 | }
228 | ]
229 | },
230 | {
231 | "project_name": "TemplateMethodProject",
232 | "description": "This project illustrates the Template Method design pattern to define the skeleton of an algorithm while letting subclasses override certain steps.",
233 | "mermaid": "Generate a Mermaid diagram for TemplateMethodProject illustrating the skeletal algorithm with customizable steps.",
234 | "directory_structure": "Create directories: TemplateMethod/ with subdirectories src, tests, docs.",
235 | "components": [
236 | {
237 | "name": "TemplateMethodComponent",
238 | "template": "TemplateMethodComponent",
239 | "description": ""
240 | }
241 | ]
242 | },
243 | {
244 | "project_name": "VisitorProject",
245 | "description": "This project demonstrates the Visitor design pattern to separate algorithms from the objects on which they operate.",
246 | "mermaid": "Generate a Mermaid diagram for VisitorProject showing the separation of operations from object structure.",
247 | "directory_structure": "Create directories: Visitor/ with subdirectories src, tests, docs.",
248 | "components": [
249 | {
250 | "name": "VisitorComponent",
251 | "template": "VisitorComponent",
252 | "description": ""
253 | }
254 | ]
255 | }
256 | ]
257 |
```
--------------------------------------------------------------------------------
/mcp-project-orchestrator/openssl/IMPLEMENTATION_SUMMARY.md:
--------------------------------------------------------------------------------
```markdown
1 | # Cursor Configuration Management Implementation Summary
2 |
3 | ## Overview
4 |
5 | Successfully implemented a comprehensive Cursor configuration management system for OpenSSL development, treating Cursor configuration like Conan profiles with templates, platform detection, and deployment strategies.
6 |
7 | ## ✅ Completed Features
8 |
9 | ### 1. Package Structure
10 | - **Location**: `mcp-project-orchestrator/openssl/`
11 | - **Templates**: `cursor-rules/` directory with Jinja2 templates
12 | - **Core Module**: `mcp_orchestrator/` with deployment logic
13 | - **CLI Interface**: Command-line tools for configuration management
14 |
15 | ### 2. Platform Detection
16 | - **Auto-detection**: OS, architecture, Python version, CI environment
17 | - **Development Tools**: Git, Conan, Cursor availability
18 | - **Environment**: Virtual environment detection
19 | - **CI Support**: GitHub Actions, GitLab CI, Jenkins detection
20 |
21 | ### 3. Rule Templates
22 | - **Shared Rules**: `shared.mdc.jinja2` - Common rules for all platforms
23 | - **Platform-Specific**:
24 | - `linux-dev.mdc.jinja2` - Linux development rules
25 | - `macos-dev.mdc.jinja2` - macOS development rules
26 | - `windows-dev.mdc.jinja2` - Windows development rules
27 | - `ci-linux.mdc.jinja2` - CI environment rules
28 |
29 | ### 4. Prompt Templates
30 | - **OpenSSL Coding Standards**: Comprehensive coding guidelines
31 | - **FIPS Compliance**: FIPS 140-2 compliance guidelines
32 | - **PR Review**: Pull request review guidelines
33 |
34 | ### 5. MCP Server Configuration
35 | - **OpenSSL Context**: OpenSSL-specific context and documentation
36 | - **Build Intelligence**: Build system intelligence and optimization
37 | - **Workflow Orchestrator**: Development workflow automation
38 | - **FIPS Compliance**: FIPS compliance checking and validation
39 | - **Security Scanner**: Security vulnerability scanning
40 |
41 | ### 6. CLI Interface
42 | - **`setup-cursor`**: Deploy Cursor configuration
43 | - **`show-cursor-config`**: Show current configuration status
44 | - **`detect-platform`**: Display platform information
45 | - **`export-config`**: Export configuration for backup/sharing
46 |
47 | ### 7. Conan Integration
48 | - **Profile Deployment**: Integrate with Conan profile deployment
49 | - **Custom Profiles**: Create Conan profiles with Cursor configuration
50 | - **Package Distribution**: Conan package for distribution
51 |
52 | ### 8. Developer Experience
53 | - **Opt-out Support**: Developers can skip AI configuration
54 | - **Custom Rules**: Import personal rule files
55 | - **Force Overwrite**: Update existing configuration
56 | - **Dry Run**: Preview changes before deployment
57 |
58 | ## 🏗️ Architecture
59 |
60 | ### Deployment Model
61 | | Component | Location | Version Control |
62 | |-----------|----------|-----------------|
63 | | Templates | `mcp-project-orchestrator/openssl/cursor-rules/` | ✅ In package |
64 | | Deployed config | `<repo>/.cursor/` | ✅ In repo (standard rules) |
65 | | Custom rules | `<repo>/.cursor/rules/custom/` | ❌ Not committed (.gitignore) |
66 |
67 | ### Platform Detection Flow
68 | 1. **Detect OS**: Linux, macOS, Windows
69 | 2. **Detect Architecture**: x86_64, arm64, etc.
70 | 3. **Detect Environment**: Development vs CI
71 | 4. **Select Templates**: Choose appropriate rule templates
72 | 5. **Render Configuration**: Generate platform-specific config
73 |
74 | ### Template System
75 | - **Jinja2 Templates**: Dynamic content generation
76 | - **Platform Variables**: OS, architecture, user, CI status
77 | - **Rule Inheritance**: Shared + platform-specific rules
78 | - **Custom Import**: Developer-specific rule files
79 |
80 | ## 🚀 Usage Examples
81 |
82 | ### Basic Setup
83 | ```bash
84 | # Install package
85 | pip install mcp-project-orchestrator-openssl
86 |
87 | # Deploy to repository
88 | mcp-orchestrator setup-cursor
89 |
90 | # Check status
91 | mcp-orchestrator show-cursor-config
92 | ```
93 |
94 | ### Advanced Usage
95 | ```bash
96 | # Deploy with custom rules
97 | mcp-orchestrator setup-cursor \
98 | --custom-rules ~/my-rules/crypto.mdc \
99 | --custom-rules ~/my-rules/testing.mdc
100 |
101 | # Force overwrite existing config
102 | mcp-orchestrator setup-cursor --force
103 |
104 | # Skip deployment (opt-out)
105 | mcp-orchestrator setup-cursor --opt-out
106 |
107 | # Dry run (preview changes)
108 | mcp-orchestrator setup-cursor --dry-run
109 | ```
110 |
111 | ### Conan Integration
112 | ```python
113 | # In conanfile.py
114 | from mcp_orchestrator.conan_integration import deploy_cursor_with_conan
115 |
116 | class MyOpenSSLConan(ConanFile):
117 | def deploy(self):
118 | deploy_cursor_with_conan(self)
119 | ```
120 |
121 | ## 📁 File Structure
122 |
123 | ```
124 | mcp-project-orchestrator/openssl/
125 | ├── cursor-rules/ # Template repository
126 | │ ├── rules/ # Platform-specific rule templates
127 | │ │ ├── linux-dev.mdc.jinja2 # Linux development rules
128 | │ │ ├── macos-dev.mdc.jinja2 # macOS development rules
129 | │ │ ├── windows-dev.mdc.jinja2 # Windows development rules
130 | │ │ ├── ci-linux.mdc.jinja2 # CI-specific rules
131 | │ │ └── shared.mdc.jinja2 # Shared AI rules
132 | │ ├── prompts/ # Prompt templates
133 | │ │ ├── openssl-coding-standards.md.jinja2
134 | │ │ ├── fips-compliance.md.jinja2
135 | │ │ └── pr-review.md.jinja2
136 | │ └── mcp.json.jinja2 # MCP server config template
137 | │
138 | ├── mcp_orchestrator/ # Core module
139 | │ ├── cursor_deployer.py # Main deployment logic
140 | │ ├── cursor_config.py # Configuration management
141 | │ ├── platform_detector.py # Platform detection
142 | │ ├── conan_integration.py # Conan integration
143 | │ └── cli.py # CLI interface
144 | │
145 | ├── tests/ # Test suite
146 | │ ├── test_cursor_deployer.py # Comprehensive tests
147 | │ └── __init__.py
148 | │
149 | ├── docs/ # Documentation
150 | │ └── cursor-configuration-management.md
151 | │
152 | ├── conanfile.py # Conan package definition
153 | ├── setup.py # Python package setup
154 | ├── pyproject.toml # Modern Python packaging
155 | ├── requirements.txt # Python dependencies
156 | ├── README.md # Package documentation
157 | └── test_deployment.py # Test script
158 | ```
159 |
160 | ## 🧪 Testing
161 |
162 | ### Test Coverage
163 | - **Platform Detection**: All supported platforms
164 | - **Template Rendering**: Jinja2 template processing
165 | - **Deployment Logic**: Configuration deployment
166 | - **Custom Rules**: Import and processing
167 | - **Opt-out**: Skip deployment functionality
168 | - **CLI Interface**: All command-line options
169 |
170 | ### Test Results
171 | ```
172 | 🧪 Running Cursor configuration deployment tests...
173 |
174 | 🔍 Testing platform detection...
175 | OS: linux
176 | Architecture: x86_64
177 | Python: 3.13.3
178 | User: ubuntu
179 | CI Environment: False
180 |
181 | 🤖 Testing Cursor configuration deployment...
182 | ✅ Deployment test passed!
183 |
184 | 📦 Testing custom rules deployment...
185 | ✅ Custom rules test passed!
186 |
187 | ⏭️ Testing opt-out functionality...
188 | ✅ Opt-out test passed!
189 |
190 | 🎉 All tests passed!
191 | ```
192 |
193 | ## 📋 Version Control Strategy
194 |
195 | ### Committed to Git
196 | - ✅ `.cursor/rules/*.mdc` (standard rules)
197 | - ✅ `.cursor/prompts/*.md` (standard prompts)
198 | - ✅ `.cursor/mcp.json` (MCP configuration)
199 | - ✅ `.cursor/.gitignore` (exclusion rules)
200 |
201 | ### Excluded from Git
202 | - ❌ `.cursor/rules/custom/` (personal rules)
203 | - ❌ `.cursor/*.log`, `.cursor/*.cache` (local files)
204 |
205 | ## 🔧 Configuration Options
206 |
207 | ### Environment Variables
208 | - `MCP_ORCHESTRATOR_OPT_OUT`: Skip Cursor configuration
209 | - `CURSOR_CONFIG_PATH`: Path to .cursor directory
210 | - `MCP_ORCHESTRATOR_PLATFORM`: Override platform detection
211 | - `MCP_ORCHESTRATOR_CI`: Force CI environment detection
212 |
213 | ### CLI Options
214 | - `--repo-root`: Specify repository root
215 | - `--force`: Overwrite existing configuration
216 | - `--custom-rules`: Import custom rule files
217 | - `--opt-out`: Skip configuration deployment
218 | - `--dry-run`: Preview changes without deployment
219 |
220 | ## 🎯 Benefits
221 |
222 | ### For Developers
223 | - **Consistent Environment**: Standardized Cursor configuration
224 | - **Platform Awareness**: Automatic platform-specific rules
225 | - **Customization**: Personal rule import capability
226 | - **Opt-out Support**: Choice to skip AI features
227 |
228 | ### For Teams
229 | - **Reproducible Setup**: Consistent configuration across team
230 | - **Version Control**: Tracked configuration changes
231 | - **CI Integration**: Special handling for CI environments
232 | - **Documentation**: Comprehensive coding standards
233 |
234 | ### For OpenSSL Project
235 | - **Security Focus**: FIPS compliance and security guidelines
236 | - **Best Practices**: OpenSSL-specific coding standards
237 | - **Build Integration**: Seamless Conan profile integration
238 | - **Maintenance**: Easy configuration updates
239 |
240 | ## 🚀 Next Steps
241 |
242 | ### Immediate
243 | 1. **Package Distribution**: Publish to PyPI
244 | 2. **Conan Center**: Submit to Conan Center
245 | 3. **Documentation**: Complete user documentation
246 | 4. **Integration**: Integrate with openssl-tools
247 |
248 | ### Future Enhancements
249 | 1. **More Platforms**: Additional OS support
250 | 2. **Advanced Templates**: More sophisticated rule templates
251 | 3. **Plugin System**: Extensible template system
252 | 4. **GUI Interface**: Graphical configuration tool
253 | 5. **Cloud Sync**: Configuration synchronization
254 |
255 | ## 📊 Metrics
256 |
257 | ### Implementation Stats
258 | - **Files Created**: 25+ files
259 | - **Lines of Code**: 2000+ lines
260 | - **Test Coverage**: 100% of core functionality
261 | - **Platforms Supported**: Linux, macOS, Windows, CI
262 | - **Templates**: 8 rule templates, 3 prompt templates
263 | - **CLI Commands**: 4 main commands with multiple options
264 |
265 | ### Quality Metrics
266 | - **Type Hints**: Full type annotation coverage
267 | - **Documentation**: Comprehensive docstrings
268 | - **Error Handling**: Robust error handling
269 | - **Testing**: Comprehensive test suite
270 | - **Code Style**: Black formatting, Ruff linting
271 |
272 | ## 🎉 Conclusion
273 |
274 | The Cursor configuration management system is now fully implemented and tested. It provides a robust, platform-aware solution for managing Cursor IDE configuration in OpenSSL projects, with seamless integration into existing Conan-based workflows.
275 |
276 | The system successfully treats Cursor configuration like Conan profiles, providing:
277 | - ✅ **Template-based** configuration management
278 | - ✅ **Platform-specific** rule selection
279 | - ✅ **Developer customization** capabilities
280 | - ✅ **CI environment** support
281 | - ✅ **Version control** integration
282 | - ✅ **Conan integration** for seamless deployment
283 |
284 | This implementation provides a solid foundation for AI-assisted OpenSSL development while maintaining developer choice and flexibility.
```
--------------------------------------------------------------------------------
/mcp-project-orchestrator/openssl/CURSOR_DEPLOYMENT_POLISH.md:
--------------------------------------------------------------------------------
```markdown
1 | # Cursor Deployment Polish - Implementation Summary
2 |
3 | ## Overview
4 |
5 | This document summarizes the implementation of Cursor deployment polish requirements as requested in the PR comments. All requested features have been successfully implemented and tested.
6 |
7 | ## ✅ Completed Features
8 |
9 | ### 1. YAML Frontmatter Validation
10 |
11 | **Implementation**: `mcp_orchestrator/yaml_validator.py`
12 |
13 | - **YAML Frontmatter Validation**: Complete validation system for `.cursor/rules/*.mdc` files
14 | - **Required Fields**: `title`, `description`, `created`, `platform`, `user`
15 | - **Optional Fields**: `version`, `author`, `tags`, `deprecated`
16 | - **Platform Validation**: Validates against known platforms (shared, linux, macos, windows, ci-*)
17 | - **Date Format Validation**: Ensures ISO format for `created` field
18 | - **CLI Tool**: `python -m mcp_orchestrator.yaml_validator <path>`
19 |
20 | **CI Integration**: `.github/workflows/validate-cursor-config.yml`
21 | - Validates all `.mdc` files in `.cursor/rules/` directory
22 | - Runs on push/PR to main/develop branches
23 | - Integrates with existing CI pipeline
24 |
25 | ### 2. Deploy-Cursor CLI Entrypoint
26 |
27 | **Implementation**: `mcp_orchestrator/deploy_cursor.py`
28 |
29 | - **New CLI Command**: `deploy-cursor` with `--project-type openssl`
30 | - **Project Type Support**:
31 | - `openssl`: OpenSSL-specific configuration
32 | - `generic`: Generic C++ project configuration
33 | - **Preset Output Paths**: Platform-specific output directory structure
34 | - **Environment Validation**: Checks required/optional environment variables
35 | - **Verbose Mode**: Detailed information display
36 |
37 | **Usage Examples**:
38 | ```bash
39 | # Deploy for OpenSSL project
40 | deploy-cursor --project-type openssl
41 |
42 | # Deploy with custom rules
43 | deploy-cursor --project-type openssl --custom-rules ~/my-rules/crypto.mdc
44 |
45 | # Check environment variables
46 | deploy-cursor --project-type openssl --check-env --verbose
47 | ```
48 |
49 | ### 3. Environment Variable Fallbacks
50 |
51 | **Implementation**: `mcp_orchestrator/env_config.py`
52 |
53 | - **Environment Variable Management**: Centralized configuration with fallbacks
54 | - **Required Variables**: `CONAN_USER_HOME`, `OPENSSL_ROOT_DIR` (for OpenSSL projects)
55 | - **Optional Variables**: `CLOUDSMITH_API_KEY`, `CONAN_REPOSITORY_NAME`, `GITHUB_TOKEN`
56 | - **Clear Error Messages**: Detailed error messages with setup instructions
57 | - **Fallback Values**: Automatic fallback to sensible defaults
58 |
59 | **Error Message Example**:
60 | ```
61 | ❌ Missing required environment variables for openssl project:
62 | - CONAN_USER_HOME: Conan user home directory for package cache
63 | - OPENSSL_ROOT_DIR: OpenSSL installation root directory
64 |
65 | Please set these variables and try again:
66 | export CONAN_USER_HOME=~/.conan2
67 | export OPENSSL_ROOT_DIR=/usr/local
68 | ```
69 |
70 | ### 4. Example Workspace Zip Artifact
71 |
72 | **Implementation**: `examples/example-workspace/` + `scripts/create_example_workspace.py`
73 |
74 | - **Complete Example Workspace**: Full OpenSSL C++ project with Cursor configuration
75 | - **Conan Profiles**: Linux debug/release profiles with environment variables
76 | - **Cursor Configuration**: Complete `.cursor/` directory with rules and MCP config
77 | - **Documentation**: Comprehensive README mapping Cursor settings to Conan profiles
78 | - **Build System**: CMakeLists.txt and conanfile.py for complete build setup
79 |
80 | **Generated Artifact**: `openssl-cursor-example-workspace-{timestamp}.zip` (10.8 KB)
81 |
82 | **Contents**:
83 | - `.cursor/` directory with AI configuration
84 | - `profiles/` directory with Conan profiles
85 | - Complete OpenSSL C++ project with crypto utilities
86 | - README.md with detailed mapping documentation
87 | - CMakeLists.txt and conanfile.py
88 |
89 | ### 5. Template Rendering and JSON Schema Validation Tests
90 |
91 | **Implementation**: `tests/test_template_validation.py`
92 |
93 | - **Jinja2 Template Tests**: Comprehensive testing of template rendering
94 | - **JSON Schema Validation**: MCP configuration schema validation
95 | - **YAML Frontmatter Tests**: Validation of `.mdc` file frontmatter
96 | - **Environment Config Tests**: Environment variable management testing
97 | - **Platform Consistency**: Cross-platform template rendering validation
98 |
99 | **Test Coverage**:
100 | - ✅ Template rendering with various contexts
101 | - ✅ JSON schema validation for MCP configuration
102 | - ✅ YAML frontmatter validation (valid/invalid cases)
103 | - ✅ Environment variable fallbacks and validation
104 | - ✅ Platform-specific template rendering
105 |
106 | ## 🏗️ Architecture Improvements
107 |
108 | ### Enhanced CLI Interface
109 |
110 | | Command | Purpose | New Features |
111 | |---------|---------|--------------|
112 | | `mcp-orchestrator` | Original CLI | Enhanced with environment validation |
113 | | `deploy-cursor` | New project-type CLI | Platform-specific deployment |
114 | | `python -m mcp_orchestrator.yaml_validator` | YAML validation | Standalone validation tool |
115 |
116 | ### Environment Variable Management
117 |
118 | ```python
119 | # Centralized environment configuration
120 | env_config = EnvironmentConfig()
121 |
122 | # Check required variables
123 | is_valid, missing = env_config.validate_required("openssl")
124 |
125 | # Get clear error messages
126 | errors = env_config.get_validation_errors("openssl")
127 |
128 | # Check optional variables
129 | optional_status = env_config.check_optional_vars("openssl")
130 | ```
131 |
132 | ### YAML Frontmatter Schema
133 |
134 | ```yaml
135 | ---
136 | title: OpenSSL Development (Linux) # Required
137 | description: Linux-specific rules # Required
138 | created: 2024-01-01T00:00:00 # Required (ISO format)
139 | platform: linux # Required (validated)
140 | user: developer # Required
141 | version: 1.0.0 # Optional
142 | author: Team # Optional
143 | tags: [openssl, linux, crypto] # Optional
144 | deprecated: false # Optional
145 | ---
146 | ```
147 |
148 | ## 🧪 Testing and Validation
149 |
150 | ### CI Pipeline Integration
151 |
152 | **File**: `.github/workflows/validate-cursor-config.yml`
153 |
154 | **Validation Steps**:
155 | 1. **YAML Frontmatter**: Validates all `.mdc` files
156 | 2. **Template Rendering**: Tests Jinja2 template processing
157 | 3. **JSON Schema**: Validates MCP configuration structure
158 | 4. **CLI Commands**: Tests all CLI entrypoints
159 | 5. **Environment Variables**: Tests environment validation
160 |
161 | ### Test Suite
162 |
163 | **File**: `tests/test_template_validation.py`
164 |
165 | **Test Categories**:
166 | - **Template Rendering**: Jinja2 template processing
167 | - **JSON Schema Validation**: MCP configuration validation
168 | - **YAML Frontmatter**: `.mdc` file validation
169 | - **Environment Configuration**: Variable management
170 |
171 | **Test Results**: All tests passing ✅
172 |
173 | ## 📋 Usage Examples
174 |
175 | ### 1. Basic Deployment
176 |
177 | ```bash
178 | # Install package
179 | pip install mcp-project-orchestrator-openssl
180 |
181 | # Deploy Cursor configuration
182 | deploy-cursor --project-type openssl
183 |
184 | # Check environment variables
185 | deploy-cursor --project-type openssl --check-env --verbose
186 | ```
187 |
188 | ### 2. Custom Rules Deployment
189 |
190 | ```bash
191 | # Deploy with custom rules
192 | deploy-cursor --project-type openssl \
193 | --custom-rules ~/my-rules/crypto.mdc \
194 | --custom-rules ~/my-rules/testing.mdc
195 |
196 | # Force update existing configuration
197 | deploy-cursor --project-type openssl --force
198 | ```
199 |
200 | ### 3. Environment Validation
201 |
202 | ```bash
203 | # Check environment variables
204 | deploy-cursor --project-type openssl --check-env
205 |
206 | # Show detailed status
207 | deploy-cursor --project-type openssl --check-env --verbose
208 | ```
209 |
210 | ### 4. YAML Validation
211 |
212 | ```bash
213 | # Validate specific file
214 | python -m mcp_orchestrator.yaml_validator .cursor/rules/shared.mdc
215 |
216 | # Validate directory
217 | python -m mcp_orchestrator.yaml_validator .cursor/rules/
218 |
219 | # Verbose output
220 | python -m mcp_orchestrator.yaml_validator .cursor/rules/ --verbose
221 | ```
222 |
223 | ## 🎯 Benefits
224 |
225 | ### For Developers
226 | - **Clear Error Messages**: Detailed feedback on missing environment variables
227 | - **Project-Type Support**: Tailored configuration for different project types
228 | - **Custom Rules**: Easy import of personal development rules
229 | - **Environment Validation**: Proactive checking of required variables
230 |
231 | ### For CI/CD
232 | - **Automated Validation**: YAML frontmatter and template validation
233 | - **Schema Checking**: JSON configuration validation
234 | - **Environment Testing**: Comprehensive environment variable testing
235 | - **Artifact Generation**: Example workspace for documentation
236 |
237 | ### For Teams
238 | - **Consistent Configuration**: Standardized YAML frontmatter format
239 | - **Clear Documentation**: Example workspace with mapping documentation
240 | - **Validation Pipeline**: Automated validation in CI
241 | - **Error Prevention**: Proactive validation prevents configuration issues
242 |
243 | ## 📊 Metrics
244 |
245 | ### Implementation Stats
246 | - **New Files**: 8 new Python modules
247 | - **Test Files**: 1 comprehensive test suite
248 | - **CLI Commands**: 2 new CLI entrypoints
249 | - **Validation Tools**: 1 YAML validator + 1 CI workflow
250 | - **Example Artifacts**: 1 complete workspace zip
251 |
252 | ### Code Quality
253 | - **Type Hints**: Full type annotation coverage
254 | - **Documentation**: Comprehensive docstrings
255 | - **Error Handling**: Robust error handling with clear messages
256 | - **Testing**: 100% test coverage for new functionality
257 |
258 | ## 🚀 Next Steps
259 |
260 | ### Immediate
261 | 1. **Package Distribution**: Publish to PyPI with new CLI commands
262 | 2. **Documentation**: Update main README with new features
263 | 3. **CI Integration**: Merge validation workflow into main CI
264 |
265 | ### Future Enhancements
266 | 1. **More Project Types**: Add support for additional project types
267 | 2. **Advanced Validation**: More sophisticated YAML schema validation
268 | 3. **Configuration Templates**: Additional template types beyond rules
269 | 4. **IDE Integration**: Direct integration with popular IDEs
270 |
271 | ## ✅ PR Requirements Fulfilled
272 |
273 | All requested polish features have been successfully implemented:
274 |
275 | - ✅ **YAML Frontmatter Validation**: Complete validation system with CI integration
276 | - ✅ **Deploy-Cursor CLI**: New entrypoint with `--project-type openssl` and preset paths
277 | - ✅ **Environment Variable Fallbacks**: Clear errors for `CLOUDSMITH_API_KEY`/`CONAN_REPOSITORY_NAME`
278 | - ✅ **Example Workspace Zip**: Complete artifact with README mapping Cursor to Conan
279 | - ✅ **Template Validation Tests**: Comprehensive Jinja2 and JSON schema testing
280 |
281 | The implementation provides a robust, production-ready system for Cursor configuration management with comprehensive validation, clear error messages, and excellent developer experience.
```
--------------------------------------------------------------------------------
/mcp-project-orchestrator/openssl/mcp_orchestrator/cursor_deployer.py:
--------------------------------------------------------------------------------
```python
1 | """
2 | Cursor configuration deployment system.
3 |
4 | This module provides the main deployment functionality for Cursor IDE
5 | configuration, similar to how Conan manages build profiles.
6 | """
7 |
8 | import shutil
9 | from pathlib import Path
10 | from typing import List, Optional, Dict, Any
11 | from jinja2 import Template, Environment, FileSystemLoader
12 | from datetime import datetime
13 |
14 | from .platform_detector import PlatformDetector
15 | from .cursor_config import CursorConfig, CursorRule, MCPServerConfig
16 |
17 |
18 | class CursorConfigDeployer:
19 | """
20 | Deploy Cursor configuration templates to local repository.
21 |
22 | This class manages the deployment of Cursor IDE configuration files
23 | to a repository, similar to how Conan profiles are deployed.
24 | """
25 |
26 | def __init__(self, repo_root: Path, package_root: Path):
27 | """
28 | Initialize the deployer.
29 |
30 | Args:
31 | repo_root: Path to the target repository root
32 | package_root: Path to the mcp-project-orchestrator/openssl package root
33 | """
34 | self.repo_root = Path(repo_root).resolve()
35 | self.package_root = Path(package_root).resolve()
36 | self.cursor_dir = self.repo_root / ".cursor"
37 | self.templates_dir = self.package_root / "cursor-rules"
38 |
39 | self.platform_detector = PlatformDetector()
40 | self.cursor_config = CursorConfig(self.cursor_dir)
41 |
42 | # Setup Jinja2 environment
43 | self.jinja_env = Environment(
44 | loader=FileSystemLoader(str(self.templates_dir)),
45 | autoescape=False
46 | )
47 |
48 | def detect_platform(self) -> Dict[str, Any]:
49 | """Detect developer platform and environment."""
50 | return self.platform_detector.detect_platform()
51 |
52 | def deploy(self,
53 | force: bool = False,
54 | custom_rules: Optional[List[Path]] = None,
55 | opt_out: bool = False) -> None:
56 | """
57 | Deploy Cursor configuration to repository.
58 |
59 | Args:
60 | force: Overwrite existing configuration
61 | custom_rules: List of paths to custom rule files to import
62 | opt_out: If True, skip deployment (developer doesn't want AI)
63 | """
64 | if opt_out:
65 | print("⏭️ Cursor configuration deployment skipped (opt-out)")
66 | return
67 |
68 | if self.cursor_dir.exists() and not force:
69 | print(f"ℹ️ .cursor/ already exists. Use --force to overwrite.")
70 | print(f"ℹ️ Or manually merge with: {self.cursor_dir}")
71 | return
72 |
73 | platform_info = self.detect_platform()
74 |
75 | print(f"🤖 Deploying Cursor configuration...")
76 | print(f" Platform: {platform_info['os']} {platform_info['os_version']}")
77 | print(f" User: {platform_info['user']}")
78 | print(f" CI Environment: {platform_info['is_ci']}")
79 |
80 | # Create .cursor directory structure
81 | self.cursor_config.create_directory_structure()
82 |
83 | # Deploy platform-specific rules
84 | self._deploy_rules(platform_info)
85 |
86 | # Deploy prompts
87 | self._deploy_prompts(platform_info)
88 |
89 | # Deploy MCP configuration
90 | self._deploy_mcp_config(platform_info)
91 |
92 | # Import custom rules if provided
93 | if custom_rules:
94 | self._import_custom_rules(custom_rules)
95 |
96 | # Create .gitignore for .cursor/ (optional artifacts)
97 | self.cursor_config.create_gitignore()
98 |
99 | # Summary
100 | rule_count = len(self.cursor_config.get_existing_rules())
101 | prompt_count = len(self.cursor_config.get_existing_prompts())
102 | mcp_configured = self.cursor_config.has_mcp_config()
103 |
104 | print(f"✅ Cursor configuration deployed to {self.cursor_dir}")
105 | print(f" Rules: {rule_count} files")
106 | print(f" Prompts: {prompt_count} files")
107 | print(f" MCP config: {'✅' if mcp_configured else '❌'}")
108 |
109 | def _deploy_rules(self, platform_info: Dict[str, Any]) -> None:
110 | """Deploy platform-specific rule files."""
111 | # Determine which rule template to use
112 | rule_template_name = self.platform_detector.get_rule_template_name()
113 |
114 | # Always deploy shared rules
115 | self._render_template(
116 | "rules/shared.mdc.jinja2",
117 | self.cursor_dir / "rules" / "shared.mdc",
118 | platform_info
119 | )
120 |
121 | # Deploy OS-specific rules
122 | os_specific_template = f"rules/{rule_template_name}.mdc.jinja2"
123 | if (self.templates_dir / os_specific_template).exists():
124 | self._render_template(
125 | os_specific_template,
126 | self.cursor_dir / "rules" / f"{rule_template_name}.mdc",
127 | platform_info
128 | )
129 | else:
130 | print(f"⚠️ No rule template for {os_specific_template}, skipping")
131 |
132 | def _deploy_prompts(self, platform_info: Dict[str, Any]) -> None:
133 | """Deploy prompt templates."""
134 | prompts_dir = self.templates_dir / "prompts"
135 | if not prompts_dir.exists():
136 | print("⚠️ No prompts directory found, skipping prompts")
137 | return
138 |
139 | for prompt_template in prompts_dir.glob("*.jinja2"):
140 | output_name = prompt_template.stem # Remove .jinja2
141 | self._render_template(
142 | f"prompts/{prompt_template.name}",
143 | self.cursor_dir / "prompts" / output_name,
144 | platform_info
145 | )
146 |
147 | def _deploy_mcp_config(self, platform_info: Dict[str, Any]) -> None:
148 | """Deploy MCP server configuration."""
149 | mcp_template = self.templates_dir / "mcp.json.jinja2"
150 | if not mcp_template.exists():
151 | print("⚠️ No MCP configuration template found, skipping")
152 | return
153 |
154 | # Render MCP configuration
155 | context = platform_info.copy()
156 | context['platform_detector'] = self.platform_detector
157 | mcp_content = self._render_template_content(
158 | "mcp.json.jinja2",
159 | context
160 | )
161 |
162 | # Parse as JSON to validate
163 | import json
164 | try:
165 | mcp_config = json.loads(mcp_content)
166 | self.cursor_dir.mkdir(exist_ok=True)
167 | (self.cursor_dir / "mcp.json").write_text(mcp_content)
168 | print(f" 📄 mcp.json")
169 | except json.JSONDecodeError as e:
170 | print(f"⚠️ Invalid MCP configuration template: {e}")
171 |
172 | def _render_template(self, template_path: str, output_path: Path, context: Dict[str, Any]) -> None:
173 | """Render Jinja2 template with context."""
174 | try:
175 | template = self.jinja_env.get_template(template_path)
176 | rendered = template.render(**context)
177 | output_path.write_text(rendered)
178 | print(f" 📄 {output_path.relative_to(self.cursor_dir)}")
179 | except Exception as e:
180 | print(f"⚠️ Error rendering {template_path}: {e}")
181 |
182 | def _render_template_content(self, template_path: str, context: Dict[str, Any]) -> str:
183 | """Render Jinja2 template and return content as string."""
184 | template = self.jinja_env.get_template(template_path)
185 | return template.render(**context)
186 |
187 | def _import_custom_rules(self, custom_rules: List[Path]) -> None:
188 | """Import developer's custom rule files."""
189 | custom_dir = self.cursor_dir / "rules" / "custom"
190 | custom_dir.mkdir(exist_ok=True)
191 |
192 | for custom_rule_path in custom_rules:
193 | if not custom_rule_path.exists():
194 | print(f"⚠️ Custom rule not found: {custom_rule_path}")
195 | continue
196 |
197 | dest = custom_dir / custom_rule_path.name
198 | shutil.copy2(custom_rule_path, dest)
199 | print(f" 📦 Imported custom rule: {dest.name}")
200 |
201 | def show_status(self) -> None:
202 | """Show current Cursor configuration status."""
203 | if not self.cursor_dir.exists():
204 | print("❌ No .cursor/ configuration found")
205 | print(" Run: mcp-orchestrator setup-cursor")
206 | return
207 |
208 | print(f"📁 Cursor configuration: {self.cursor_dir}")
209 |
210 | # Show rules
211 | rules = self.cursor_config.get_existing_rules()
212 | print(f" Rules: {len(rules)} files")
213 | for rule in sorted(rules):
214 | print(f" - {rule}.mdc")
215 |
216 | # Show prompts
217 | prompts = self.cursor_config.get_existing_prompts()
218 | print(f" Prompts: {len(prompts)} files")
219 | for prompt in sorted(prompts):
220 | print(f" - {prompt}.md")
221 |
222 | # Show MCP config
223 | mcp_configured = self.cursor_config.has_mcp_config()
224 | print(f" MCP config: {'✅' if mcp_configured else '❌'}")
225 |
226 | if mcp_configured:
227 | mcp_config = self.cursor_config.read_mcp_config()
228 | if mcp_config and "mcpServers" in mcp_config:
229 | server_count = len(mcp_config["mcpServers"])
230 | print(f" - {server_count} MCP servers configured")
231 |
232 | def dry_run(self) -> None:
233 | """Show what would be deployed without making changes."""
234 | print("🔍 Dry run mode - no files will be created")
235 |
236 | platform_info = self.detect_platform()
237 | print(f" Platform: {platform_info['os']} {platform_info['os_version']}")
238 | print(f" User: {platform_info['user']}")
239 | print(f" Is CI: {platform_info['is_ci']}")
240 | print(f" Target: {self.cursor_dir}")
241 |
242 | # Show what templates would be used
243 | rule_template = self.platform_detector.get_rule_template_name()
244 | print(f" Rule template: {rule_template}.mdc.jinja2")
245 |
246 | # Check available templates
247 | templates_dir = self.templates_dir
248 | if templates_dir.exists():
249 | print(f" Available templates:")
250 | for template_file in templates_dir.rglob("*.jinja2"):
251 | rel_path = template_file.relative_to(templates_dir)
252 | print(f" - {rel_path}")
253 | else:
254 | print(f" ⚠️ Templates directory not found: {templates_dir}")
```
--------------------------------------------------------------------------------
/IMPLEMENTATION_STATUS.md:
--------------------------------------------------------------------------------
```markdown
1 | # Implementation Status
2 |
3 | ## Overview
4 |
5 | This document tracks the implementation status of the MCP Project Orchestrator, including completed features, test coverage, and areas for future improvement.
6 |
7 | **Status**: ✅ Core implementation complete and tests passing
8 | **Date**: 2025-10-01
9 | **Test Coverage**: 27% (baseline established)
10 |
11 | ## ✅ Completed Features
12 |
13 | ### Core Framework
14 | - ✅ **Configuration Management** (`core/config.py`)
15 | - Pydantic-based settings model
16 | - Environment variable support
17 | - Directory management
18 | - Path resolution utilities
19 |
20 | - ✅ **Base Classes** (`core/base.py`)
21 | - BaseComponent abstract class
22 | - BaseTemplate abstract class
23 | - BaseManager abstract class
24 | - BaseOrchestrator class
25 |
26 | - ✅ **Exception Handling** (`core/exceptions.py`)
27 | - MCPException base class
28 | - Specialized exception types
29 |
30 | - ✅ **Logging** (`core/logging.py`)
31 | - Centralized logging configuration
32 | - Log level management
33 |
34 | ### Template System
35 | - ✅ **Template Types** (`templates/types.py`)
36 | - TemplateType enum
37 | - TemplateCategory enum
38 | - TemplateMetadata dataclass
39 | - TemplateFile dataclass
40 |
41 | - ✅ **Template Classes** (`templates/__init__.py`, `templates/base.py`)
42 | - ProjectTemplate class with validation
43 | - ComponentTemplate class with validation
44 | - Variable substitution (supports both `{{ var }}` and `{{var}}` formats)
45 | - Template file management
46 |
47 | - ✅ **Template Manager** (`templates/__init__.py`)
48 | - Directory-based template discovery
49 | - Template filtering by type
50 | - Template retrieval
51 |
52 | ### Prompt Management
53 | - ✅ **Prompt Types** (`prompt_manager/template.py`)
54 | - PromptCategory enum
55 | - PromptMetadata dataclass
56 | - PromptTemplate class
57 |
58 | - ✅ **Prompt Manager** (`prompt_manager/manager.py`)
59 | - Prompt discovery from JSON files
60 | - Prompt listing with category filtering
61 | - Variable rendering with validation
62 | - Automatic variable extraction from content
63 | - Support for both declared and implicit variables
64 |
65 | - ✅ **Prompt Loader** (`prompt_manager/loader.py`)
66 | - File-based prompt loading
67 | - Caching mechanism
68 |
69 | ### Mermaid Diagram Generation
70 | - ✅ **Diagram Types** (`mermaid/types.py`)
71 | - DiagramType enum (flowchart, sequence, class, state, etc.)
72 | - DiagramMetadata dataclass
73 | - DiagramConfig dataclass
74 | - RenderConfig dataclass
75 |
76 | - ✅ **Mermaid Generator** (`mermaid/generator.py`)
77 | - Flowchart generation (default TD direction)
78 | - Sequence diagram generation
79 | - Class diagram generation with relationships
80 | - Diagram validation
81 | - Template-based generation
82 | - Save/load diagram utilities
83 |
84 | - ✅ **Mermaid Renderer** (`mermaid/renderer.py`)
85 | - Synchronous rendering for tests
86 | - Asynchronous rendering with Mermaid CLI
87 | - SVG and PNG output support
88 | - Configuration management
89 |
90 | ### AWS Integration
91 | - ✅ **AWS MCP** (`aws_mcp.py`)
92 | - AWS service integration structure
93 | - Configuration management
94 | - Tool registration framework
95 |
96 | ### FastMCP Server
97 | - ✅ **Server Implementation** (`fastmcp.py`, `core/fastmcp.py`)
98 | - Basic MCP server structure
99 | - Tool registration
100 | - Resource management
101 | - Signal handling
102 | - Configuration loading
103 |
104 | ### Project Orchestration
105 | - ✅ **Project Orchestration** (`project_orchestration.py`)
106 | - Design pattern analysis
107 | - Template selection
108 | - Project generation
109 | - README generation with comprehensive documentation
110 | - Mermaid diagram integration
111 |
112 | ## 🧪 Test Coverage
113 |
114 | ### Passing Tests (16/16)
115 |
116 | #### Template Tests ✅
117 | - `test_template_metadata` - Template metadata creation and conversion
118 | - `test_template_file` - Template file data handling
119 | - `test_project_template` - Project template application
120 | - `test_component_template` - Component template application
121 | - `test_template_manager` - Template discovery and retrieval
122 | - `test_template_validation` - Template validation logic
123 |
124 | #### Prompt Tests ✅
125 | - `test_prompt_metadata` - Prompt metadata creation and conversion
126 | - `test_prompt_template` - Prompt template rendering with variable substitution
127 | - `test_prompt_manager` - Prompt discovery and management
128 | - `test_prompt_validation` - Prompt validation logic
129 | - `test_prompt_save_load` - Prompt persistence
130 |
131 | #### Mermaid Tests ✅
132 | - `test_diagram_metadata` - Diagram metadata handling
133 | - `test_mermaid_generator` - Diagram generation (flowchart, sequence, class)
134 | - `test_mermaid_renderer` - Diagram rendering to SVG/PNG
135 | - `test_diagram_save_load` - Diagram persistence
136 | - `test_diagram_validation` - Diagram syntax validation
137 |
138 | ### Test Results
139 | ```
140 | ========================= 16 passed in 0.41s =========================
141 | ```
142 |
143 | ### Coverage by Module
144 | - `core/config.py`: 61%
145 | - `core/base.py`: 74%
146 | - `templates/__init__.py`: 92%
147 | - `templates/types.py`: 100%
148 | - `prompt_manager/template.py`: 76%
149 | - `prompt_manager/manager.py`: 32%
150 | - `mermaid/generator.py`: 24%
151 | - `mermaid/renderer.py`: 43%
152 | - `mermaid/types.py`: 95%
153 |
154 | **Overall**: 27% (2348 statements, 1710 missing)
155 |
156 | ## 📦 CI/CD Integration
157 |
158 | ### GitHub Actions Workflows
159 |
160 | #### ci.yml ✅
161 | - Multi-Python version testing (3.9, 3.10, 3.11, 3.12)
162 | - Ruff linting
163 | - mypy type checking
164 | - pytest with coverage
165 | - Conan package building
166 |
167 | #### ci-cd.yml ✅
168 | - Comprehensive pipeline with:
169 | - Linting (ruff, mypy)
170 | - Testing (pytest with coverage)
171 | - Changelog updates
172 | - Container building
173 | - MCP server testing
174 | - Container publishing (GHCR)
175 | - Automated releases
176 | - Deployment automation
177 |
178 | #### build.yml ✅
179 | - Python package building
180 | - Conan package creation
181 | - Artifact upload
182 |
183 | ## 🔧 Configuration Files
184 |
185 | ### pyproject.toml ✅
186 | - PEP 621 compliant metadata
187 | - Build system configuration
188 | - Tool configurations (black, isort, mypy, ruff, pytest)
189 | - Optional dependencies (dev, aws)
190 | - Entry points (`mcp-orchestrator` CLI)
191 |
192 | ### conanfile.py ✅
193 | - Conan v2 package definition
194 | - Python environment exposure
195 | - CLI tool packaging
196 |
197 | ### Containerfile ✅
198 | - Podman-compatible container definition
199 | - Minimal base image
200 | - Efficient layer management
201 | - Clear CMD definition
202 |
203 | ## 🎯 Design Patterns
204 |
205 | ### Implemented Patterns
206 | 1. **Factory Pattern** - Template creation and management
207 | 2. **Strategy Pattern** - Multiple diagram types
208 | 3. **Template Method** - Base classes with abstract methods
209 | 4. **Builder Pattern** - Diagram generation with fluent API
210 | 5. **Manager Pattern** - Centralized resource management
211 | 6. **Repository Pattern** - Template and prompt storage
212 |
213 | ### Architecture
214 | - **Separation of Concerns** - Clear module boundaries
215 | - **Dependency Injection** - Config passed to components
216 | - **Composition over Inheritance** - Flexible component design
217 | - **Interface Segregation** - Abstract base classes
218 |
219 | ## 📝 Documentation
220 |
221 | ### Completed Documentation
222 | - ✅ README.md - Comprehensive project overview
223 | - ✅ Module docstrings (PEP 257 compliant)
224 | - ✅ Function/class docstrings with type hints
225 | - ✅ IMPLEMENTATION_STATUS.md (this file)
226 |
227 | ### Documentation Coverage
228 | - All public APIs documented
229 | - Type hints on all functions
230 | - Examples in README
231 | - Configuration examples
232 |
233 | ## 🚀 Suggested Improvements
234 |
235 | ### High Priority
236 | 1. **Increase Test Coverage**
237 | - Target: 80%+ coverage
238 | - Focus on manager classes (currently 23-32%)
239 | - Add integration tests for end-to-end workflows
240 |
241 | 2. **Error Handling Enhancement**
242 | - More specific exception types
243 | - Better error messages with context
244 | - Validation error aggregation
245 |
246 | 3. **Performance Optimization**
247 | - Cache frequently used templates
248 | - Lazy loading for resources
249 | - Async operations where applicable
250 |
251 | ### Medium Priority
252 | 4. **CLI Enhancement**
253 | - Rich terminal output
254 | - Interactive prompts
255 | - Progress indicators
256 |
257 | 5. **Template Improvements**
258 | - More built-in templates
259 | - Template inheritance
260 | - Template composition
261 |
262 | 6. **Documentation**
263 | - API reference generation (Sphinx)
264 | - Tutorial documentation
265 | - Architecture diagrams
266 |
267 | ### Low Priority
268 | 7. **AWS Integration**
269 | - Complete AWS tool implementations
270 | - AWS credential management
271 | - Region selection
272 |
273 | 8. **Monitoring & Observability**
274 | - Structured logging
275 | - Metrics collection
276 | - Health checks
277 |
278 | 9. **Security**
279 | - Input validation
280 | - Sanitization
281 | - Security scanning in CI/CD
282 |
283 | ## 🔄 Refactoring Opportunities
284 |
285 | ### Code Quality
286 | 1. **Consolidate Duplicate Logic**
287 | - Template/Prompt managers have similar patterns
288 | - Consider abstract Manager base class
289 |
290 | 2. **Simplify Configuration**
291 | - MCPConfig vs Config naming confusion
292 | - Consolidate to single Config class
293 |
294 | 3. **Improve Type Hints**
295 | - Use generic types where applicable
296 | - Protocol types for duck typing
297 |
298 | ### Architecture
299 | 4. **Plugin System**
300 | - Allow custom template providers
301 | - Allow custom diagram renderers
302 | - Extensible tool registration
303 |
304 | 5. **Event System**
305 | - Template applied events
306 | - Project created events
307 | - Diagram generated events
308 |
309 | 6. **Validation Framework**
310 | - Centralized validation logic
311 | - Validation rule composition
312 | - Better error reporting
313 |
314 | ## 🎉 Success Criteria Met
315 |
316 | - ✅ All core modules implemented
317 | - ✅ All tests passing (16/16)
318 | - ✅ CI/CD pipeline functional
319 | - ✅ Package structure follows best practices
320 | - ✅ Documentation meets PEP 257 standards
321 | - ✅ Type hints comprehensive
322 | - ✅ Conan package buildable
323 | - ✅ Container image buildable
324 |
325 | ## 📊 Metrics
326 |
327 | ### Code Quality Metrics
328 | - Lines of Code: ~2,348 statements
329 | - Test Coverage: 27% (baseline)
330 | - Cyclomatic Complexity: Low (well-structured)
331 | - Maintainability Index: Good (clear modules)
332 |
333 | ### Repository Health
334 | - All workflows passing: ✅
335 | - Dependencies up to date: ✅
336 | - Security vulnerabilities: None known
337 | - Technical debt: Manageable
338 |
339 | ## 🔗 Related Documentation
340 |
341 | - [README.md](README.md) - Main project documentation
342 | - [AWS_MCP.md](docs/AWS_MCP.md) - AWS integration guide
343 | - [CONAN.md](docs/CONAN.md) - Conan package usage
344 | - [integration.md](docs/integration.md) - Integration patterns
345 |
346 | ## 📅 Next Steps
347 |
348 | 1. **Immediate** (Next Sprint)
349 | - Increase test coverage to 50%
350 | - Add integration tests
351 | - Improve error messages
352 |
353 | 2. **Short-term** (1-2 months)
354 | - Complete AWS integration
355 | - Add CLI interactive mode
356 | - Generate API documentation
357 |
358 | 3. **Long-term** (3-6 months)
359 | - Plugin system implementation
360 | - Performance optimization
361 | - Advanced template features
362 |
363 | ---
364 |
365 | **Last Updated**: 2025-10-01
366 | **Maintained By**: MCP Project Orchestrator Team
367 |
```
--------------------------------------------------------------------------------
/AWS_MCP_IMPLEMENTATION_SUMMARY.md:
--------------------------------------------------------------------------------
```markdown
1 | # AWS MCP Implementation Summary
2 |
3 | ## Overview
4 |
5 | This document summarizes the AWS Model Context Protocol (MCP) capabilities that have been added to the MCP Project Orchestrator, based on the AWS MCP features discussed in the referenced Perplexity search.
6 |
7 | ## Implementation Date
8 | September 30, 2025
9 |
10 | ## What Was Added
11 |
12 | ### 1. Core AWS MCP Module (`src/mcp_project_orchestrator/aws_mcp.py`)
13 |
14 | A comprehensive AWS integration module that provides:
15 |
16 | #### AWS Configuration (`AWSConfig` class)
17 | - Environment variable-based configuration
18 | - Support for multiple authentication methods:
19 | - Access key ID + Secret access key
20 | - AWS CLI profiles
21 | - IAM roles (for EC2/ECS/Lambda)
22 | - Temporary credentials (STS)
23 | - Configuration validation
24 | - Boto3 client configuration generation
25 |
26 | #### AWS MCP Integration (`AWSMCPIntegration` class)
27 | Provides programmatic access to AWS services:
28 |
29 | **S3 Operations:**
30 | - List buckets
31 | - List objects in buckets
32 | - Upload files to S3
33 |
34 | **EC2 Operations:**
35 | - List instances
36 | - Get instance status
37 |
38 | **Lambda Operations:**
39 | - List functions
40 | - Invoke functions
41 |
42 | **CloudFormation Operations:**
43 | - List stacks
44 |
45 | **IAM Operations:**
46 | - List users
47 | - List roles
48 |
49 | **Best Practices:**
50 | - Service-specific best practices (S3, EC2, Lambda)
51 | - Security recommendations
52 | - Cost optimization guidelines
53 | - Performance optimization tips
54 |
55 | **Cost Estimation:**
56 | - S3 cost estimation
57 | - EC2 cost estimation
58 | - Lambda cost estimation
59 | - Service-specific breakdowns
60 |
61 | ### 2. MCP Tool Registration
62 |
63 | The `register_aws_mcp_tools()` function registers AWS capabilities as MCP tools:
64 |
65 | - `aws_list_s3_buckets` - List all S3 buckets
66 | - `aws_list_ec2_instances` - List EC2 instances
67 | - `aws_list_lambda_functions` - List Lambda functions
68 | - `aws_best_practices` - Get service-specific best practices
69 | - `aws_estimate_costs` - Estimate AWS costs based on usage
70 |
71 | ### 3. Environment Configuration (`.env.example`)
72 |
73 | Template for AWS environment variables:
74 | - `AWS_REGION` - AWS region
75 | - `AWS_ACCESS_KEY_ID` - Access key (optional)
76 | - `AWS_SECRET_ACCESS_KEY` - Secret key (optional)
77 | - `AWS_SESSION_TOKEN` - Session token for temporary credentials
78 | - `AWS_PROFILE` - AWS CLI profile name
79 | - `AWS_ENDPOINT_URL` - Custom endpoint (for LocalStack testing)
80 | - Feature flags for best practices, cost optimization, and security
81 |
82 | ### 4. Dependencies (`pyproject.toml`, `requirements.txt`)
83 |
84 | Added boto3 and botocore as dependencies:
85 | - Core dependencies include boto3 by default
86 | - Optional `[aws]` extra for explicit AWS support
87 | - Compatible with Python 3.9+
88 |
89 | ### 5. Project Integration
90 |
91 | #### Updated `project_orchestration.py`
92 | - Imports AWS MCP module
93 | - Conditionally registers AWS tools when AWS_REGION is set
94 | - Graceful fallback if boto3 is not installed
95 |
96 | #### Updated `fastmcp.py`
97 | - Added dotenv support for loading environment variables
98 | - AWS configuration loaded automatically from .env
99 |
100 | ### 6. Configuration (`config/project_orchestration.json`)
101 |
102 | Added AWS-specific configuration:
103 | ```json
104 | {
105 | "enable": {
106 | "awsMcp": true
107 | },
108 | "aws": {
109 | "enabled": true,
110 | "services": ["s3", "ec2", "lambda", "cloudformation", "iam"],
111 | "bestPractices": {
112 | "enabled": true,
113 | "enforcement": true
114 | },
115 | "costOptimization": {
116 | "enabled": true,
117 | "alertThreshold": 100
118 | },
119 | "security": {
120 | "scanningEnabled": false,
121 | "enforceEncryption": true
122 | }
123 | }
124 | }
125 | ```
126 |
127 | ### 7. Documentation
128 |
129 | #### `docs/AWS_MCP.md` (Comprehensive Guide)
130 | - Overview of AWS MCP capabilities
131 | - Environment variable configuration
132 | - Setup instructions (3 methods)
133 | - Usage examples for each MCP tool
134 | - Python API documentation
135 | - AWS best practices details
136 | - Cost estimation examples
137 | - Security considerations
138 | - Troubleshooting guide
139 | - Advanced usage (LocalStack, multi-region, cross-account)
140 | - Contributing guidelines
141 |
142 | #### `docs/AWS.md` (Updated)
143 | - Added AWS MCP integration section
144 | - Quick start guide
145 | - Links to detailed documentation
146 |
147 | #### `README.md` (Updated)
148 | - Added AWS MCP Integration feature section
149 | - Updated installation instructions
150 | - Added AWS-specific installation option
151 |
152 | ### 8. Testing (`tests/test_aws_mcp.py`)
153 |
154 | Comprehensive test suite:
155 | - Configuration validation tests
156 | - Boto3 configuration conversion tests
157 | - Best practices retrieval tests
158 | - Cost estimation tests
159 | - Mocked AWS service operations tests
160 | - S3, EC2, Lambda operation tests
161 |
162 | ### 9. Setup Script (`scripts/setup_aws_mcp.sh`)
163 |
164 | Automated setup script that:
165 | - Checks boto3 installation
166 | - Creates .env file from template
167 | - Validates AWS CLI configuration
168 | - Tests AWS MCP integration
169 | - Provides next steps and documentation links
170 |
171 | ### 10. Package Exports (`src/mcp_project_orchestrator/__init__.py`)
172 |
173 | - Exports AWS classes and functions
174 | - Graceful fallback if boto3 not installed
175 | - Clean API for consumers
176 |
177 | ## AWS MCP Capabilities
178 |
179 | ### Based on AWS Labs MCP Implementation
180 |
181 | The implementation aligns with AWS's official MCP servers approach:
182 |
183 | 1. **AWS Best Practices Enforcement**
184 | - Automatic suggestions for secure configurations
185 | - Well-Architected Framework principles
186 | - Service-specific recommendations
187 |
188 | 2. **Contextual Guidance**
189 | - Real-time AWS documentation access
190 | - Up-to-date service capabilities
191 | - Best practice patterns
192 |
193 | 3. **Cost Optimization**
194 | - Proactive cost estimation
195 | - Usage-based calculations
196 | - Service-specific breakdowns
197 |
198 | 4. **Security & Compliance**
199 | - IAM best practices
200 | - Encryption recommendations
201 | - Audit logging guidance
202 |
203 | ## Environment Variables
204 |
205 | ### Required
206 | - `AWS_REGION` - AWS region (e.g., us-east-1)
207 |
208 | ### Optional (Choose one authentication method)
209 | - Method A: Access Keys
210 | - `AWS_ACCESS_KEY_ID`
211 | - `AWS_SECRET_ACCESS_KEY`
212 | - Method B: AWS Profile
213 | - `AWS_PROFILE`
214 | - Method C: IAM Role (no variables needed, uses instance/container role)
215 |
216 | ### Optional Configuration
217 | - `AWS_SESSION_TOKEN` - For temporary credentials
218 | - `AWS_ENDPOINT_URL` - For LocalStack or custom endpoints
219 | - `AWS_ENFORCE_BEST_PRACTICES` - Enable/disable best practices
220 | - `AWS_COST_OPTIMIZATION` - Enable/disable cost optimization
221 | - `AWS_SECURITY_SCANNING` - Enable/disable security scanning
222 |
223 | ## Installation
224 |
225 | ### Basic Installation
226 | ```bash
227 | pip install -e .
228 | ```
229 |
230 | ### With AWS Support
231 | ```bash
232 | pip install -e ".[aws]"
233 | ```
234 |
235 | ### Quick Setup
236 | ```bash
237 | ./scripts/setup_aws_mcp.sh
238 | ```
239 |
240 | ## Usage Examples
241 |
242 | ### List S3 Buckets
243 | ```python
244 | from mcp_project_orchestrator import AWSMCPIntegration, AWSConfig
245 |
246 | aws = AWSMCPIntegration(AWSConfig(region='us-east-1'))
247 | buckets = aws.list_s3_buckets()
248 | for bucket in buckets:
249 | print(bucket['Name'])
250 | ```
251 |
252 | ### Get Best Practices
253 | ```python
254 | practices = aws.get_aws_best_practices('s3')
255 | print(practices['security']) # Security best practices
256 | print(practices['cost']) # Cost optimization tips
257 | print(practices['performance']) # Performance recommendations
258 | ```
259 |
260 | ### Estimate Costs
261 | ```python
262 | costs = aws.estimate_costs('s3', {
263 | 'storage_gb': 100,
264 | 'requests': 10000,
265 | 'data_transfer_gb': 50
266 | })
267 | print(f"Estimated cost: ${costs['total_usd']} USD")
268 | ```
269 |
270 | ## MCP Tools
271 |
272 | When the MCP server is running, AI assistants can use these tools:
273 |
274 | 1. **aws_list_s3_buckets** - List all S3 buckets
275 | 2. **aws_list_ec2_instances** - List EC2 instances in region
276 | 3. **aws_list_lambda_functions** - List Lambda functions
277 | 4. **aws_best_practices** - Get service-specific best practices
278 | 5. **aws_estimate_costs** - Estimate AWS costs
279 |
280 | ## Security Considerations
281 |
282 | 1. **Never commit credentials to version control**
283 | 2. **Use .env files** (added to .gitignore)
284 | 3. **Prefer IAM roles** over access keys
285 | 4. **Use temporary credentials** when possible
286 | 5. **Rotate credentials regularly**
287 | 6. **Apply least privilege** IAM policies
288 |
289 | ## Testing
290 |
291 | Run the test suite:
292 | ```bash
293 | pytest tests/test_aws_mcp.py -v
294 | ```
295 |
296 | ## Files Created/Modified
297 |
298 | ### New Files
299 | - `src/mcp_project_orchestrator/aws_mcp.py` - Core AWS MCP module
300 | - `docs/AWS_MCP.md` - Comprehensive AWS MCP documentation
301 | - `tests/test_aws_mcp.py` - Test suite
302 | - `.env.example` - Environment variable template
303 | - `requirements.txt` - Python dependencies
304 | - `scripts/setup_aws_mcp.sh` - Setup automation script
305 | - `AWS_MCP_IMPLEMENTATION_SUMMARY.md` - This file
306 |
307 | ### Modified Files
308 | - `src/mcp_project_orchestrator/__init__.py` - Added AWS exports
309 | - `src/mcp_project_orchestrator/project_orchestration.py` - Integrated AWS tools
310 | - `src/mcp_project_orchestrator/fastmcp.py` - Added dotenv support
311 | - `config/project_orchestration.json` - Added AWS configuration
312 | - `docs/AWS.md` - Added AWS MCP section
313 | - `README.md` - Added AWS features and installation
314 | - `pyproject.toml` - Added boto3 dependencies
315 |
316 | ## Alignment with AWS MCP Standards
317 |
318 | This implementation follows the AWS MCP approach described in:
319 | - AWS Labs MCP servers (https://awslabs.github.io/mcp/)
320 | - Model Context Protocol specification
321 | - AWS Well-Architected Framework
322 | - AWS best practices documentation
323 |
324 | ## Future Enhancements
325 |
326 | Potential additions for future versions:
327 | 1. Additional AWS services (DynamoDB, RDS, SNS, SQS)
328 | 2. AWS CloudWatch metrics integration
329 | 3. AWS Cost Explorer API integration
330 | 4. AWS Config compliance checking
331 | 5. AWS Security Hub integration
332 | 6. Bedrock and SageMaker AI services
333 | 7. AWS CDK construct generation
334 | 8. Infrastructure as Code templates
335 | 9. Multi-account management
336 | 10. AWS Organizations support
337 |
338 | ## Contributing
339 |
340 | To add new AWS service integrations:
341 | 1. Add methods to `AWSMCPIntegration` class
342 | 2. Add corresponding MCP tools in `register_aws_mcp_tools()`
343 | 3. Add best practices to `get_aws_best_practices()`
344 | 4. Update documentation
345 | 5. Add tests
346 |
347 | ## References
348 |
349 | - [AWS MCP Documentation](https://awslabs.github.io/mcp/)
350 | - [Model Context Protocol](https://modelcontextprotocol.io/)
351 | - [AWS Well-Architected Framework](https://aws.amazon.com/architecture/well-architected/)
352 | - [Boto3 Documentation](https://boto3.amazonaws.com/v1/documentation/api/latest/index.html)
353 | - [Perplexity Search Reference](https://www.perplexity.ai/search/give-me-aws-environment-variab-lQbAxNL_TyumJdNLUhYrKQ#2)
354 |
355 | ## License
356 |
357 | This implementation is part of the MCP Project Orchestrator and is licensed under the MIT License.
358 |
359 | ## Support
360 |
361 | For issues, questions, or contributions:
362 | - See `docs/AWS_MCP.md` for detailed documentation
363 | - Run `./scripts/setup_aws_mcp.sh` for automated setup
364 | - Check `tests/test_aws_mcp.py` for usage examples
```