This is page 8 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
--------------------------------------------------------------------------------
/tests/integration/test_core_integration.py:
--------------------------------------------------------------------------------
```python
1 | """
2 | Integration tests for the core module functionality.
3 |
4 | These tests verify that the core components work together properly.
5 | """
6 |
7 | import os
8 | import pytest
9 | import tempfile
10 | from pathlib import Path
11 | import json
12 |
13 | from mcp_project_orchestrator.core import FastMCPServer, MCPConfig
14 | from mcp_project_orchestrator.core import setup_logging, MCPException
15 |
16 |
17 | class TestCoreIntegration:
18 | """Integration tests for core module components."""
19 |
20 | @pytest.fixture
21 | def temp_config_dir(self):
22 | """Create a temporary config directory."""
23 | with tempfile.TemporaryDirectory() as temp_dir:
24 | yield Path(temp_dir)
25 |
26 | @pytest.fixture
27 | def config(self, temp_config_dir):
28 | """Create a test configuration."""
29 | config_data = {
30 | "name": "test-mcp-server",
31 | "version": "0.1.0",
32 | "description": "Test MCP Server",
33 | "server": {
34 | "host": "127.0.0.1",
35 | "port": 8080
36 | },
37 | "paths": {
38 | "prompts": str(temp_config_dir / "prompts"),
39 | "templates": str(temp_config_dir / "templates"),
40 | "mermaid": str(temp_config_dir / "mermaid"),
41 | "resources": str(temp_config_dir / "resources")
42 | }
43 | }
44 |
45 | config_file = temp_config_dir / "config.json"
46 | with open(config_file, "w") as f:
47 | json.dump(config_data, f)
48 |
49 | # Create required directories
50 | for dir_name in ["prompts", "templates", "mermaid", "resources"]:
51 | (temp_config_dir / dir_name).mkdir(exist_ok=True)
52 |
53 | return MCPConfig(config_file=config_file)
54 |
55 | def test_config_loading(self, config):
56 | """Test that configuration is loaded properly."""
57 | assert config.name == "test-mcp-server"
58 | assert config.version == "0.1.0"
59 | assert config.description == "Test MCP Server"
60 | assert config.server_host == "127.0.0.1"
61 | assert config.server_port == 8080
62 |
63 | def test_server_initialization(self, config):
64 | """Test that the server initializes properly."""
65 | server = FastMCPServer(config=config)
66 | assert server.name == config.name
67 | assert server.config == config
68 |
69 | def test_tool_registration(self, config):
70 | """Test that tools can be registered."""
71 | server = FastMCPServer(config=config)
72 |
73 | tool_name = "test-tool"
74 | tool_description = "A test tool"
75 | tool_params = {
76 | "type": "object",
77 | "properties": {
78 | "param1": {"type": "string"},
79 | "param2": {"type": "number"}
80 | },
81 | "required": ["param1"]
82 | }
83 |
84 | # Define a simple tool function
85 | def tool_function(params):
86 | return {"result": f"Hello, {params['param1']}!"}
87 |
88 | # Register the tool
89 | server.register_tool(
90 | name=tool_name,
91 | description=tool_description,
92 | parameters=tool_params,
93 | handler=tool_function
94 | )
95 |
96 | # Check if the tool was registered
97 | assert tool_name in server.tools
98 | assert server.tools[tool_name]["description"] == tool_description
99 | assert server.tools[tool_name]["parameters"] == tool_params
100 | assert server.tools[tool_name]["handler"] == tool_function
101 |
102 | def test_resource_registration(self, config):
103 | """Test that resources can be registered."""
104 | server = FastMCPServer(config=config)
105 |
106 | resource_name = "test-resource"
107 | resource_content = {"key": "value"}
108 |
109 | # Register the resource
110 | server.register_resource(
111 | name=resource_name,
112 | content=resource_content
113 | )
114 |
115 | # Check if the resource was registered
116 | assert resource_name in server.resources
117 | assert server.resources[resource_name] == resource_content
118 |
119 | def test_exception_handling(self):
120 | """Test that exceptions are handled properly."""
121 | with pytest.raises(MCPException) as excinfo:
122 | raise MCPException("Test exception")
123 | assert "Test exception" in str(excinfo.value)
124 |
125 | def test_logging_setup(self, temp_config_dir):
126 | """Test that logging is set up properly."""
127 | log_file = temp_config_dir / "test.log"
128 | logger = setup_logging(log_file=log_file)
129 |
130 | # Log a test message
131 | test_message = "Test log message"
132 | logger.info(test_message)
133 |
134 | # Check if the message was logged
135 | with open(log_file, "r") as f:
136 | log_content = f.read()
137 | assert test_message in log_content
```
--------------------------------------------------------------------------------
/component_templates.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "component_templates": [
3 | {
4 | "name": "Factory",
5 | "description": "Creates objects using the Factory Method.",
6 | "mermaid": "Generate a Mermaid diagram visualizing FactoryMethod Design Pattern, showing the factory, product, and client interactions."
7 | },
8 | {
9 | "name": "AbstractFactory",
10 | "description": "Creates related objects without specifying concrete classes.",
11 | "mermaid": "Generate a Mermaid diagram visualizing AbstractFactory Design Pattern, illustrating families of related objects and their creation process."
12 | },
13 | {
14 | "name": "Builder",
15 | "description": "Constructs objects using a step-by-step approach.",
16 | "mermaid": "Generate a Mermaid diagram visualizing Builder Design Pattern, that shows the step-by-step construction process of complex objects."
17 | },
18 | {
19 | "name": "Prototype",
20 | "description": "Clones existing objects as prototypes.",
21 | "mermaid": "Generate a Mermaid diagram visualizing Prototype Design Pattern, displaying object cloning and prototype relationships."
22 | },
23 | {
24 | "name": "Singleton",
25 | "description": "Manages a single instance across the application.",
26 | "mermaid": "Generate a Mermaid diagram visualizing Singleton Design Pattern, illustrating the single instance and global access point."
27 | },
28 | {
29 | "name": "Adapter",
30 | "description": "Adapts one interface to another.",
31 | "mermaid": "Generate a Mermaid diagram visualizing Adapter Design Pattern, showing how incompatible interfaces are adapted to work together."
32 | },
33 | {
34 | "name": "Decorator",
35 | "description": "Wraps objects to extend functionality.",
36 | "mermaid": "Generate a Mermaid diagram visualizing Decorator Design Pattern, that shows dynamic addition of behaviors to objects."
37 | },
38 | {
39 | "name": "Facade",
40 | "description": "Simplifies interactions with a subsystem.",
41 | "mermaid": "Generate a Mermaid diagram visualizing Facade Design Pattern, showing a simplified interface versus a complex subsystem."
42 | },
43 | {
44 | "name": "Proxy",
45 | "description": "Intermediates access to a real object.",
46 | "mermaid": "Generate a Mermaid diagram visualizing Proxy Design Pattern, demonstrating the surrogate control pattern."
47 | },
48 | {
49 | "name": "Chain",
50 | "description": "Processes a request through a chain of handlers.",
51 | "mermaid": "Generate a Mermaid diagram visualizing ChainOfResponsibility Design Pattern, showing the flow of requests through handlers."
52 | },
53 | {
54 | "name": "Command",
55 | "description": "Encapsulates requests as objects.",
56 | "mermaid": "Generate a Mermaid diagram visualizing Command Design Pattern, outlining encapsulated request objects and their invokers."
57 | },
58 | {
59 | "name": "Iterator",
60 | "description": "Enables sequential access to collection elements.",
61 | "mermaid": "Generate a Mermaid diagram visualizing Iterator Design Pattern, showing sequential access to a collection."
62 | },
63 | {
64 | "name": "Mediator",
65 | "description": "Manages communication between objects.",
66 | "mermaid": "Generate a Mermaid diagram visualizing Mediator Design Pattern, showing how components communicate via a mediator."
67 | },
68 | {
69 | "name": "Memento",
70 | "description": "Stores and restores object state.",
71 | "mermaid": "Generate a Mermaid diagram visualizing Memento Design Pattern, illustrating state capture and restoration processes."
72 | },
73 | {
74 | "name": "Observer",
75 | "description": "Notifies subscribers of state changes.",
76 | "mermaid": "Generate a Mermaid diagram visualizing Observer Design Pattern, showing one-to-many dependencies between subjects and observers."
77 | },
78 | {
79 | "name": "State",
80 | "description": "Manages state-dependent behavior.",
81 | "mermaid": "Generate a Mermaid diagram visualizing State Design Pattern, outlining state transitions and behavior changes."
82 | },
83 | {
84 | "name": "Strategy",
85 | "description": "Encapsulates interchangeable algorithms.",
86 | "mermaid": "Generate a Mermaid diagram visualizing Strategy Design Pattern, showing interchangeable algorithms and their selection criteria."
87 | },
88 | {
89 | "name": "TemplateMethod",
90 | "description": "Defines a skeletal algorithm with overrideable steps.",
91 | "mermaid": "Generate a Mermaid diagram visualizing TemplateMethod Design Pattern, illustrating the skeletal algorithm with customizable steps."
92 | },
93 | {
94 | "name": "Visitor",
95 | "description": "Separates operations from object structure.",
96 | "mermaid": "Generate a Mermaid diagram visualizing Visitor Design Pattern, showing the separation of operations from object structure."
97 | }
98 | ]
99 | }
```
--------------------------------------------------------------------------------
/project_orchestration.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "communication_protocol": "JSON-RPC",
3 | "mcp_compliance": true,
4 | "system_prompt": "You are an AI assistant specializing in guiding users through software project implementation using systematic approaches and design patterns. Your goal is to orchestrate the development project from an idea that is provided by user. Execute following steps:\n1. Extract key information from the user's query and decide on relevant context - files, MCP tools or prompts - to link each next step with.\n2. Determine which known design patterns and SW architecture abstraction concepts cover the logic behind the user's idea.\n3. Select one of the project templates from the catalogue and apply it by creating a new directory in my common SW projects directory and copying in the contents of the selected template's data folder. In the copied template's files, make sure to correctly substitute variable placeholders with their actual values, combining user idea with context of design patterns best practices and other results of the conducted research.\n4. Create Project Documentation - Describe SW Architecture, Components and Modules, their relationships, interfaces, communication protocols, technologies used, dependencies, installation, build, run and test commands. Use simplified mermaid tools to visualize the various parts of the documentation.\n5. Prepare File Structure and visualize directory tree of the project. For each source code file, assign a suitable file name and location within the project. Filenames must be consistent, clear, descriptive, and unambiguous with assumed file contents. Maintain consistency with existing naming patterns if present. Follow standard naming conventions for the type of item being named and ensure names are unique within their context.\n6. Decide in which order files should be implemented, how features should be tested, and how components should be built and deployed. Update project README with final aggregated notes on project orchestration and instructions for the composer implementor agent.",
5 | "goals": [
6 | "Analyze user input to identify suitable design patterns and project templates.",
7 | "Initialize and define the tools required for project setup.",
8 | "Prepare an implementation plan that includes design patterns, file structures, and testing strategies.",
9 | "Provide clear instructions for tool usage during the project lifecycle."
10 | ],
11 | "tools": [
12 | {
13 | "name": "MermaidTool",
14 | "description": "A unified tool to generate Mermaid diagrams for visualizing software architecture, design patterns, and process flows.",
15 | "input_schema": {
16 | "type": "object",
17 | "properties": {
18 | "diagram_planning": {
19 | "type": "string",
20 | "description": "Planned strategy for the diagram implementation."
21 | }
22 | },
23 | "required": ["diagram_planning"]
24 | }
25 | }
26 | ],
27 | "steps": [
28 | {
29 | "phase": "Information Extraction",
30 | "description": "Extract key information from the user's query and decide on relevant context - files, MCP tools or prompts - to link each next step with."
31 | },
32 | {
33 | "phase": "Design Patterns & Architecture Identification",
34 | "description": "Determine which known design patterns and software architecture abstraction concepts align with the user's idea, considering system modularity and orchestrated design."
35 | },
36 | {
37 | "phase": "Project Template Application",
38 | "description": "Select one of the project templates from the catalogue and apply it by creating a new directory in the common SW projects directory, copying in the contents of the selected template's data folder, and substituting variable placeholders appropriately."
39 | },
40 | {
41 | "phase": "Project Documentation & Visual Design",
42 | "description": "Create comprehensive project documentation that outlines the software architecture, components, and modules, and includes visual representations using MermaidTool."
43 | },
44 | {
45 | "phase": "File Structure Preparation",
46 | "description": "Prepare the file structure and visualize the directory tree of the project. Assign clear, descriptive, and consistent file names and locations with temporary TODO comments for future implementation."
47 | },
48 | {
49 | "phase": "Implementation Strategy",
50 | "description": "Decide on the implementation order for files, define testing strategies for implemented features, and update the project README with final orchestration notes and instructions for the composer implementor agent."
51 | }
52 | ]
53 | }
54 |
55 |
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/templates/renderer.py:
--------------------------------------------------------------------------------
```python
1 | """Template renderer for MCP Project Orchestrator.
2 |
3 | This module provides the TemplateRenderer class that handles template rendering
4 | using Jinja2, with support for custom filters and extensions.
5 | """
6 |
7 | from pathlib import Path
8 | from typing import Dict, Any, Optional, Union
9 | import re
10 |
11 | from jinja2 import Environment, FileSystemLoader, Template, select_autoescape
12 |
13 | from ..core.exceptions import TemplateError
14 |
15 |
16 | class TemplateRenderer:
17 | """Template renderer implementation."""
18 |
19 | def __init__(self, template_dir: Optional[Union[str, Path]] = None):
20 | """Initialize template renderer.
21 |
22 | Args:
23 | template_dir: Optional directory containing template files
24 | """
25 | self.template_dir = Path(template_dir) if template_dir else None
26 | self.env = Environment(
27 | loader=FileSystemLoader(str(template_dir)) if template_dir else None,
28 | autoescape=select_autoescape(['html', 'xml']),
29 | trim_blocks=True,
30 | lstrip_blocks=True,
31 | keep_trailing_newline=True,
32 | )
33 | self._setup_filters()
34 | self._setup_extensions()
35 |
36 | def _setup_filters(self) -> None:
37 | """Set up custom Jinja2 filters."""
38 | self.env.filters.update({
39 | 'camelcase': self._to_camel_case,
40 | 'snakecase': self._to_snake_case,
41 | 'kebabcase': self._to_kebab_case,
42 | 'pascalcase': self._to_pascal_case,
43 | 'quote': lambda s: f'"{s}"',
44 | 'indent': self._indent_text,
45 | })
46 |
47 | def _setup_extensions(self) -> None:
48 | """Set up Jinja2 extensions."""
49 | self.env.add_extension('jinja2.ext.do')
50 | self.env.add_extension('jinja2.ext.loopcontrols')
51 |
52 | def render_string(self, template_str: str, context: Dict[str, Any]) -> str:
53 | """Render a template string with context.
54 |
55 | Args:
56 | template_str: Template string to render
57 | context: Template variables
58 |
59 | Returns:
60 | str: Rendered content
61 |
62 | Raises:
63 | TemplateError: If rendering fails
64 | """
65 | try:
66 | template = Template(template_str, environment=self.env)
67 | return template.render(**context)
68 | except Exception as e:
69 | raise TemplateError(f"Failed to render template string: {str(e)}")
70 |
71 | def render_file(self, template_path: Union[str, Path], context: Dict[str, Any]) -> str:
72 | """Render a template file with context.
73 |
74 | Args:
75 | template_path: Path to template file
76 | context: Template variables
77 |
78 | Returns:
79 | str: Rendered content
80 |
81 | Raises:
82 | TemplateError: If rendering fails
83 | """
84 | if not self.template_dir:
85 | raise TemplateError("Template directory not set")
86 |
87 | try:
88 | template = self.env.get_template(str(template_path))
89 | return template.render(**context)
90 | except Exception as e:
91 | raise TemplateError(
92 | f"Failed to render template file {template_path}: {str(e)}"
93 | )
94 |
95 | @staticmethod
96 | def _to_camel_case(s: str) -> str:
97 | """Convert string to camelCase.
98 |
99 | Args:
100 | s: Input string
101 |
102 | Returns:
103 | str: Converted string
104 | """
105 | s = re.sub(r"[^a-zA-Z0-9]+", " ", s).title().replace(" ", "")
106 | return s[0].lower() + s[1:]
107 |
108 | @staticmethod
109 | def _to_snake_case(s: str) -> str:
110 | """Convert string to snake_case.
111 |
112 | Args:
113 | s: Input string
114 |
115 | Returns:
116 | str: Converted string
117 | """
118 | s = re.sub(r"[^a-zA-Z0-9]+", " ", s)
119 | return "_".join(s.lower().split())
120 |
121 | @staticmethod
122 | def _to_kebab_case(s: str) -> str:
123 | """Convert string to kebab-case.
124 |
125 | Args:
126 | s: Input string
127 |
128 | Returns:
129 | str: Converted string
130 | """
131 | s = re.sub(r"[^a-zA-Z0-9]+", " ", s)
132 | return "-".join(s.lower().split())
133 |
134 | @staticmethod
135 | def _to_pascal_case(s: str) -> str:
136 | """Convert string to PascalCase.
137 |
138 | Args:
139 | s: Input string
140 |
141 | Returns:
142 | str: Converted string
143 | """
144 | s = re.sub(r"[^a-zA-Z0-9]+", " ", s).title().replace(" ", "")
145 | return s
146 |
147 | @staticmethod
148 | def _indent_text(text: str, width: int = 4, first: bool = False) -> str:
149 | """Indent text by specified width.
150 |
151 | Args:
152 | text: Text to indent
153 | width: Number of spaces for indentation
154 | first: Whether to indent first line
155 |
156 | Returns:
157 | str: Indented text
158 | """
159 | prefix = " " * width
160 | lines = text.splitlines()
161 | if not lines:
162 | return ""
163 | if first:
164 | return "\n".join(prefix + line for line in lines)
165 | return "\n".join(
166 | prefix + line if line else line
167 | for line in lines
168 | )
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompt_manager/loader.py:
--------------------------------------------------------------------------------
```python
1 | """
2 | Prompt loader for MCP Project Orchestrator.
3 |
4 | This module provides functionality for loading prompt templates
5 | from various sources (files, directories, remote repositories).
6 | """
7 |
8 | import asyncio
9 | from pathlib import Path
10 | from typing import Dict, List, Optional, Set
11 | import json
12 | import aiohttp
13 | import logging
14 |
15 | from ..core import BaseOrchestrator, Config
16 | from .template import PromptTemplate
17 |
18 | class PromptLoader(BaseOrchestrator):
19 | """Class for loading prompt templates from various sources."""
20 |
21 | def __init__(self, config: Config):
22 | """Initialize the prompt loader.
23 |
24 | Args:
25 | config: Configuration instance
26 | """
27 | super().__init__(config)
28 | self.templates: Dict[str, PromptTemplate] = {}
29 | self.categories: Set[str] = set()
30 | self.tags: Set[str] = set()
31 |
32 | async def initialize(self) -> None:
33 | """Initialize the prompt loader.
34 |
35 | Loads templates from the configured templates directory.
36 | """
37 | await self.load_templates_from_directory(
38 | self.config.prompt_templates_dir
39 | )
40 |
41 | async def cleanup(self) -> None:
42 | """Clean up resources."""
43 | self.templates.clear()
44 | self.categories.clear()
45 | self.tags.clear()
46 |
47 | async def load_templates_from_directory(
48 | self, directory: Path
49 | ) -> None:
50 | """Load all template files from a directory.
51 |
52 | Args:
53 | directory: Directory containing template files
54 |
55 | Raises:
56 | FileNotFoundError: If the directory doesn't exist
57 | """
58 | if not directory.exists():
59 | raise FileNotFoundError(f"Templates directory not found: {directory}")
60 |
61 | for file_path in directory.glob("*.json"):
62 | try:
63 | template = PromptTemplate.from_file(file_path)
64 | template.validate()
65 | self.templates[template.name] = template
66 |
67 | if template.category:
68 | self.categories.add(template.category)
69 | self.tags.update(template.tags)
70 |
71 | except (json.JSONDecodeError, ValueError) as e:
72 | self.log_error(f"Error loading template {file_path}", e)
73 |
74 | async def load_template_from_url(self, url: str) -> Optional[PromptTemplate]:
75 | """Load a template from a URL.
76 |
77 | Args:
78 | url: URL of the template JSON file
79 |
80 | Returns:
81 | Loaded template or None if loading failed
82 | """
83 | try:
84 | async with aiohttp.ClientSession() as session:
85 | async with session.get(url) as response:
86 | if response.status != 200:
87 | self.log_error(
88 | f"Failed to fetch template from {url}: "
89 | f"Status {response.status}"
90 | )
91 | return None
92 |
93 | data = await response.json()
94 | template = PromptTemplate(**data)
95 | template.validate()
96 | return template
97 |
98 | except (aiohttp.ClientError, ValueError) as e:
99 | self.log_error(f"Error loading template from {url}", e)
100 | return None
101 |
102 | def get_template(self, name: str) -> Optional[PromptTemplate]:
103 | """Get a template by name.
104 |
105 | Args:
106 | name: Name of the template
107 |
108 | Returns:
109 | Template instance or None if not found
110 | """
111 | return self.templates.get(name)
112 |
113 | def get_templates_by_category(self, category: str) -> List[PromptTemplate]:
114 | """Get all templates in a category.
115 |
116 | Args:
117 | category: Category to filter by
118 |
119 | Returns:
120 | List of templates in the category
121 | """
122 | return [
123 | template for template in self.templates.values()
124 | if template.category == category
125 | ]
126 |
127 | def get_templates_by_tag(self, tag: str) -> List[PromptTemplate]:
128 | """Get all templates with a specific tag.
129 |
130 | Args:
131 | tag: Tag to filter by
132 |
133 | Returns:
134 | List of templates with the tag
135 | """
136 | return [
137 | template for template in self.templates.values()
138 | if tag in template.tags
139 | ]
140 |
141 | def get_all_categories(self) -> List[str]:
142 | """Get all available categories.
143 |
144 | Returns:
145 | List of category names
146 | """
147 | return sorted(self.categories)
148 |
149 | def get_all_tags(self) -> List[str]:
150 | """Get all available tags.
151 |
152 | Returns:
153 | List of tag names
154 | """
155 | return sorted(self.tags)
```
--------------------------------------------------------------------------------
/mcp-project-orchestrator/openssl/mcp_orchestrator/cursor_config.py:
--------------------------------------------------------------------------------
```python
1 | """
2 | Cursor configuration management utilities.
3 |
4 | This module provides classes and utilities for managing Cursor IDE
5 | configuration files and settings.
6 | """
7 |
8 | import json
9 | from pathlib import Path
10 | from typing import Dict, Any, List, Optional
11 | from dataclasses import dataclass
12 |
13 |
14 | @dataclass
15 | class CursorRule:
16 | """Represents a Cursor rule configuration."""
17 |
18 | title: str
19 | description: str
20 | platform: str
21 | content: str
22 | created: str
23 | user: str
24 |
25 | def to_mdc_content(self) -> str:
26 | """Convert to .mdc file content with YAML frontmatter."""
27 | frontmatter = {
28 | "title": self.title,
29 | "description": self.description,
30 | "platform": self.platform,
31 | "created": self.created,
32 | "user": self.user,
33 | }
34 |
35 | yaml_content = "\n".join([
36 | "---",
37 | *[f"{k}: {v}" for k, v in frontmatter.items()],
38 | "---",
39 | "",
40 | ])
41 |
42 | return yaml_content + self.content
43 |
44 |
45 | @dataclass
46 | class MCPServerConfig:
47 | """Represents an MCP server configuration."""
48 |
49 | name: str
50 | command: str
51 | args: List[str]
52 | env: Dict[str, str]
53 | disabled: bool = False
54 |
55 | def to_dict(self) -> Dict[str, Any]:
56 | """Convert to dictionary for JSON serialization."""
57 | config = {
58 | "command": self.command,
59 | "args": self.args,
60 | "env": self.env,
61 | }
62 |
63 | if self.disabled:
64 | config["disabled"] = True
65 |
66 | return config
67 |
68 |
69 | class CursorConfig:
70 | """Manages Cursor IDE configuration files."""
71 |
72 | def __init__(self, cursor_dir: Path):
73 | self.cursor_dir = Path(cursor_dir)
74 | self.rules_dir = self.cursor_dir / "rules"
75 | self.prompts_dir = self.cursor_dir / "prompts"
76 | self.mcp_config_file = self.cursor_dir / "mcp.json"
77 |
78 | def create_directory_structure(self) -> None:
79 | """Create the standard .cursor directory structure."""
80 | self.cursor_dir.mkdir(exist_ok=True)
81 | self.rules_dir.mkdir(exist_ok=True)
82 | self.prompts_dir.mkdir(exist_ok=True)
83 | (self.rules_dir / "custom").mkdir(exist_ok=True)
84 |
85 | def write_rule(self, rule: CursorRule, filename: str) -> None:
86 | """Write a rule to the rules directory."""
87 | rule_file = self.rules_dir / f"{filename}.mdc"
88 | rule_file.write_text(rule.to_mdc_content())
89 |
90 | def write_prompt(self, title: str, content: str, filename: str) -> None:
91 | """Write a prompt to the prompts directory."""
92 | prompt_file = self.prompts_dir / f"{filename}.md"
93 | prompt_file.write_text(f"# {title}\n\n{content}")
94 |
95 | def write_mcp_config(self, servers: List[MCPServerConfig],
96 | global_shortcut: str = "Ctrl+Shift+.",
97 | logging_level: str = "info") -> None:
98 | """Write MCP server configuration."""
99 | config = {
100 | "mcpServers": {
101 | server.name: server.to_dict()
102 | for server in servers
103 | },
104 | "globalShortcut": global_shortcut,
105 | "logging": {
106 | "level": logging_level
107 | }
108 | }
109 |
110 | self.mcp_config_file.write_text(json.dumps(config, indent=2))
111 |
112 | def create_gitignore(self) -> None:
113 | """Create .gitignore for .cursor directory."""
114 | gitignore_content = """# Cursor IDE local customizations
115 | *.log
116 | *.cache
117 | .cursor-session
118 |
119 | # Keep rule templates and prompts in VCS
120 | !rules/
121 | !prompts/
122 | !mcp.json
123 |
124 | # Ignore developer-specific overrides
125 | rules/custom/
126 | """
127 | gitignore_file = self.cursor_dir / ".gitignore"
128 | gitignore_file.write_text(gitignore_content)
129 |
130 | def get_existing_rules(self) -> List[str]:
131 | """Get list of existing rule files."""
132 | if not self.rules_dir.exists():
133 | return []
134 |
135 | return [f.stem for f in self.rules_dir.glob("*.mdc")]
136 |
137 | def get_existing_prompts(self) -> List[str]:
138 | """Get list of existing prompt files."""
139 | if not self.prompts_dir.exists():
140 | return []
141 |
142 | return [f.stem for f in self.prompts_dir.glob("*.md")]
143 |
144 | def has_mcp_config(self) -> bool:
145 | """Check if MCP configuration exists."""
146 | return self.mcp_config_file.exists()
147 |
148 | def read_mcp_config(self) -> Optional[Dict[str, Any]]:
149 | """Read existing MCP configuration."""
150 | if not self.has_mcp_config():
151 | return None
152 |
153 | try:
154 | return json.loads(self.mcp_config_file.read_text())
155 | except (json.JSONDecodeError, FileNotFoundError):
156 | return None
157 |
158 | def is_configured(self) -> bool:
159 | """Check if Cursor is configured (has rules or prompts)."""
160 | return (
161 | len(self.get_existing_rules()) > 0 or
162 | len(self.get_existing_prompts()) > 0 or
163 | self.has_mcp_config()
164 | )
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/templates/__init__.py:
--------------------------------------------------------------------------------
```python
1 | """
2 | Project and component templates for the MCP Project Orchestrator.
3 |
4 | This package exposes a simple template API used in tests:
5 | - TemplateType, TemplateCategory, TemplateMetadata, TemplateFile
6 | - ProjectTemplate, ComponentTemplate
7 | - TemplateManager (directory-based discovery)
8 | """
9 |
10 | from pathlib import Path
11 | from typing import Dict, List, Optional, Union
12 |
13 | from .types import TemplateType, TemplateCategory, TemplateMetadata, TemplateFile
14 | from .base import BaseTemplate
15 |
16 |
17 | class ProjectTemplate(BaseTemplate):
18 | """Project template with validation and apply logic for tests."""
19 |
20 | def validate(self) -> bool:
21 | # Valid if at least one file is present
22 | return len(self.files) > 0
23 |
24 | def apply(self, target_path: Union[str, Path]) -> None:
25 | target_path = Path(target_path)
26 | target_path.mkdir(parents=True, exist_ok=True)
27 |
28 | # Create a nested directory named after the project if provided
29 | project_dir_name = self.get_variable("project_name", "Project")
30 | project_root = target_path / project_dir_name
31 | project_root.mkdir(parents=True, exist_ok=True)
32 |
33 | for file in self.files:
34 | dest = project_root / file.path
35 | dest.parent.mkdir(parents=True, exist_ok=True)
36 | content = self.substitute_variables_jinja2(file.content) if file.path.endswith(".jinja2") else self.substitute_variables(file.content)
37 | dest.write_text(content)
38 |
39 |
40 | class ComponentTemplate(BaseTemplate):
41 | """Component template with validation and apply logic for tests."""
42 |
43 | def validate(self) -> bool:
44 | # Valid if at least one file is present
45 | return len(self.files) > 0
46 |
47 | def apply(self, target_path: Union[str, Path]) -> None:
48 | target_path = Path(target_path)
49 | target_path.mkdir(parents=True, exist_ok=True)
50 |
51 | for file in self.files:
52 | # Substitute variables in the file path as well
53 | file_path = self.substitute_variables(file.path)
54 | dest = target_path / file_path
55 | dest.parent.mkdir(parents=True, exist_ok=True)
56 | content = self.substitute_variables_jinja2(file.content) if file.path.endswith(".jinja2") else self.substitute_variables(file.content)
57 | dest.write_text(content)
58 |
59 |
60 | class TemplateManager:
61 | """Directory-based template discovery and access used in tests."""
62 |
63 | def __init__(self, templates_dir: Union[str, Path, None] = None) -> None:
64 | self.templates_dir = Path(templates_dir) if templates_dir else Path.cwd() / "templates"
65 | self._templates: Dict[str, BaseTemplate] = {}
66 |
67 | def discover_templates(self) -> None:
68 | self._templates.clear()
69 | if not self.templates_dir.exists():
70 | return
71 | for sub in self.templates_dir.iterdir():
72 | if not sub.is_dir():
73 | continue
74 | metadata_path = sub / "template.json"
75 | if not metadata_path.exists():
76 | continue
77 | try:
78 | meta = TemplateMetadata.from_dict(__import__("json").load(open(metadata_path)))
79 | except Exception:
80 | continue
81 | # Choose template class based on type
82 | if meta.type == TemplateType.PROJECT:
83 | template = ProjectTemplate(meta)
84 | else:
85 | template = ComponentTemplate(meta)
86 |
87 | # Load files directory if present
88 | files_dir = sub / "files"
89 | if files_dir.exists():
90 | for fp in files_dir.rglob("*"):
91 | if fp.is_file():
92 | rel = fp.relative_to(files_dir)
93 | content = fp.read_text()
94 | template.add_file(TemplateFile(path=str(rel), content=content))
95 |
96 | self._templates[meta.name] = template
97 |
98 | def list_templates(self, template_type: Optional[TemplateType] = None) -> List[str]:
99 | if template_type is None:
100 | return list(self._templates.keys())
101 | return [name for name, t in self._templates.items() if isinstance(t, ProjectTemplate) and template_type == TemplateType.PROJECT or isinstance(t, ComponentTemplate) and template_type == TemplateType.COMPONENT]
102 |
103 | def get_template(self, name: str) -> Optional[BaseTemplate]:
104 | return self._templates.get(name)
105 |
106 |
107 | __all__ = [
108 | "TemplateType",
109 | "TemplateCategory",
110 | "TemplateMetadata",
111 | "TemplateFile",
112 | "ProjectTemplate",
113 | "ComponentTemplate",
114 | "TemplateManager",
115 | ]
116 |
117 | def apply_template(self, template_name: str, variables: dict, target_dir: str) -> None:
118 | """Apply a template with variables to create a new project"""
119 | template = self.get_template(template_name)
120 | if not template:
121 | raise ValueError(f"Template '{template_name}' not found")
122 |
123 | # Set variables
124 | for key, value in variables.items():
125 | template.set_variable(key, str(value))
126 |
127 | # Apply template
128 | template.apply(target_dir)
129 |
```
--------------------------------------------------------------------------------
/mcp-project-orchestrator/openssl/docs/cursor-configuration-management.md:
--------------------------------------------------------------------------------
```markdown
1 | # Cursor Configuration Management
2 |
3 | ## Overview
4 |
5 | Cursor configuration is managed like Conan profiles:
6 | - **Templates** stored in package: `cursor-rules/`
7 | - **Deployed** to each repository: `.cursor/`
8 | - **Platform-specific** rules auto-selected
9 | - **Developer customization** via `--custom-rules`
10 |
11 | ## Deployment Model
12 |
13 | | Component | Location | Version Control |
14 | |-----------|----------|-----------------|
15 | | Templates | `mcp-project-orchestrator/openssl/cursor-rules/` | ✅ In package |
16 | | Deployed config | `<repo>/.cursor/` | ✅ In repo (standard rules) |
17 | | Custom rules | `<repo>/.cursor/rules/custom/` | ❌ Not committed (.gitignore) |
18 |
19 | ## Platform Detection
20 |
21 | The deployer automatically detects:
22 | - **OS**: Linux, macOS, Windows
23 | - **CI environment**: GitHub Actions, GitLab CI, etc.
24 | - **Python version**
25 | - **User home directory**
26 |
27 | ## Usage
28 |
29 | ### Quick Start
30 |
31 | ```bash
32 | # Install mcp-project-orchestrator/openssl
33 | pip install mcp-project-orchestrator-openssl
34 |
35 | # Deploy to current repository
36 | mcp-orchestrator setup-cursor
37 | ```
38 |
39 | ### Advanced Options
40 |
41 | ```bash
42 | # Force overwrite existing config
43 | mcp-orchestrator setup-cursor --force
44 |
45 | # Import custom rules
46 | mcp-orchestrator setup-cursor \
47 | --custom-rules ~/my-rules/crypto.mdc \
48 | --custom-rules ~/my-rules/testing.mdc
49 |
50 | # Opt out of AI features
51 | mcp-orchestrator setup-cursor --opt-out
52 |
53 | # Dry run (see what would be deployed)
54 | mcp-orchestrator setup-cursor --dry-run
55 | ```
56 |
57 | ## Customization
58 |
59 | ### Scenario: Add Team-Specific Rules
60 |
61 | 1. Fork `mcp-project-orchestrator/openssl`
62 | 2. Edit `cursor-rules/rules/shared.mdc.jinja2`
63 | 3. Publish to private PyPI or install from Git
64 |
65 | ```bash
66 | pip install git+https://github.com/mycompany/mcp-project-orchestrator/openssl.git@custom-rules
67 | ```
68 |
69 | ### Scenario: Disable MCP Servers
70 |
71 | Edit `.cursor/mcp.json` manually:
72 |
73 | ```json
74 | {
75 | "mcpServers": {
76 | "openssl-context": {
77 | "disabled": true
78 | }
79 | }
80 | }
81 | ```
82 |
83 | ## Version Control Best Practices
84 |
85 | Commit to Git:
86 | - ✅ `.cursor/rules/*.mdc` (standard rules)
87 | - ✅ `.cursor/prompts/*.md` (standard prompts)
88 | - ✅ `.cursor/mcp.json` (MCP configuration)
89 |
90 | Exclude from Git:
91 | - ❌ `.cursor/rules/custom/` (personal rules)
92 | - ❌ `.cursor/*.log`, `.cursor/*.cache`
93 |
94 | ## FAQ
95 |
96 | **Q: Can I skip Cursor deployment entirely?**
97 | A: Yes, use `--opt-out` or set `MCP_ORCHESTRATOR_OPT_OUT=true`.
98 |
99 | **Q: How do I update rules after package upgrade?**
100 | A: Run `mcp-orchestrator setup-cursor --force`.
101 |
102 | **Q: Can I use my own rule templates?**
103 | A: Yes, use `--custom-rules` to import your files.
104 |
105 | **Q: What if I want CI-specific rules locally?**
106 | A: Set `export CI=true` before running `setup-cursor`.
107 |
108 | ## Integration with OpenSSL Tools
109 |
110 | ### Setup Script Integration
111 |
112 | ```python
113 | # openssl-tools/setup_openssl_env.py (UPDATED)
114 | from openssl_conan_base.profile_deployer import deploy_conan_profiles
115 | from mcp_orchestrator.cursor_deployer import CursorConfigDeployer
116 | import click
117 |
118 | @click.command()
119 | @click.option('--with-cursor', is_flag=True, default=False,
120 | help='Also deploy Cursor AI configuration')
121 | @click.option('--cursor-opt-out', is_flag=True, default=False,
122 | help='Skip Cursor configuration deployment')
123 | def setup_environment(with_cursor, cursor_opt_out):
124 | """Setup OpenSSL development environment"""
125 |
126 | # Step 1: Deploy Conan profiles (always)
127 | click.echo("📦 Deploying Conan profiles...")
128 | deploy_conan_profiles()
129 |
130 | # Step 2: Deploy Cursor configuration (optional)
131 | if with_cursor and not cursor_opt_out:
132 | click.echo("🤖 Deploying Cursor AI configuration...")
133 | deployer = CursorConfigDeployer(Path.cwd(), get_mcp_package_root())
134 | deployer.deploy()
135 | elif cursor_opt_out:
136 | click.echo("⏭️ Skipping Cursor configuration (opt-out)")
137 | else:
138 | click.echo("ℹ️ Cursor configuration not deployed (use --with-cursor)")
139 |
140 | click.echo("✅ OpenSSL environment setup complete!")
141 |
142 | if __name__ == '__main__':
143 | setup_environment()
144 | ```
145 |
146 | ## Summary: Cursor as Profile Management
147 |
148 | | Aspect | Implementation |
149 | | :-- | :-- |
150 | | **Template Storage** | `mcp-project-orchestrator/openssl/cursor-rules/` (like `profiles/` in Conan packages) |
151 | | **Deployment Target** | `<repo>/.cursor/` (like `~/.conan2/profiles/`) |
152 | | **Platform Detection** | Auto-detect OS, CI, Python version (like profile selection logic) |
153 | | **Customization** | `--custom-rules` flag (like profile inheritance/override) |
154 | | **Opt-Out** | `--opt-out` flag or env var (like disabling Conan for a project) |
155 | | **Version Control** | Standard rules committed, custom rules excluded (like shared profiles + local overrides) |
156 | | **Update Strategy** | `--force` flag to re-deploy (like `conan config install --force`) |
157 |
158 | This pattern provides:
159 | - ✅ **Platform-specific** rules without manual selection
160 | - ✅ **Developer opt-out** for those who don't want AI
161 | - ✅ **Custom rule import** for personal preferences
162 | - ✅ **CI environment** detection and adaptation
163 | - ✅ **Reproducibility** through VCS-tracked standard rules
164 | - ✅ **Flexibility** through local customization
```
--------------------------------------------------------------------------------
/mcp-project-orchestrator/openssl/examples/example-workspace/src/crypto_utils.cpp:
--------------------------------------------------------------------------------
```cpp
1 | #include "crypto_utils.h"
2 | #include <openssl/evp.h>
3 | #include <openssl/rand.h>
4 | #include <openssl/sha.h>
5 | #include <iomanip>
6 | #include <sstream>
7 |
8 | std::string encrypt_aes256_gcm(const std::string& plaintext, const std::string& key) {
9 | if (key.length() != 32) {
10 | return ""; // Key must be 32 bytes for AES-256
11 | }
12 |
13 | EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
14 | if (!ctx) {
15 | return "";
16 | }
17 |
18 | // Generate random IV
19 | unsigned char iv[12]; // GCM uses 12-byte IV
20 | if (RAND_bytes(iv, sizeof(iv)) != 1) {
21 | EVP_CIPHER_CTX_free(ctx);
22 | return "";
23 | }
24 |
25 | // Initialize encryption
26 | if (EVP_EncryptInit_ex(ctx, EVP_aes_256_gcm(), NULL,
27 | reinterpret_cast<const unsigned char*>(key.c_str()), iv) != 1) {
28 | EVP_CIPHER_CTX_free(ctx);
29 | return "";
30 | }
31 |
32 | // Encrypt
33 | std::vector<unsigned char> ciphertext(plaintext.length() + EVP_CIPHER_block_size(EVP_aes_256_gcm()));
34 | int len;
35 | int ciphertext_len;
36 |
37 | if (EVP_EncryptUpdate(ctx, ciphertext.data(), &len,
38 | reinterpret_cast<const unsigned char*>(plaintext.c_str()),
39 | plaintext.length()) != 1) {
40 | EVP_CIPHER_CTX_free(ctx);
41 | return "";
42 | }
43 | ciphertext_len = len;
44 |
45 | if (EVP_EncryptFinal_ex(ctx, ciphertext.data() + len, &len) != 1) {
46 | EVP_CIPHER_CTX_free(ctx);
47 | return "";
48 | }
49 | ciphertext_len += len;
50 |
51 | // Get authentication tag
52 | unsigned char tag[16];
53 | if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_GET_TAG, 16, tag) != 1) {
54 | EVP_CIPHER_CTX_free(ctx);
55 | return "";
56 | }
57 |
58 | EVP_CIPHER_CTX_free(ctx);
59 |
60 | // Combine IV + ciphertext + tag
61 | std::stringstream ss;
62 | ss << std::hex << std::setfill('0');
63 |
64 | // Add IV
65 | for (int i = 0; i < 12; i++) {
66 | ss << std::setw(2) << static_cast<int>(iv[i]);
67 | }
68 |
69 | // Add ciphertext
70 | for (int i = 0; i < ciphertext_len; i++) {
71 | ss << std::setw(2) << static_cast<int>(ciphertext[i]);
72 | }
73 |
74 | // Add tag
75 | for (int i = 0; i < 16; i++) {
76 | ss << std::setw(2) << static_cast<int>(tag[i]);
77 | }
78 |
79 | return ss.str();
80 | }
81 |
82 | std::string decrypt_aes256_gcm(const std::string& ciphertext, const std::string& key) {
83 | if (key.length() != 32 || ciphertext.length() < 56) { // 24 (IV) + 32 (tag) minimum
84 | return "";
85 | }
86 |
87 | EVP_CIPHER_CTX* ctx = EVP_CIPHER_CTX_new();
88 | if (!ctx) {
89 | return "";
90 | }
91 |
92 | // Parse hex string
93 | std::vector<unsigned char> data;
94 | for (size_t i = 0; i < ciphertext.length(); i += 2) {
95 | std::string byte_str = ciphertext.substr(i, 2);
96 | data.push_back(static_cast<unsigned char>(std::stoi(byte_str, nullptr, 16)));
97 | }
98 |
99 | if (data.size() < 28) { // 12 (IV) + 16 (tag) minimum
100 | EVP_CIPHER_CTX_free(ctx);
101 | return "";
102 | }
103 |
104 | // Extract components
105 | unsigned char iv[12];
106 | std::copy(data.begin(), data.begin() + 12, iv);
107 |
108 | std::vector<unsigned char> encrypted_data(data.begin() + 12, data.end() - 16);
109 | unsigned char tag[16];
110 | std::copy(data.end() - 16, data.end(), tag);
111 |
112 | // Initialize decryption
113 | if (EVP_DecryptInit_ex(ctx, EVP_aes_256_gcm(), NULL,
114 | reinterpret_cast<const unsigned char*>(key.c_str()), iv) != 1) {
115 | EVP_CIPHER_CTX_free(ctx);
116 | return "";
117 | }
118 |
119 | // Decrypt
120 | std::vector<unsigned char> plaintext(encrypted_data.size() + EVP_CIPHER_block_size(EVP_aes_256_gcm()));
121 | int len;
122 | int plaintext_len;
123 |
124 | if (EVP_DecryptUpdate(ctx, plaintext.data(), &len,
125 | encrypted_data.data(), encrypted_data.size()) != 1) {
126 | EVP_CIPHER_CTX_free(ctx);
127 | return "";
128 | }
129 | plaintext_len = len;
130 |
131 | // Set authentication tag
132 | if (EVP_CIPHER_CTX_ctrl(ctx, EVP_CTRL_GCM_SET_TAG, 16, tag) != 1) {
133 | EVP_CIPHER_CTX_free(ctx);
134 | return "";
135 | }
136 |
137 | if (EVP_DecryptFinal_ex(ctx, plaintext.data() + len, &len) != 1) {
138 | EVP_CIPHER_CTX_free(ctx);
139 | return "";
140 | }
141 | plaintext_len += len;
142 |
143 | EVP_CIPHER_CTX_free(ctx);
144 |
145 | return std::string(reinterpret_cast<char*>(plaintext.data()), plaintext_len);
146 | }
147 |
148 | std::string generate_aes256_key() {
149 | unsigned char key[32];
150 | if (RAND_bytes(key, sizeof(key)) != 1) {
151 | return "";
152 | }
153 |
154 | std::stringstream ss;
155 | ss << std::hex << std::setfill('0');
156 | for (int i = 0; i < 32; i++) {
157 | ss << std::setw(2) << static_cast<int>(key[i]);
158 | }
159 |
160 | return ss.str();
161 | }
162 |
163 | std::string sha256_hash(const std::string& input) {
164 | unsigned char hash[SHA256_DIGEST_LENGTH];
165 | SHA256_CTX sha256;
166 | SHA256_Init(&sha256);
167 | SHA256_Update(&sha256, input.c_str(), input.length());
168 | SHA256_Final(hash, &sha256);
169 |
170 | std::stringstream ss;
171 | ss << std::hex << std::setfill('0');
172 | for (int i = 0; i < SHA256_DIGEST_LENGTH; i++) {
173 | ss << std::setw(2) << static_cast<int>(hash[i]);
174 | }
175 |
176 | return ss.str();
177 | }
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/template.py:
--------------------------------------------------------------------------------
```python
1 | """Prompt template implementation for MCP Project Orchestrator.
2 |
3 | This module provides the PromptTemplate class that handles individual prompt
4 | templates, including loading, validation, and rendering.
5 | """
6 |
7 | from typing import Dict, List, Any, Optional
8 | from jinja2 import Environment, Template, StrictUndefined
9 |
10 | from ..core.exceptions import PromptError
11 | from .version import PromptVersion
12 |
13 |
14 | class PromptTemplate:
15 | """Class representing a prompt template."""
16 |
17 | def __init__(
18 | self,
19 | name: str,
20 | description: str,
21 | version: PromptVersion,
22 | author: str,
23 | template: str,
24 | variables: Dict[str, Any],
25 | category: str = "general",
26 | tags: Optional[List[str]] = None
27 | ):
28 | """Initialize prompt template.
29 |
30 | Args:
31 | name: Template name
32 | description: Template description
33 | version: Template version
34 | author: Template author
35 | template: Template content
36 | variables: Template variables with descriptions
37 | category: Template category
38 | tags: Template tags
39 | """
40 | self.name = name
41 | self.description = description
42 | self.version = version
43 | self.author = author
44 | self.template = template
45 | self.variables = variables
46 | self.category = category
47 | self.tags = tags or []
48 |
49 | self._jinja_env = Environment(
50 | undefined=StrictUndefined,
51 | trim_blocks=True,
52 | lstrip_blocks=True,
53 | keep_trailing_newline=True
54 | )
55 | self._compiled_template: Optional[Template] = None
56 |
57 | async def validate(self) -> None:
58 | """Validate the prompt template.
59 |
60 | This method checks that:
61 | - Required fields are present
62 | - Template syntax is valid
63 | - Variable references are valid
64 |
65 | Raises:
66 | PromptError: If validation fails
67 | """
68 | if not self.name:
69 | raise PromptError("Template name is required")
70 |
71 | if not self.template:
72 | raise PromptError("Template content is required")
73 |
74 | try:
75 | self._compiled_template = self._jinja_env.from_string(self.template)
76 | except Exception as e:
77 | raise PromptError(
78 | f"Invalid template syntax in {self.name}",
79 | self.name
80 | ) from e
81 |
82 | # Validate variable references
83 | try:
84 | # Create dummy variables with None values
85 | dummy_vars = {name: None for name in self.variables}
86 | self._compiled_template.render(**dummy_vars)
87 | except Exception as e:
88 | raise PromptError(
89 | f"Invalid variable references in {self.name}",
90 | self.name
91 | ) from e
92 |
93 | async def render(self, variables: Dict[str, Any]) -> str:
94 | """Render the prompt template with variables.
95 |
96 | Args:
97 | variables: Template variables
98 |
99 | Returns:
100 | str: Rendered prompt
101 |
102 | Raises:
103 | PromptError: If rendering fails
104 | """
105 | if not self._compiled_template:
106 | await self.validate()
107 |
108 | try:
109 | # Validate required variables are provided
110 | missing = set(self.variables) - set(variables)
111 | if missing:
112 | raise PromptError(
113 | f"Missing required variables: {', '.join(missing)}",
114 | self.name
115 | )
116 |
117 | return self._compiled_template.render(**variables)
118 | except Exception as e:
119 | raise PromptError(
120 | f"Failed to render template {self.name}",
121 | self.name
122 | ) from e
123 |
124 | def get_variable_info(self) -> Dict[str, Dict[str, Any]]:
125 | """Get information about template variables.
126 |
127 | Returns:
128 | Dict[str, Dict[str, Any]]: Variable information
129 | """
130 | return self.variables
131 |
132 | def to_dict(self) -> Dict[str, Any]:
133 | """Convert template to dictionary representation.
134 |
135 | Returns:
136 | Dict[str, Any]: Dictionary representation
137 | """
138 | return {
139 | "name": self.name,
140 | "description": self.description,
141 | "version": {
142 | "major": self.version.major,
143 | "minor": self.version.minor,
144 | "patch": self.version.patch,
145 | },
146 | "author": self.author,
147 | "template": self.template,
148 | "variables": self.variables,
149 | "category": self.category,
150 | "tags": self.tags,
151 | }
152 |
153 | def __str__(self) -> str:
154 | """Get string representation.
155 |
156 | Returns:
157 | str: String representation
158 | """
159 | return f"{self.name} (v{self.version})"
160 |
161 | def __repr__(self) -> str:
162 | """Get detailed string representation.
163 |
164 | Returns:
165 | str: Detailed string representation
166 | """
167 | return (
168 | f"PromptTemplate(name='{self.name}', "
169 | f"version={self.version}, "
170 | f"category='{self.category}')"
171 | )
```
--------------------------------------------------------------------------------
/tests/test_mermaid.py:
--------------------------------------------------------------------------------
```python
1 | """Tests for the Mermaid diagram generation system."""
2 |
3 | import pytest
4 | from pathlib import Path
5 |
6 | from mcp_project_orchestrator.mermaid import (
7 | MermaidGenerator,
8 | MermaidRenderer,
9 | DiagramType,
10 | DiagramMetadata,
11 | )
12 |
13 | def test_diagram_metadata():
14 | """Test diagram metadata creation and conversion."""
15 | metadata = DiagramMetadata(
16 | name="test-diagram",
17 | description="Test diagram",
18 | type=DiagramType.FLOWCHART,
19 | version="1.0.0",
20 | author="Test Author",
21 | tags=["test", "flowchart"],
22 | )
23 |
24 | # Test to_dict
25 | data = metadata.to_dict()
26 | assert data["name"] == "test-diagram"
27 | assert data["type"] == "flowchart"
28 |
29 | # Test from_dict
30 | new_metadata = DiagramMetadata.from_dict(data)
31 | assert new_metadata.name == metadata.name
32 | assert new_metadata.type == metadata.type
33 |
34 | def test_mermaid_generator(mermaid_generator):
35 | """Test Mermaid diagram generation."""
36 | # Generate flowchart
37 | flowchart = mermaid_generator.generate_flowchart(
38 | nodes=[
39 | ("A", "Start"),
40 | ("B", "Process"),
41 | ("C", "End"),
42 | ],
43 | edges=[
44 | ("A", "B", ""),
45 | ("B", "C", ""),
46 | ],
47 | )
48 | assert "flowchart TD" in flowchart
49 | assert "A[Start]" in flowchart
50 | assert "B[Process]" in flowchart
51 | assert "C[End]" in flowchart
52 | assert "A --> B" in flowchart
53 | assert "B --> C" in flowchart
54 |
55 | # Generate sequence diagram
56 | sequence = mermaid_generator.generate_sequence(
57 | participants=["User", "System"],
58 | messages=[
59 | ("User", "System", "Request"),
60 | ("System", "User", "Response"),
61 | ],
62 | )
63 | assert "sequenceDiagram" in sequence
64 | assert "participant User" in sequence
65 | assert "participant System" in sequence
66 | assert "User->>System: Request" in sequence
67 | assert "System->>User: Response" in sequence
68 |
69 | # Generate class diagram
70 | class_diagram = mermaid_generator.generate_class(
71 | classes=[
72 | {
73 | "name": "Animal",
74 | "attributes": ["name: str", "age: int"],
75 | "methods": ["speak()", "move()"],
76 | },
77 | {
78 | "name": "Dog",
79 | "attributes": ["breed: str"],
80 | "methods": ["bark()"],
81 | },
82 | ],
83 | relationships=[
84 | ("Dog", "Animal", "extends"),
85 | ],
86 | )
87 | assert "classDiagram" in class_diagram
88 | assert "class Animal" in class_diagram
89 | assert "class Dog" in class_diagram
90 | assert "Dog --|> Animal" in class_diagram
91 |
92 | def test_mermaid_renderer(mermaid_renderer, temp_dir):
93 | """Test Mermaid diagram rendering."""
94 | # Create test diagram
95 | diagram = """
96 | flowchart TD
97 | A[Start] --> B[Process]
98 | B --> C[End]
99 | """
100 |
101 | # Render to SVG
102 | svg_path = temp_dir / "test.svg"
103 | mermaid_renderer.render(diagram, svg_path)
104 | assert svg_path.exists()
105 | assert svg_path.stat().st_size > 0
106 |
107 | # Render to PNG
108 | png_path = temp_dir / "test.png"
109 | mermaid_renderer.render(diagram, png_path)
110 | assert png_path.exists()
111 | assert png_path.stat().st_size > 0
112 |
113 | def test_diagram_save_load(mermaid_generator, temp_dir):
114 | """Test saving and loading diagrams."""
115 | # Create diagram
116 | metadata = DiagramMetadata(
117 | name="save-test",
118 | description="Save test diagram",
119 | type=DiagramType.FLOWCHART,
120 | version="1.0.0",
121 | author="Test Author",
122 | tags=["test"],
123 | )
124 | diagram = """
125 | flowchart TD
126 | A[Start] --> B[Process]
127 | B --> C[End]
128 | """
129 |
130 | # Save diagram
131 | diagram_dir = temp_dir / "diagrams"
132 | diagram_dir.mkdir(parents=True, exist_ok=True)
133 | diagram_file = diagram_dir / "save-test.mmd"
134 | mermaid_generator.save_diagram(metadata, diagram, diagram_file)
135 |
136 | # Load diagram
137 | loaded_metadata, loaded_diagram = mermaid_generator.load_diagram(diagram_file)
138 | assert loaded_metadata.name == metadata.name
139 | assert loaded_metadata.type == metadata.type
140 | assert loaded_diagram.strip() == diagram.strip()
141 |
142 | def test_diagram_validation(mermaid_generator):
143 | """Test diagram validation."""
144 | # Valid flowchart
145 | valid_flowchart = """
146 | flowchart TD
147 | A[Start] --> B[Process]
148 | B --> C[End]
149 | """
150 | assert mermaid_generator.validate_diagram(valid_flowchart, DiagramType.FLOWCHART)
151 |
152 | # Invalid flowchart (syntax error)
153 | invalid_flowchart = """
154 | flowchart TD
155 | A[Start] --> B[Process
156 | B --> C[End]
157 | """
158 | assert not mermaid_generator.validate_diagram(invalid_flowchart, DiagramType.FLOWCHART)
159 |
160 | # Valid sequence diagram
161 | valid_sequence = """
162 | sequenceDiagram
163 | participant A
164 | participant B
165 | A->>B: Message
166 | """
167 | assert mermaid_generator.validate_diagram(valid_sequence, DiagramType.SEQUENCE)
168 |
169 | # Invalid sequence diagram (missing participant)
170 | invalid_sequence = """
171 | sequenceDiagram
172 | A->>B: Message
173 | """
174 | assert not mermaid_generator.validate_diagram(invalid_sequence, DiagramType.SEQUENCE)
```
--------------------------------------------------------------------------------
/data/prompts/templates/sequential-data-analysis.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "id": "sequential-data-analysis",
3 | "name": "Sequential Data Analysis with MCP Integration",
4 | "description": "Advanced prompt template for multi-stage data analysis that integrates filesystem, database, memory, and sequential thinking MCP servers for comprehensive data workflows.",
5 | "content": "# Sequential Data Analysis Assistant\n\nYou are a specialized AI assistant for comprehensive data analysis, with access to multiple MCP servers that enhance your capabilities. Your task is to analyze {{data_type}} data from {{data_source}} and provide insights about {{analysis_objective}}.\n\n## Available MCP Servers\n\nYou have access to the following MCP servers to assist with this analysis:\n\n- **Filesystem**: Access data files, configuration, and save analysis outputs\n- **PostgreSQL**: Query structured data from databases\n- **Memory**: Store intermediate analysis results and insights\n- **Sequential Thinking**: Break complex analysis into logical steps\n- **GitHub**: Access code repositories, documentation, and data processing scripts\n{{additional_servers}}\n\n## Data Context\n\n- **Data Type**: {{data_type}}\n- **Data Source**: {{data_source}}\n- **Analysis Objective**: {{analysis_objective}}\n- **Technical Background**: {{technical_background}}\n- **Required Output Format**: {{output_format}}\n\n## Analysis Plan\n\nYour data analysis should follow these sequential steps, utilizing appropriate MCP servers at each stage:\n\n### 1. Data Discovery and Acquisition\n- Identify all relevant data sources across available servers\n- Use Filesystem MCP to check available data files\n- Use PostgreSQL MCP to explore database schema and available tables\n- Use GitHub MCP to locate relevant data processing scripts\n- Document data types, formats, and relationships\n\n### 2. Data Preparation\n- Use Sequential Thinking MCP to plan data cleaning steps\n- Process data to handle missing values, outliers, transformations\n- Use Memory MCP to store intermediate processing results\n- Document data preparation decisions and their rationale\n\n### 3. Exploratory Analysis\n- Calculate descriptive statistics\n- Identify patterns, correlations, and potential insights\n- Generate appropriate visualizations (described textually)\n- Store key observations in Memory MCP for later reference\n\n### 4. Advanced Analysis\n- Apply statistical methods or machine learning techniques appropriate for {{analysis_objective}}\n- Use Sequential Thinking MCP to break down complex analysis into logical steps\n- Reference relevant GitHub repositories for specialized algorithms\n- Document methodology, assumptions, and limitations\n\n### 5. Synthesis and Reporting\n- Summarize key findings and insights\n- Relate results back to {{analysis_objective}}\n- Provide actionable recommendations\n- Use Filesystem MCP to save analysis results in {{output_format}}\n\n## Guidelines for Your Response\n\n1. Begin by outlining your understanding of the analysis objective and the data context\n2. Specify which MCP servers you'll use for each analysis stage\n3. Provide a structured analysis following the sequential steps above\n4. For complex analyses, use the Sequential Thinking MCP to break down your reasoning\n5. Store important intermediate findings in Memory MCP and reference them in your final analysis\n6. Present results in the required {{output_format}}\n7. Include recommendations for further analysis or actions\n8. Document any limitations of your analysis or areas requiring human validation\n\n{{additional_guidelines}}",
6 | "isTemplate": true,
7 | "variables": [
8 | "data_type",
9 | "data_source",
10 | "analysis_objective",
11 | "technical_background",
12 | "output_format",
13 | "additional_servers",
14 | "additional_guidelines"
15 | ],
16 | "tags": [
17 | "data-analysis",
18 | "mcp-integration",
19 | "sequential-processing",
20 | "filesystem",
21 | "postgres",
22 | "memory",
23 | "sequential-thinking",
24 | "template"
25 | ],
26 | "createdAt": "2025-03-15T12:00:00.000Z",
27 | "updatedAt": "2025-03-15T12:00:00.000Z",
28 | "version": 1,
29 | "metadata": {
30 | "recommended_servers": [
31 | "filesystem",
32 | "postgres",
33 | "memory",
34 | "sequential-thinking",
35 | "github"
36 | ],
37 | "example_variables": {
38 | "data_type": "time series",
39 | "data_source": "PostgreSQL database with sensor readings and JSON log files",
40 | "analysis_objective": "identifying anomalies in IoT device performance",
41 | "technical_background": "The IoT devices are deployed in manufacturing environments and collect temperature, vibration, and power consumption data at 5-minute intervals",
42 | "output_format": "JSON report with statistical summary, detected anomalies, and visualization descriptions",
43 | "additional_servers": "- **Brave Search**: Access relevant research papers on IoT anomaly detection\n- **ElevenLabs**: Generate audio summary of critical findings",
44 | "additional_guidelines": "Focus particularly on correlations between temperature spikes and subsequent power consumption anomalies. The stakeholders are especially interested in predictive maintenance opportunities."
45 | }
46 | }
47 | }
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/coding/nonASCIIidentifierStartChars.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "nonASCIIidentifierStartChars",
3 | "description": "Prompt template extracted from lexer.js",
4 | "type": "prompt",
5 | "category": "coding",
6 | "content": "\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0370-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u037f\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u052f\\u0531-\\u0556\\u0559\\u0560-\\u0588\\u05d0-\\u05ea\\u05ef-\\u05f2\\u0620-\\u064a\\u066e\\u066f\\u0671-\\u06d3\\u06d5\\u06e5\\u06e6\\u06ee\\u06ef\\u06fa-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07ca-\\u07ea\\u07f4\\u07f5\\u07fa\\u0800-\\u0815\\u081a\\u0824\\u0828\\u0840-\\u0858\\u0860-\\u086a\\u08a0-\\u08b4\\u08b6-\\u08c7\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc\\u09dd\\u09df-\\u09e1\\u09f0\\u09f1\\u09fc\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0\\u0ae1\\u0af9\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c\\u0b5d\\u0b5f-\\u0b61\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c39\\u0c3d\\u0c58-\\u0c5a\\u0c60\\u0c61\\u0c80\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d04-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d54-\\u0d56\\u0d5f-\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e86-\\u0e8a\\u0e8c-\\u0ea3\\u0ea5\\u0ea7-\\u0eb0\\u0eb2\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0edc-\\u0edf\\u0f00\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8c\\u1000-\\u102a\\u103f\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f5\\u13f8-\\u13fd\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f8\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1878\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191e\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19b0-\\u19c9\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1c80-\\u1c88\\u1c90-\\u1cba\\u1cbd-\\u1cbf\\u1ce9-\\u1cec\\u1cee-\\u1cf3\\u1cf5\\u1cf6\\u1cfa\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2118-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309b-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312f\\u3131-\\u318e\\u31a0-\\u31bf\\u31f0-\\u31ff\\u3400-\\u4dbf\\u4e00-\\u9ffc\\ua000-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua69d\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua7bf\\ua7c2-\\ua7ca\\ua7f5-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua8fd\\ua8fe\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\ua9e0-\\ua9e4\\ua9e6-\\ua9ef\\ua9fa-\\ua9fe\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa7e-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uab30-\\uab5a\\uab5c-\\uab69\\uab70-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc",
7 | "variables": {},
8 | "metadata": {
9 | "source": "/home/sparrow/projects/mcp-prompts/node_modules/cjs-module-lexer/lexer.js",
10 | "imported": true
11 | }
12 | }
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/nonASCIIidentifierStartChars.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "nonASCIIidentifierStartChars",
3 | "description": "Prompt template extracted from lexer.js",
4 | "type": "prompt",
5 | "category": "coding",
6 | "content": "\\xaa\\xb5\\xba\\xc0-\\xd6\\xd8-\\xf6\\xf8-\\u02c1\\u02c6-\\u02d1\\u02e0-\\u02e4\\u02ec\\u02ee\\u0370-\\u0374\\u0376\\u0377\\u037a-\\u037d\\u037f\\u0386\\u0388-\\u038a\\u038c\\u038e-\\u03a1\\u03a3-\\u03f5\\u03f7-\\u0481\\u048a-\\u052f\\u0531-\\u0556\\u0559\\u0560-\\u0588\\u05d0-\\u05ea\\u05ef-\\u05f2\\u0620-\\u064a\\u066e\\u066f\\u0671-\\u06d3\\u06d5\\u06e5\\u06e6\\u06ee\\u06ef\\u06fa-\\u06fc\\u06ff\\u0710\\u0712-\\u072f\\u074d-\\u07a5\\u07b1\\u07ca-\\u07ea\\u07f4\\u07f5\\u07fa\\u0800-\\u0815\\u081a\\u0824\\u0828\\u0840-\\u0858\\u0860-\\u086a\\u08a0-\\u08b4\\u08b6-\\u08c7\\u0904-\\u0939\\u093d\\u0950\\u0958-\\u0961\\u0971-\\u0980\\u0985-\\u098c\\u098f\\u0990\\u0993-\\u09a8\\u09aa-\\u09b0\\u09b2\\u09b6-\\u09b9\\u09bd\\u09ce\\u09dc\\u09dd\\u09df-\\u09e1\\u09f0\\u09f1\\u09fc\\u0a05-\\u0a0a\\u0a0f\\u0a10\\u0a13-\\u0a28\\u0a2a-\\u0a30\\u0a32\\u0a33\\u0a35\\u0a36\\u0a38\\u0a39\\u0a59-\\u0a5c\\u0a5e\\u0a72-\\u0a74\\u0a85-\\u0a8d\\u0a8f-\\u0a91\\u0a93-\\u0aa8\\u0aaa-\\u0ab0\\u0ab2\\u0ab3\\u0ab5-\\u0ab9\\u0abd\\u0ad0\\u0ae0\\u0ae1\\u0af9\\u0b05-\\u0b0c\\u0b0f\\u0b10\\u0b13-\\u0b28\\u0b2a-\\u0b30\\u0b32\\u0b33\\u0b35-\\u0b39\\u0b3d\\u0b5c\\u0b5d\\u0b5f-\\u0b61\\u0b71\\u0b83\\u0b85-\\u0b8a\\u0b8e-\\u0b90\\u0b92-\\u0b95\\u0b99\\u0b9a\\u0b9c\\u0b9e\\u0b9f\\u0ba3\\u0ba4\\u0ba8-\\u0baa\\u0bae-\\u0bb9\\u0bd0\\u0c05-\\u0c0c\\u0c0e-\\u0c10\\u0c12-\\u0c28\\u0c2a-\\u0c39\\u0c3d\\u0c58-\\u0c5a\\u0c60\\u0c61\\u0c80\\u0c85-\\u0c8c\\u0c8e-\\u0c90\\u0c92-\\u0ca8\\u0caa-\\u0cb3\\u0cb5-\\u0cb9\\u0cbd\\u0cde\\u0ce0\\u0ce1\\u0cf1\\u0cf2\\u0d04-\\u0d0c\\u0d0e-\\u0d10\\u0d12-\\u0d3a\\u0d3d\\u0d4e\\u0d54-\\u0d56\\u0d5f-\\u0d61\\u0d7a-\\u0d7f\\u0d85-\\u0d96\\u0d9a-\\u0db1\\u0db3-\\u0dbb\\u0dbd\\u0dc0-\\u0dc6\\u0e01-\\u0e30\\u0e32\\u0e33\\u0e40-\\u0e46\\u0e81\\u0e82\\u0e84\\u0e86-\\u0e8a\\u0e8c-\\u0ea3\\u0ea5\\u0ea7-\\u0eb0\\u0eb2\\u0eb3\\u0ebd\\u0ec0-\\u0ec4\\u0ec6\\u0edc-\\u0edf\\u0f00\\u0f40-\\u0f47\\u0f49-\\u0f6c\\u0f88-\\u0f8c\\u1000-\\u102a\\u103f\\u1050-\\u1055\\u105a-\\u105d\\u1061\\u1065\\u1066\\u106e-\\u1070\\u1075-\\u1081\\u108e\\u10a0-\\u10c5\\u10c7\\u10cd\\u10d0-\\u10fa\\u10fc-\\u1248\\u124a-\\u124d\\u1250-\\u1256\\u1258\\u125a-\\u125d\\u1260-\\u1288\\u128a-\\u128d\\u1290-\\u12b0\\u12b2-\\u12b5\\u12b8-\\u12be\\u12c0\\u12c2-\\u12c5\\u12c8-\\u12d6\\u12d8-\\u1310\\u1312-\\u1315\\u1318-\\u135a\\u1380-\\u138f\\u13a0-\\u13f5\\u13f8-\\u13fd\\u1401-\\u166c\\u166f-\\u167f\\u1681-\\u169a\\u16a0-\\u16ea\\u16ee-\\u16f8\\u1700-\\u170c\\u170e-\\u1711\\u1720-\\u1731\\u1740-\\u1751\\u1760-\\u176c\\u176e-\\u1770\\u1780-\\u17b3\\u17d7\\u17dc\\u1820-\\u1878\\u1880-\\u18a8\\u18aa\\u18b0-\\u18f5\\u1900-\\u191e\\u1950-\\u196d\\u1970-\\u1974\\u1980-\\u19ab\\u19b0-\\u19c9\\u1a00-\\u1a16\\u1a20-\\u1a54\\u1aa7\\u1b05-\\u1b33\\u1b45-\\u1b4b\\u1b83-\\u1ba0\\u1bae\\u1baf\\u1bba-\\u1be5\\u1c00-\\u1c23\\u1c4d-\\u1c4f\\u1c5a-\\u1c7d\\u1c80-\\u1c88\\u1c90-\\u1cba\\u1cbd-\\u1cbf\\u1ce9-\\u1cec\\u1cee-\\u1cf3\\u1cf5\\u1cf6\\u1cfa\\u1d00-\\u1dbf\\u1e00-\\u1f15\\u1f18-\\u1f1d\\u1f20-\\u1f45\\u1f48-\\u1f4d\\u1f50-\\u1f57\\u1f59\\u1f5b\\u1f5d\\u1f5f-\\u1f7d\\u1f80-\\u1fb4\\u1fb6-\\u1fbc\\u1fbe\\u1fc2-\\u1fc4\\u1fc6-\\u1fcc\\u1fd0-\\u1fd3\\u1fd6-\\u1fdb\\u1fe0-\\u1fec\\u1ff2-\\u1ff4\\u1ff6-\\u1ffc\\u2071\\u207f\\u2090-\\u209c\\u2102\\u2107\\u210a-\\u2113\\u2115\\u2118-\\u211d\\u2124\\u2126\\u2128\\u212a-\\u2139\\u213c-\\u213f\\u2145-\\u2149\\u214e\\u2160-\\u2188\\u2c00-\\u2c2e\\u2c30-\\u2c5e\\u2c60-\\u2ce4\\u2ceb-\\u2cee\\u2cf2\\u2cf3\\u2d00-\\u2d25\\u2d27\\u2d2d\\u2d30-\\u2d67\\u2d6f\\u2d80-\\u2d96\\u2da0-\\u2da6\\u2da8-\\u2dae\\u2db0-\\u2db6\\u2db8-\\u2dbe\\u2dc0-\\u2dc6\\u2dc8-\\u2dce\\u2dd0-\\u2dd6\\u2dd8-\\u2dde\\u3005-\\u3007\\u3021-\\u3029\\u3031-\\u3035\\u3038-\\u303c\\u3041-\\u3096\\u309b-\\u309f\\u30a1-\\u30fa\\u30fc-\\u30ff\\u3105-\\u312f\\u3131-\\u318e\\u31a0-\\u31bf\\u31f0-\\u31ff\\u3400-\\u4dbf\\u4e00-\\u9ffc\\ua000-\\ua48c\\ua4d0-\\ua4fd\\ua500-\\ua60c\\ua610-\\ua61f\\ua62a\\ua62b\\ua640-\\ua66e\\ua67f-\\ua69d\\ua6a0-\\ua6ef\\ua717-\\ua71f\\ua722-\\ua788\\ua78b-\\ua7bf\\ua7c2-\\ua7ca\\ua7f5-\\ua801\\ua803-\\ua805\\ua807-\\ua80a\\ua80c-\\ua822\\ua840-\\ua873\\ua882-\\ua8b3\\ua8f2-\\ua8f7\\ua8fb\\ua8fd\\ua8fe\\ua90a-\\ua925\\ua930-\\ua946\\ua960-\\ua97c\\ua984-\\ua9b2\\ua9cf\\ua9e0-\\ua9e4\\ua9e6-\\ua9ef\\ua9fa-\\ua9fe\\uaa00-\\uaa28\\uaa40-\\uaa42\\uaa44-\\uaa4b\\uaa60-\\uaa76\\uaa7a\\uaa7e-\\uaaaf\\uaab1\\uaab5\\uaab6\\uaab9-\\uaabd\\uaac0\\uaac2\\uaadb-\\uaadd\\uaae0-\\uaaea\\uaaf2-\\uaaf4\\uab01-\\uab06\\uab09-\\uab0e\\uab11-\\uab16\\uab20-\\uab26\\uab28-\\uab2e\\uab30-\\uab5a\\uab5c-\\uab69\\uab70-\\uabe2\\uac00-\\ud7a3\\ud7b0-\\ud7c6\\ud7cb-\\ud7fb\\uf900-\\ufa6d\\ufa70-\\ufad9\\ufb00-\\ufb06\\ufb13-\\ufb17\\ufb1d\\ufb1f-\\ufb28\\ufb2a-\\ufb36\\ufb38-\\ufb3c\\ufb3e\\ufb40\\ufb41\\ufb43\\ufb44\\ufb46-\\ufbb1\\ufbd3-\\ufd3d\\ufd50-\\ufd8f\\ufd92-\\ufdc7\\ufdf0-\\ufdfb\\ufe70-\\ufe74\\ufe76-\\ufefc\\uff21-\\uff3a\\uff41-\\uff5a\\uff66-\\uffbe\\uffc2-\\uffc7\\uffca-\\uffcf\\uffd2-\\uffd7\\uffda-\\uffdc",
7 | "variables": {},
8 | "metadata": {
9 | "source": "/home/sparrow/projects/mcp-prompts/node_modules/cjs-module-lexer/lexer.js",
10 | "imported": true
11 | }
12 | }
```
--------------------------------------------------------------------------------
/docs/integration.md:
--------------------------------------------------------------------------------
```markdown
1 | # Integrating Mermaid Server with Other MCP Servers
2 |
3 | The Mermaid MCP Server can be integrated with other MCP servers to create powerful workflows. Here are some common integration patterns:
4 |
5 | ## GitHub Integration
6 |
7 | Use the GitHub MCP Server with Mermaid to commit generated diagrams to repositories:
8 |
9 | ```python
10 | # Example workflow: Generate a diagram and commit it to GitHub
11 | # 1. Generate a diagram with Mermaid
12 | diagram = mermaid_server.generate_diagram(
13 | "Create a sequence diagram for API authentication flow",
14 | theme="dark"
15 | )
16 |
17 | # 2. Commit the diagram to GitHub
18 | github_server.create_or_update_file(
19 | owner="your-username",
20 | repo="your-repo",
21 | path="docs/diagrams/authentication-flow.mmd",
22 | content=diagram,
23 | message="Add authentication flow diagram",
24 | branch="main"
25 | )
26 | ```
27 |
28 | ## Database Integration
29 |
30 | Store and retrieve diagrams using the PostgreSQL or SQLite MCP Server:
31 |
32 | ```python
33 | # Example workflow: Store a diagram in a database
34 | # 1. Generate a diagram with Mermaid
35 | diagram = mermaid_server.generate_diagram(
36 | "Create an ER diagram for a social media database",
37 | theme="vibrant"
38 | )
39 |
40 | # 2. Store the diagram in a database
41 | postgres_server.execute_query(
42 | query="INSERT INTO diagrams (name, content, created_at) VALUES ($1, $2, NOW())",
43 | parameters=["social_media_er_diagram", diagram]
44 | )
45 | ```
46 |
47 | ## Memory Integration
48 |
49 | Use the Memory MCP Server to remember your commonly used diagrams:
50 |
51 | ```python
52 | # Example workflow: Save a diagram to memory
53 | # 1. Generate a diagram with Mermaid
54 | diagram = mermaid_server.generate_diagram(
55 | "Create a flowchart for user onboarding",
56 | theme="pastel"
57 | )
58 |
59 | # 2. Store the diagram in memory
60 | memory_server.add_memory(
61 | content=f"User onboarding flowchart: ```mermaid\n{diagram}\n```",
62 | metadata={
63 | "type": "diagram",
64 | "diagram_type": "flowchart",
65 | "topic": "user_onboarding",
66 | "theme": "pastel"
67 | }
68 | )
69 | ```
70 |
71 | ## Slack Integration
72 |
73 | Share diagrams with your team via Slack:
74 |
75 | ```python
76 | # Example workflow: Generate a diagram and post it to Slack
77 | # 1. Generate a diagram with Mermaid
78 | diagram = mermaid_server.generate_diagram(
79 | "Create a class diagram for our e-commerce application",
80 | theme="default"
81 | )
82 |
83 | # 2. Generate an SVG preview
84 | svg_base64 = mermaid_server.preview_diagram(diagram)
85 |
86 | # 3. Post to Slack with the preview
87 | slack_server.post_message(
88 | channel="#engineering",
89 | text="Here's the class diagram for our e-commerce app:",
90 | blocks=[
91 | {
92 | "type": "image",
93 | "title": {
94 | "type": "plain_text",
95 | "text": "E-commerce Class Diagram"
96 | },
97 | "image_url": f"data:image/svg+xml;base64,{svg_base64}",
98 | "alt_text": "Class Diagram"
99 | }
100 | ]
101 | )
102 | ```
103 |
104 | ## File System Integration
105 |
106 | Save diagrams and SVG previews to the filesystem:
107 |
108 | ```python
109 | # Example workflow: Generate a diagram and save it to the filesystem
110 | # 1. Generate a diagram with Mermaid
111 | diagram = mermaid_server.generate_diagram(
112 | "Create a network diagram for our infrastructure",
113 | theme="dark"
114 | )
115 |
116 | # 2. Generate an SVG preview
117 | svg_base64 = mermaid_server.preview_diagram(diagram)
118 | svg_bytes = base64.b64decode(svg_base64)
119 |
120 | # 3. Save to filesystem
121 | filesystem_server.write_file(
122 | path="diagrams/network_diagram.mmd",
123 | content=diagram
124 | )
125 |
126 | filesystem_server.write_file(
127 | path="diagrams/network_diagram.svg",
128 | content=svg_bytes,
129 | mode="binary"
130 | )
131 | ```
132 |
133 | ## Orchestrator Integration
134 |
135 | Use an orchestrator to coordinate complex workflows:
136 |
137 | ```python
138 | # Example workflow: Orchestrate a complex diagramming process
139 | orchestrator_server.create_workflow(
140 | name="diagram_workflow",
141 | steps=[
142 | {
143 | "name": "generate_diagram",
144 | "server": "mermaid-generator",
145 | "tool": "generate_diagram",
146 | "params": {
147 | "query": "Create a sequence diagram for user registration",
148 | "theme": "vibrant"
149 | },
150 | "output_var": "diagram"
151 | },
152 | {
153 | "name": "analyze_diagram",
154 | "server": "mermaid-generator",
155 | "tool": "analyze_diagram",
156 | "params": {
157 | "diagram": "$diagram"
158 | },
159 | "output_var": "analysis"
160 | },
161 | {
162 | "name": "modify_diagram",
163 | "server": "mermaid-generator",
164 | "tool": "modify_diagram",
165 | "params": {
166 | "diagram": "$diagram",
167 | "modification": "Add error handling for duplicate email",
168 | "theme": "vibrant"
169 | },
170 | "output_var": "improved_diagram"
171 | },
172 | {
173 | "name": "save_to_github",
174 | "server": "github",
175 | "tool": "create_or_update_file",
176 | "params": {
177 | "owner": "your-username",
178 | "repo": "your-repo",
179 | "path": "docs/diagrams/user_registration.mmd",
180 | "content": "$improved_diagram",
181 | "message": "Add user registration diagram with error handling",
182 | "branch": "main"
183 | }
184 | }
185 | ]
186 | )
187 | ```
188 |
189 | These integrations demonstrate how the Mermaid MCP Server can be part of larger workflows, combining with other servers to automate diagram creation, storage, sharing, and version control.
```
--------------------------------------------------------------------------------
/data/prompts/templates/collaborative-development.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "id": "collaborative-development",
3 | "name": "Collaborative Development with MCP Integration",
4 | "description": "Advanced prompt template for collaborative software development that integrates GitHub, filesystem, memory, and sequential thinking MCP servers for efficient team workflows.",
5 | "content": "# Collaborative Development Assistant\\n\\nYou are a specialized AI assistant for collaborative software development, with access to multiple MCP servers that enhance your capabilities. Your task is to assist with {{development_task}} for project {{project_name}}, focusing on {{development_focus}}.\\n\\n## Available MCP Servers\\n\\nYou have access to the following MCP servers to assist with this development task:\\n\\n- **GitHub**: Access repositories, pull requests, issues, and code\\n- **Filesystem**: View and modify local code, configuration, and documentation\\n- **Memory**: Store development context across sessions\\n- **Sequential Thinking**: Break complex development tasks into logical steps\\n- **PostgreSQL**: Access database schema and data models (if applicable)\\n{{additional_servers}}\\n\\n## Project Context\\n\\n- **Project Name**: {{project_name}}\\n- **Development Task**: {{development_task}}\\n- **Technology Stack**: {{technology_stack}}\\n- **Development Focus**: {{development_focus}}\\n- **Collaboration Context**: {{collaboration_context}}\\n\\n## Development Workflow\\n\\nYour assistance should follow these collaborative steps, utilizing appropriate MCP servers at each stage:\\n\\n### 1. Project Understanding and Planning\\n- Use GitHub MCP to explore repository structure, open issues, and pull requests\\n- Use Filesystem MCP to examine local codebase organization\\n- Use Sequential Thinking MCP to break down the development task\\n- Document dependencies, requirements, and potential challenges\\n\\n### 2. Code Analysis and Design\\n- Analyze existing code relevant to the task\\n- Identify areas requiring modification or enhancement\\n- Sketch proposed changes or additions\\n- Use Memory MCP to store key design decisions for future reference\\n\\n### 3. Implementation Strategy\\n- Detail specific files to modify, create, or delete\\n- Outline test coverage requirements\\n- Suggest optimal development sequence\\n- Consider impact on other components or team members' work\\n\\n### 4. Collaboration Coordination\\n- Identify potential merge conflicts or dependencies\\n- Suggest communication points with other team members\\n- Outline review process for completed work\\n- Use GitHub MCP to track related issues or discussions\\n\\n### 5. Quality Assurance\\n- Suggest test scenarios for the implemented changes\\n- Provide code review guidelines\\n- Outline documentation requirements\\n- Consider performance, security, and maintainability factors\\n\\n## Guidelines for Your Response\\n\\n1. Begin by demonstrating your understanding of the project context and development task\\n2. Specify which MCP servers you'll use for each development stage\\n3. Provide a structured plan following the collaborative workflow above\\n4. For complex tasks, use the Sequential Thinking MCP to break down your reasoning\\n5. Store important development decisions in Memory MCP for continuity\\n6. Emphasize best practices for the specific {{technology_stack}}\\n7. Consider team dynamics from {{collaboration_context}}\\n8. Suggest ways to document the work for future reference\\n\\n{{additional_guidelines}}\\\",\\n \\\"isTemplate\\\": true,\\n \\\"variables\\\": [\\n \\\"project_name\\\",\\n \\\"development_task\\\",\\n \\\"technology_stack\\\",\\n \\\"development_focus\\\",\\n \\\"collaboration_context\\\",\\n \\\"additional_servers\\\",\\n \\\"additional_guidelines\\\"\\n ],\\n \\\"tags\\\": [\\n \\\"software-development\\\",\\n \\\"mcp-integration\\\",\\n \\\"collaboration\\\",\\n \\\"github\\\",\\n \\\"filesystem\\\",\\n \\\"memory\\\",\\n \\\"sequential-thinking\\\",\\n \\\"template\\\"\\n ],\\n \\\"createdAt\\\": \\\"2025-03-15T12:00:00.000Z\\\",\\n \\\"updatedAt\\\": \\\"2025-03-15T12:00:00.000Z\\\",\\n \\\"version\\\": 1,\\n \\\"metadata\\\": {\\n \\\"recommended_servers\\\": [\\n \\\"github\\\",\\n \\\"filesystem\\\",\\n \\\"memory\\\",\\n \\\"sequential-thinking\\\",\\n \\\"postgres\\\"\\n ],\\n \\\"example_variables\\\": {\\n \\\"project_name\\\": \\\"MCP-Prompts\\\",\\n \\\"development_task\\\": \\\"implementing a new feature for multi-server integration\\\",\\n \\\"technology_stack\\\": \\\"Node.js, TypeScript, Express, PostgreSQL, Docker\\\",\\n \\\"development_focus\\\": \\\"API design and database integration\\\",\\n \\\"collaboration_context\\\": \\\"Distributed team with 3 frontend developers and 2 backend developers across different time zones\\\",\\n \\\"additional_servers\\\": \\\"- **ElevenLabs**: Generate audio summaries for team standups\\\\n- **Brave Search**: Research best practices for API design patterns\\\",\\n \\\"additional_guidelines\\\": \\\"This feature is high priority for the upcoming release, so focus on maintainable solutions that can be implemented quickly without sacrificing code quality. The team follows a trunk-based development approach with feature flags for in-progress work."
6 | }
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/fastmcp.py:
--------------------------------------------------------------------------------
```python
1 | #!/usr/bin/env python3
2 | """
3 | FastMCP server implementation for the MCP Project Orchestrator.
4 |
5 | This module provides a lightweight MCP server that handles communication
6 | with MCP clients like Claude Desktop, exposing project orchestration
7 | capabilities through the Model Context Protocol.
8 | """
9 | import sys
10 | import signal
11 | import logging
12 | import json
13 | import time
14 | from typing import Any, Optional, Callable
15 | from dotenv import load_dotenv
16 |
17 | # Load environment variables from .env file
18 | load_dotenv()
19 |
20 | # Set up logging
21 | logging.basicConfig(
22 | level=logging.INFO,
23 | format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
24 | handlers=[logging.StreamHandler()]
25 | )
26 | logger = logging.getLogger("mcp-project-orchestrator")
27 |
28 | class FastMCP:
29 | """
30 | FastMCP server implementation for project orchestration.
31 |
32 | This class provides a lightweight MCP server that handles communication
33 | with MCP clients, exposing project orchestration capabilities through
34 | registered tools and appropriate error handling.
35 | """
36 |
37 | def __init__(self, name: str):
38 | """
39 | Initialize the MCP server with the given name.
40 |
41 | Args:
42 | name: Name of the MCP server
43 | """
44 | self.name = name
45 | self.config = {}
46 | self.tools = {}
47 | self.resources = {}
48 |
49 | # Set up signal handlers
50 | signal.signal(signal.SIGINT, self._handle_signal)
51 | signal.signal(signal.SIGTERM, self._handle_signal)
52 |
53 | logger.info(f"Initialized FastMCP server '{name}'")
54 |
55 | # Try to load configuration if it exists
56 | self._load_config()
57 |
58 | def _load_config(self) -> None:
59 | """Load configuration from project_orchestration.json if it exists."""
60 | import os
61 |
62 | try:
63 | config_path = os.path.join(os.getcwd(), "project_orchestration.json")
64 | if os.path.exists(config_path):
65 | with open(config_path, 'r') as f:
66 | self.config = json.load(f)
67 | logger.info(f"Loaded configuration from {config_path}")
68 | else:
69 | logger.warning(f"Configuration file {config_path} not found, using defaults")
70 | except Exception as e:
71 | logger.error(f"Error loading configuration: {str(e)}")
72 |
73 | def tool(self, func: Optional[Callable] = None,
74 | name: Optional[str] = None,
75 | description: Optional[str] = None):
76 | """
77 | Decorator to register a function as an MCP tool.
78 |
79 | Args:
80 | func: The function to register
81 | name: Optional name for the tool (defaults to function name)
82 | description: Optional description of the tool
83 |
84 | Returns:
85 | The decorated function
86 | """
87 | def decorator(fn):
88 | tool_name = name or fn.__name__
89 | tool_desc = description or fn.__doc__ or f"Tool {tool_name}"
90 |
91 | self.tools[tool_name] = {
92 | "function": fn,
93 | "description": tool_desc,
94 | "parameters": {} # In a real implementation, extract from function signature
95 | }
96 |
97 | logger.info(f"Registered tool '{tool_name}'")
98 | return fn
99 |
100 | if func is None:
101 | return decorator
102 | return decorator(func)
103 |
104 | def resource(self, name: str, content: Any) -> None:
105 | """
106 | Register a resource with the MCP server.
107 |
108 | Args:
109 | name: Name of the resource
110 | content: Content of the resource
111 | """
112 | self.resources[name] = content
113 | logger.info(f"Registered resource '{name}'")
114 |
115 | def _handle_signal(self, signum: int, frame: Any) -> None:
116 | """
117 | Handle shutdown signals gracefully.
118 |
119 | Args:
120 | signum: Signal number
121 | frame: Current stack frame
122 | """
123 | signal_name = signal.Signals(signum).name
124 | logger.info(f"Received {signal_name}, shutting down...")
125 | sys.exit(0)
126 |
127 | def _handle_client_connection(self) -> None:
128 | """Handle client connections and MCP protocol messages."""
129 | logger.info("Handling client connection")
130 | # In a real implementation, this would use proper MCP protocol
131 | # to handle client requests, parse JSON messages, etc.
132 |
133 | def run(self) -> None:
134 | """Run the MCP server and handle client connections."""
135 | logger.info(f"FastMCP server '{self.name}' running with configuration: {self.config}")
136 |
137 | try:
138 | # In a real implementation, this would start a proper server
139 | # that listens for connections and handles MCP protocol
140 | logger.info("Server running on port 8080")
141 | logger.info("Press Ctrl+C to stop")
142 |
143 | # For demonstration, just keep the process running
144 | while True:
145 | time.sleep(1)
146 | except KeyboardInterrupt:
147 | logger.info("Keyboard interrupt received, shutting down...")
148 | except Exception as e:
149 | logger.error(f"Error running server: {str(e)}")
150 | finally:
151 | logger.info("Server shutting down")
152 |
153 | def main() -> None:
154 | """Main entry point for the FastMCP server."""
155 | server = FastMCP("Project Orchestrator")
156 | server.run()
157 |
158 | if __name__ == "__main__":
159 | main()
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/core/config.py:
--------------------------------------------------------------------------------
```python
1 | """Configuration management for MCP Project Orchestrator.
2 |
3 | This module provides configuration management functionality through Pydantic models,
4 | including settings validation and loading from various sources.
5 | """
6 |
7 | from pathlib import Path
8 | from typing import Dict, Any, Optional, Union
9 | import json
10 | import yaml
11 |
12 | from pydantic import BaseModel, Field
13 |
14 |
15 | class Settings(BaseModel):
16 | """Settings model for MCP Project Orchestrator."""
17 |
18 | # Project paths
19 | workspace_dir: Path = Field(
20 | default=Path.cwd(),
21 | description="Root directory for the workspace"
22 | )
23 | templates_dir: Path = Field(
24 | default=Path("templates"),
25 | description="Directory containing project templates"
26 | )
27 | prompts_dir: Path = Field(
28 | default=Path("prompts"),
29 | description="Directory containing prompt templates"
30 | )
31 | resources_dir: Path = Field(
32 | default=Path("resources"),
33 | description="Directory containing project resources"
34 | )
35 | output_dir: Path = Field(
36 | default=Path("output"),
37 | description="Directory for generated output"
38 | )
39 |
40 | # Server settings
41 | host: str = Field(
42 | default="localhost",
43 | description="Host to bind the server to"
44 | )
45 | port: int = Field(
46 | default=8000,
47 | description="Port to bind the server to"
48 | )
49 | debug: bool = Field(
50 | default=False,
51 | description="Enable debug mode"
52 | )
53 |
54 | # Component settings
55 | mermaid_path: Optional[str] = Field(
56 | default=None,
57 | description="Path to Mermaid CLI executable"
58 | )
59 | template_extensions: Dict[str, str] = Field(
60 | default={
61 | ".py": "python",
62 | ".js": "javascript",
63 | ".ts": "typescript",
64 | ".md": "markdown",
65 | ".yml": "yaml",
66 | ".yaml": "yaml",
67 | ".json": "json",
68 | },
69 | description="Mapping of file extensions to template types"
70 | )
71 |
72 | class MCPConfig:
73 | """Pydantic model configuration."""
74 | arbitrary_types_allowed = True
75 |
76 |
77 | class MCPConfig:
78 | """Configuration manager for MCP Project Orchestrator."""
79 |
80 | def __init__(
81 | self,
82 | config_path: Optional[Union[str, Path]] = None,
83 | env_prefix: str = "MCP_",
84 | ):
85 | """Initialize configuration manager.
86 |
87 | Args:
88 | config_path: Optional path to configuration file
89 | env_prefix: Prefix for environment variables
90 | """
91 | self.config_path = Path(config_path) if config_path else None
92 | self.env_prefix = env_prefix
93 | self.settings = Settings()
94 |
95 | def load_config(self) -> None:
96 | """Load configuration from file and environment variables."""
97 | if self.config_path and self.config_path.exists():
98 | config_data = self._load_config_file(self.config_path)
99 | self.settings = Settings(**config_data)
100 |
101 | # Update with environment variables
102 | self._update_from_env()
103 |
104 | # Ensure directories exist
105 | self._create_directories()
106 |
107 | def _load_config_file(self, path: Path) -> Dict[str, Any]:
108 | """Load configuration from file.
109 |
110 | Args:
111 | path: Path to configuration file
112 |
113 | Returns:
114 | Dict[str, Any]: Configuration data
115 | """
116 | if path.suffix in [".yml", ".yaml"]:
117 | with open(path) as f:
118 | return yaml.safe_load(f)
119 | elif path.suffix == ".json":
120 | with open(path) as f:
121 | return json.load(f)
122 | else:
123 | raise ValueError(f"Unsupported config file format: {path.suffix}")
124 |
125 | def _update_from_env(self) -> None:
126 | """Update settings from environment variables."""
127 | # This will be handled by Pydantic's env var support
128 | pass
129 |
130 | def _create_directories(self) -> None:
131 | """Create required directories if they don't exist."""
132 | directories = [
133 | self.settings.workspace_dir,
134 | self.settings.templates_dir,
135 | self.settings.prompts_dir,
136 | self.settings.resources_dir,
137 | self.settings.output_dir,
138 | ]
139 |
140 | for directory in directories:
141 | directory.mkdir(parents=True, exist_ok=True)
142 |
143 | def get_workspace_path(self, *paths: str) -> Path:
144 | """Get a path relative to the workspace directory.
145 |
146 | Args:
147 | *paths: Path components to join
148 |
149 | Returns:
150 | Path: Resolved workspace path
151 | """
152 | return self.settings.workspace_dir.joinpath(*paths)
153 |
154 | def get_template_path(self, *paths: str) -> Path:
155 | """Get a path relative to the templates directory.
156 |
157 | Args:
158 | *paths: Path components to join
159 |
160 | Returns:
161 | Path: Resolved template path
162 | """
163 | return self.settings.templates_dir.joinpath(*paths)
164 |
165 | def get_prompt_path(self, *paths: str) -> Path:
166 | """Get a path relative to the prompts directory.
167 |
168 | Args:
169 | *paths: Path components to join
170 |
171 | Returns:
172 | Path: Resolved prompt path
173 | """
174 | return self.settings.prompts_dir.joinpath(*paths)
175 |
176 | def get_resource_path(self, *paths: str) -> Path:
177 | """Get a path relative to the resources directory.
178 |
179 | Args:
180 | *paths: Path components to join
181 |
182 | Returns:
183 | Path: Resolved resource path
184 | """
185 | return self.settings.resources_dir.joinpath(*paths)
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/other/Collaborative_Development_with_MCP_Integration.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "Collaborative Development with MCP Integration",
3 | "description": "Advanced prompt template for collaborative software development that integrates GitHub, filesystem, memory, and sequential thinking MCP servers for efficient team workflows.",
4 | "type": "prompt",
5 | "category": "other",
6 | "content": "# Collaborative Development Assistant\\n\\nYou are a specialized AI assistant for collaborative software development, with access to multiple MCP servers that enhance your capabilities. Your task is to assist with {{development_task}} for project {{project_name}}, focusing on {{development_focus}}.\\n\\n## Available MCP Servers\\n\\nYou have access to the following MCP servers to assist with this development task:\\n\\n- **GitHub**: Access repositories, pull requests, issues, and code\\n- **Filesystem**: View and modify local code, configuration, and documentation\\n- **Memory**: Store development context across sessions\\n- **Sequential Thinking**: Break complex development tasks into logical steps\\n- **PostgreSQL**: Access database schema and data models (if applicable)\\n{{additional_servers}}\\n\\n## Project Context\\n\\n- **Project Name**: {{project_name}}\\n- **Development Task**: {{development_task}}\\n- **Technology Stack**: {{technology_stack}}\\n- **Development Focus**: {{development_focus}}\\n- **Collaboration Context**: {{collaboration_context}}\\n\\n## Development Workflow\\n\\nYour assistance should follow these collaborative steps, utilizing appropriate MCP servers at each stage:\\n\\n### 1. Project Understanding and Planning\\n- Use GitHub MCP to explore repository structure, open issues, and pull requests\\n- Use Filesystem MCP to examine local codebase organization\\n- Use Sequential Thinking MCP to break down the development task\\n- Document dependencies, requirements, and potential challenges\\n\\n### 2. Code Analysis and Design\\n- Analyze existing code relevant to the task\\n- Identify areas requiring modification or enhancement\\n- Sketch proposed changes or additions\\n- Use Memory MCP to store key design decisions for future reference\\n\\n### 3. Implementation Strategy\\n- Detail specific files to modify, create, or delete\\n- Outline test coverage requirements\\n- Suggest optimal development sequence\\n- Consider impact on other components or team members' work\\n\\n### 4. Collaboration Coordination\\n- Identify potential merge conflicts or dependencies\\n- Suggest communication points with other team members\\n- Outline review process for completed work\\n- Use GitHub MCP to track related issues or discussions\\n\\n### 5. Quality Assurance\\n- Suggest test scenarios for the implemented changes\\n- Provide code review guidelines\\n- Outline documentation requirements\\n- Consider performance, security, and maintainability factors\\n\\n## Guidelines for Your Response\\n\\n1. Begin by demonstrating your understanding of the project context and development task\\n2. Specify which MCP servers you'll use for each development stage\\n3. Provide a structured plan following the collaborative workflow above\\n4. For complex tasks, use the Sequential Thinking MCP to break down your reasoning\\n5. Store important development decisions in Memory MCP for continuity\\n6. Emphasize best practices for the specific {{technology_stack}}\\n7. Consider team dynamics from {{collaboration_context}}\\n8. Suggest ways to document the work for future reference\\n\\n{{additional_guidelines}}\\\",\\n \\\"isTemplate\\\": true,\\n \\\"variables\\\": [\\n \\\"project_name\\\",\\n \\\"development_task\\\",\\n \\\"technology_stack\\\",\\n \\\"development_focus\\\",\\n \\\"collaboration_context\\\",\\n \\\"additional_servers\\\",\\n \\\"additional_guidelines\\\"\\n ],\\n \\\"tags\\\": [\\n \\\"software-development\\\",\\n \\\"mcp-integration\\\",\\n \\\"collaboration\\\",\\n \\\"github\\\",\\n \\\"filesystem\\\",\\n \\\"memory\\\",\\n \\\"sequential-thinking\\\",\\n \\\"template\\\"\\n ],\\n \\\"createdAt\\\": \\\"2025-03-15T12:00:00.000Z\\\",\\n \\\"updatedAt\\\": \\\"2025-03-15T12:00:00.000Z\\\",\\n \\\"version\\\": 1,\\n \\\"metadata\\\": {\\n \\\"recommended_servers\\\": [\\n \\\"github\\\",\\n \\\"filesystem\\\",\\n \\\"memory\\\",\\n \\\"sequential-thinking\\\",\\n \\\"postgres\\\"\\n ],\\n \\\"example_variables\\\": {\\n \\\"project_name\\\": \\\"MCP-Prompts\\\",\\n \\\"development_task\\\": \\\"implementing a new feature for multi-server integration\\\",\\n \\\"technology_stack\\\": \\\"Node.js, TypeScript, Express, PostgreSQL, Docker\\\",\\n \\\"development_focus\\\": \\\"API design and database integration\\\",\\n \\\"collaboration_context\\\": \\\"Distributed team with 3 frontend developers and 2 backend developers across different time zones\\\",\\n \\\"additional_servers\\\": \\\"- **ElevenLabs**: Generate audio summaries for team standups\\\\n- **Brave Search**: Research best practices for API design patterns\\\",\\n \\\"additional_guidelines\\\": \\\"This feature is high priority for the upcoming release, so focus on maintainable solutions that can be implemented quickly without sacrificing code quality. The team follows a trunk-based development approach with feature flags for in-progress work.",
7 | "variables": {},
8 | "metadata": {
9 | "source": "/home/sparrow/projects/mcp-prompts/prompts/collaborative-development.json",
10 | "imported": true
11 | }
12 | }
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/Collaborative_Development_with_MCP_Integration.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "Collaborative Development with MCP Integration",
3 | "description": "Advanced prompt template for collaborative software development that integrates GitHub, filesystem, memory, and sequential thinking MCP servers for efficient team workflows.",
4 | "type": "prompt",
5 | "category": "development",
6 | "content": "# Collaborative Development Assistant\\n\\nYou are a specialized AI assistant for collaborative software development, with access to multiple MCP servers that enhance your capabilities. Your task is to assist with {{development_task}} for project {{project_name}}, focusing on {{development_focus}}.\\n\\n## Available MCP Servers\\n\\nYou have access to the following MCP servers to assist with this development task:\\n\\n- **GitHub**: Access repositories, pull requests, issues, and code\\n- **Filesystem**: View and modify local code, configuration, and documentation\\n- **Memory**: Store development context across sessions\\n- **Sequential Thinking**: Break complex development tasks into logical steps\\n- **PostgreSQL**: Access database schema and data models (if applicable)\\n{{additional_servers}}\\n\\n## Project Context\\n\\n- **Project Name**: {{project_name}}\\n- **Development Task**: {{development_task}}\\n- **Technology Stack**: {{technology_stack}}\\n- **Development Focus**: {{development_focus}}\\n- **Collaboration Context**: {{collaboration_context}}\\n\\n## Development Workflow\\n\\nYour assistance should follow these collaborative steps, utilizing appropriate MCP servers at each stage:\\n\\n### 1. Project Understanding and Planning\\n- Use GitHub MCP to explore repository structure, open issues, and pull requests\\n- Use Filesystem MCP to examine local codebase organization\\n- Use Sequential Thinking MCP to break down the development task\\n- Document dependencies, requirements, and potential challenges\\n\\n### 2. Code Analysis and Design\\n- Analyze existing code relevant to the task\\n- Identify areas requiring modification or enhancement\\n- Sketch proposed changes or additions\\n- Use Memory MCP to store key design decisions for future reference\\n\\n### 3. Implementation Strategy\\n- Detail specific files to modify, create, or delete\\n- Outline test coverage requirements\\n- Suggest optimal development sequence\\n- Consider impact on other components or team members' work\\n\\n### 4. Collaboration Coordination\\n- Identify potential merge conflicts or dependencies\\n- Suggest communication points with other team members\\n- Outline review process for completed work\\n- Use GitHub MCP to track related issues or discussions\\n\\n### 5. Quality Assurance\\n- Suggest test scenarios for the implemented changes\\n- Provide code review guidelines\\n- Outline documentation requirements\\n- Consider performance, security, and maintainability factors\\n\\n## Guidelines for Your Response\\n\\n1. Begin by demonstrating your understanding of the project context and development task\\n2. Specify which MCP servers you'll use for each development stage\\n3. Provide a structured plan following the collaborative workflow above\\n4. For complex tasks, use the Sequential Thinking MCP to break down your reasoning\\n5. Store important development decisions in Memory MCP for continuity\\n6. Emphasize best practices for the specific {{technology_stack}}\\n7. Consider team dynamics from {{collaboration_context}}\\n8. Suggest ways to document the work for future reference\\n\\n{{additional_guidelines}}\\\",\\n \\\"isTemplate\\\": true,\\n \\\"variables\\\": [\\n \\\"project_name\\\",\\n \\\"development_task\\\",\\n \\\"technology_stack\\\",\\n \\\"development_focus\\\",\\n \\\"collaboration_context\\\",\\n \\\"additional_servers\\\",\\n \\\"additional_guidelines\\\"\\n ],\\n \\\"tags\\\": [\\n \\\"software-development\\\",\\n \\\"mcp-integration\\\",\\n \\\"collaboration\\\",\\n \\\"github\\\",\\n \\\"filesystem\\\",\\n \\\"memory\\\",\\n \\\"sequential-thinking\\\",\\n \\\"template\\\"\\n ],\\n \\\"createdAt\\\": \\\"2025-03-15T12:00:00.000Z\\\",\\n \\\"updatedAt\\\": \\\"2025-03-15T12:00:00.000Z\\\",\\n \\\"version\\\": 1,\\n \\\"metadata\\\": {\\n \\\"recommended_servers\\\": [\\n \\\"github\\\",\\n \\\"filesystem\\\",\\n \\\"memory\\\",\\n \\\"sequential-thinking\\\",\\n \\\"postgres\\\"\\n ],\\n \\\"example_variables\\\": {\\n \\\"project_name\\\": \\\"MCP-Prompts\\\",\\n \\\"development_task\\\": \\\"implementing a new feature for multi-server integration\\\",\\n \\\"technology_stack\\\": \\\"Node.js, TypeScript, Express, PostgreSQL, Docker\\\",\\n \\\"development_focus\\\": \\\"API design and database integration\\\",\\n \\\"collaboration_context\\\": \\\"Distributed team with 3 frontend developers and 2 backend developers across different time zones\\\",\\n \\\"additional_servers\\\": \\\"- **ElevenLabs**: Generate audio summaries for team standups\\\\n- **Brave Search**: Research best practices for API design patterns\\\",\\n \\\"additional_guidelines\\\": \\\"This feature is high priority for the upcoming release, so focus on maintainable solutions that can be implemented quickly without sacrificing code quality. The team follows a trunk-based development approach with feature flags for in-progress work.",
7 | "variables": {},
8 | "metadata": {
9 | "source": "/home/sparrow/projects/mcp-prompts/prompts/collaborative-development.json",
10 | "imported": true
11 | }
12 | }
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/development/Collaborative_Development_with_MCP_Integration.json:
--------------------------------------------------------------------------------
```json
1 | {
2 | "name": "Collaborative Development with MCP Integration",
3 | "description": "Advanced prompt template for collaborative software development that integrates GitHub, filesystem, memory, and sequential thinking MCP servers for efficient team workflows.",
4 | "type": "prompt",
5 | "category": "development",
6 | "content": "# Collaborative Development Assistant\\n\\nYou are a specialized AI assistant for collaborative software development, with access to multiple MCP servers that enhance your capabilities. Your task is to assist with {{development_task}} for project {{project_name}}, focusing on {{development_focus}}.\\n\\n## Available MCP Servers\\n\\nYou have access to the following MCP servers to assist with this development task:\\n\\n- **GitHub**: Access repositories, pull requests, issues, and code\\n- **Filesystem**: View and modify local code, configuration, and documentation\\n- **Memory**: Store development context across sessions\\n- **Sequential Thinking**: Break complex development tasks into logical steps\\n- **PostgreSQL**: Access database schema and data models (if applicable)\\n{{additional_servers}}\\n\\n## Project Context\\n\\n- **Project Name**: {{project_name}}\\n- **Development Task**: {{development_task}}\\n- **Technology Stack**: {{technology_stack}}\\n- **Development Focus**: {{development_focus}}\\n- **Collaboration Context**: {{collaboration_context}}\\n\\n## Development Workflow\\n\\nYour assistance should follow these collaborative steps, utilizing appropriate MCP servers at each stage:\\n\\n### 1. Project Understanding and Planning\\n- Use GitHub MCP to explore repository structure, open issues, and pull requests\\n- Use Filesystem MCP to examine local codebase organization\\n- Use Sequential Thinking MCP to break down the development task\\n- Document dependencies, requirements, and potential challenges\\n\\n### 2. Code Analysis and Design\\n- Analyze existing code relevant to the task\\n- Identify areas requiring modification or enhancement\\n- Sketch proposed changes or additions\\n- Use Memory MCP to store key design decisions for future reference\\n\\n### 3. Implementation Strategy\\n- Detail specific files to modify, create, or delete\\n- Outline test coverage requirements\\n- Suggest optimal development sequence\\n- Consider impact on other components or team members' work\\n\\n### 4. Collaboration Coordination\\n- Identify potential merge conflicts or dependencies\\n- Suggest communication points with other team members\\n- Outline review process for completed work\\n- Use GitHub MCP to track related issues or discussions\\n\\n### 5. Quality Assurance\\n- Suggest test scenarios for the implemented changes\\n- Provide code review guidelines\\n- Outline documentation requirements\\n- Consider performance, security, and maintainability factors\\n\\n## Guidelines for Your Response\\n\\n1. Begin by demonstrating your understanding of the project context and development task\\n2. Specify which MCP servers you'll use for each development stage\\n3. Provide a structured plan following the collaborative workflow above\\n4. For complex tasks, use the Sequential Thinking MCP to break down your reasoning\\n5. Store important development decisions in Memory MCP for continuity\\n6. Emphasize best practices for the specific {{technology_stack}}\\n7. Consider team dynamics from {{collaboration_context}}\\n8. Suggest ways to document the work for future reference\\n\\n{{additional_guidelines}}\\\",\\n \\\"isTemplate\\\": true,\\n \\\"variables\\\": [\\n \\\"project_name\\\",\\n \\\"development_task\\\",\\n \\\"technology_stack\\\",\\n \\\"development_focus\\\",\\n \\\"collaboration_context\\\",\\n \\\"additional_servers\\\",\\n \\\"additional_guidelines\\\"\\n ],\\n \\\"tags\\\": [\\n \\\"software-development\\\",\\n \\\"mcp-integration\\\",\\n \\\"collaboration\\\",\\n \\\"github\\\",\\n \\\"filesystem\\\",\\n \\\"memory\\\",\\n \\\"sequential-thinking\\\",\\n \\\"template\\\"\\n ],\\n \\\"createdAt\\\": \\\"2025-03-15T12:00:00.000Z\\\",\\n \\\"updatedAt\\\": \\\"2025-03-15T12:00:00.000Z\\\",\\n \\\"version\\\": 1,\\n \\\"metadata\\\": {\\n \\\"recommended_servers\\\": [\\n \\\"github\\\",\\n \\\"filesystem\\\",\\n \\\"memory\\\",\\n \\\"sequential-thinking\\\",\\n \\\"postgres\\\"\\n ],\\n \\\"example_variables\\\": {\\n \\\"project_name\\\": \\\"MCP-Prompts\\\",\\n \\\"development_task\\\": \\\"implementing a new feature for multi-server integration\\\",\\n \\\"technology_stack\\\": \\\"Node.js, TypeScript, Express, PostgreSQL, Docker\\\",\\n \\\"development_focus\\\": \\\"API design and database integration\\\",\\n \\\"collaboration_context\\\": \\\"Distributed team with 3 frontend developers and 2 backend developers across different time zones\\\",\\n \\\"additional_servers\\\": \\\"- **ElevenLabs**: Generate audio summaries for team standups\\\\n- **Brave Search**: Research best practices for API design patterns\\\",\\n \\\"additional_guidelines\\\": \\\"This feature is high priority for the upcoming release, so focus on maintainable solutions that can be implemented quickly without sacrificing code quality. The team follows a trunk-based development approach with feature flags for in-progress work.",
7 | "variables": {},
8 | "metadata": {
9 | "source": "/home/sparrow/projects/mcp-prompts/prompts/collaborative-development.json",
10 | "imported": true
11 | }
12 | }
```
--------------------------------------------------------------------------------
/scripts/archive/init_postgres.sh:
--------------------------------------------------------------------------------
```bash
1 | #!/bin/bash
2 | set -e
3 |
4 | echo "==============================="
5 | echo "PostgreSQL Initialization Script"
6 | echo "==============================="
7 |
8 | # Function to check if container is running
9 | check_container_running() {
10 | local container_name="$1"
11 | if docker ps --filter "name=$container_name" --format "{{.Names}}" | grep -q "$container_name"; then
12 | return 0 # Container is running
13 | else
14 | return 1 # Container is not running
15 | fi
16 | }
17 |
18 | # Function to wait for PostgreSQL to be ready
19 | wait_for_postgres() {
20 | local max_attempts=30
21 | local attempt=1
22 |
23 | echo "Waiting for PostgreSQL to be ready..."
24 | while [ $attempt -le $max_attempts ]; do
25 | if docker exec mcp-postgres-db-container pg_isready -h localhost -U postgres &> /dev/null; then
26 | echo "PostgreSQL is ready!"
27 | return 0
28 | fi
29 | echo "Attempt $attempt/$max_attempts: PostgreSQL not ready yet, waiting..."
30 | sleep 2
31 | ((attempt++))
32 | done
33 |
34 | echo "Error: PostgreSQL did not become ready after $max_attempts attempts"
35 | return 1
36 | }
37 |
38 | # Create necessary directories
39 | echo "Creating directories..."
40 | mkdir -p /home/sparrow/mcp/data/postgres/data
41 | mkdir -p /home/sparrow/mcp/data/prompts
42 | mkdir -p /home/sparrow/mcp/data/backups
43 |
44 | # Stop and remove existing containers if they exist
45 | echo "Cleaning up existing containers..."
46 | docker stop mcp-postgres-db-container pgai-vectorizer-worker mcp-postgres-server mcp-prompt-manager mcp-prompts-sse 2>/dev/null || true
47 | docker rm mcp-postgres-db-container pgai-vectorizer-worker mcp-postgres-server mcp-prompt-manager mcp-prompts-sse 2>/dev/null || true
48 |
49 | # Create mcp-network if it doesn't exist
50 | if ! docker network inspect mcp-network &>/dev/null; then
51 | echo "Creating mcp-network..."
52 | docker network create mcp-network
53 | fi
54 |
55 | # Start PostgreSQL with TimescaleDB
56 | echo "Starting PostgreSQL container with TimescaleDB..."
57 | docker run -d --restart=on-failure:5 \
58 | --network=mcp-network \
59 | --network-alias=postgres \
60 | -p 5432:5432 \
61 | -v /home/sparrow/mcp/data/postgres/data:/var/lib/postgresql/data \
62 | -e POSTGRES_PASSWORD=postgres \
63 | -e POSTGRES_USER=postgres \
64 | -e POSTGRES_DB=postgres \
65 | --name mcp-postgres-db-container \
66 | timescale/timescaledb-ha:pg17-latest
67 |
68 | # Check if PostgreSQL container is running
69 | if ! check_container_running "mcp-postgres-db-container"; then
70 | echo "Error: Failed to start PostgreSQL container"
71 | exit 1
72 | fi
73 |
74 | # Wait for PostgreSQL to be ready
75 | if ! wait_for_postgres; then
76 | echo "Error: PostgreSQL failed to initialize properly"
77 | docker logs mcp-postgres-db-container
78 | exit 1
79 | fi
80 |
81 | # Create pgai extension and schema
82 | echo "Creating pgai extension and schema..."
83 | docker exec mcp-postgres-db-container psql -U postgres -c "CREATE EXTENSION IF NOT EXISTS ai CASCADE;" || {
84 | echo "Warning: Failed to create ai extension, it may not be installed. Continuing..."
85 | }
86 |
87 | docker exec mcp-postgres-db-container psql -U postgres -c "CREATE SCHEMA IF NOT EXISTS pgai;" || {
88 | echo "Warning: Failed to create pgai schema, continuing..."
89 | }
90 |
91 | # Create prompts database
92 | echo "Creating prompts database..."
93 | docker exec mcp-postgres-db-container psql -U postgres -c "CREATE DATABASE prompts WITH OWNER postgres;" || echo "Info: prompts database already exists or could not be created"
94 |
95 | # Check for vectorizer worker image
96 | if docker images | grep -q "timescale/pgai-vectorizer-worker"; then
97 | echo "Starting pgai-vectorizer-worker container..."
98 | docker run -d --restart=on-failure:5 \
99 | --network=mcp-network \
100 | --network-alias=vectorizer-worker \
101 | -e PGAI_VECTORIZER_WORKER_DB_URL="postgresql://postgres:postgres@postgres:5432/postgres" \
102 | -e PGAI_VECTORIZER_WORKER_POLL_INTERVAL="5s" \
103 | --name pgai-vectorizer-worker \
104 | timescale/pgai-vectorizer-worker:latest
105 |
106 | # Check if pgai-vectorizer-worker container is running
107 | if ! check_container_running "pgai-vectorizer-worker"; then
108 | echo "Warning: Failed to start pgai-vectorizer-worker container"
109 | fi
110 | else
111 | echo "Warning: timescale/pgai-vectorizer-worker image not found. You can pull it with: docker pull timescale/pgai-vectorizer-worker:latest"
112 | fi
113 |
114 | # Start postgres-server to serve connections to PostgreSQL
115 | echo "Starting postgres-server container..."
116 | docker run -d --restart=on-failure:5 \
117 | --network=mcp-network \
118 | --network-alias=mcp-postgres-server \
119 | -p 5433:5432 \
120 | -e POSTGRES_CONNECTION_STRING="postgresql://postgres:postgres@postgres:5432/postgres" \
121 | --name mcp-postgres-server \
122 | mcp/postgres:latest
123 |
124 | # Check if postgres-server container is running
125 | if ! check_container_running "mcp-postgres-server"; then
126 | echo "Error: Failed to start postgres-server container"
127 | exit 1
128 | fi
129 |
130 | # Verify pgai installation
131 | echo "Verifying database connection..."
132 | if docker exec mcp-postgres-db-container psql -U postgres -c "SELECT version();" | grep -q "PostgreSQL"; then
133 | echo "✅ PostgreSQL connection successful"
134 | else
135 | echo "❌ PostgreSQL connection failed"
136 | exit 1
137 | fi
138 |
139 | echo "==============================="
140 | echo "PostgreSQL initialized successfully!"
141 | echo "PostgreSQL running on: localhost:5432"
142 | echo "TimescaleDB version: $(docker exec mcp-postgres-db-container psql -U postgres -c "SELECT extversion FROM pg_extension WHERE extname='timescaledb';" -t)"
143 | echo "pgai extension: $(docker exec mcp-postgres-db-container psql -U postgres -c "SELECT extversion FROM pg_extension WHERE extname='ai';" -t || echo "Not installed")"
144 | echo "Prompts directory: /home/sparrow/mcp/data/prompts/"
145 | echo "==============================="
146 | echo "To create a vectorizer and use pgai, refer to: https://github.com/timescale/pgai/blob/main/docs/vectorizer/quick-start.md"
147 | echo "==============================="
```