This is page 5 of 21. Use http://codebase.md/sparesparrow/mcp-project-orchestrator?lines=false&page={x} to view the full context.
# Directory Structure
```
├── .cursorrules
├── .env.example
├── .github
│ └── workflows
│ ├── build.yml
│ ├── ci-cd.yml
│ ├── ci.yml
│ ├── deploy.yml
│ ├── ecosystem-monitor.yml
│ ├── fan-out-orchestrator.yml
│ └── release.yml
├── .gitignore
├── .pre-commit-config.yaml
├── AUTOMOTIVE_CAMERA_SYSTEM_SUMMARY.md
├── automotive-camera-system
│ ├── docs
│ │ └── IMPLEMENTACE_CS.md
│ └── README.md
├── AWS_MCP_IMPLEMENTATION_SUMMARY.md
├── AWS_MCP_QUICKSTART.md
├── AWS_SIP_TRUNK_DEPLOYMENT_COMPLETE.md
├── aws-sip-trunk
│ ├── .gitignore
│ ├── config
│ │ ├── extensions.conf.j2
│ │ └── pjsip.conf.j2
│ ├── DEPLOYMENT_SUMMARY.md
│ ├── docs
│ │ ├── DEPLOYMENT.md
│ │ └── TROUBLESHOOTING.md
│ ├── PROJECT_INDEX.md
│ ├── pyproject.toml
│ ├── QUICKSTART.md
│ ├── README.md
│ ├── scripts
│ │ ├── deploy-asterisk-aws.sh
│ │ └── user-data.sh
│ ├── terraform
│ │ ├── ec2.tf
│ │ ├── main.tf
│ │ ├── monitoring.tf
│ │ ├── networking.tf
│ │ ├── outputs.tf
│ │ ├── storage.tf
│ │ ├── terraform.tfvars.example
│ │ └── variables.tf
│ ├── tests
│ │ └── test_sip_connectivity.py
│ └── VERIFICATION_CHECKLIST.md
├── CLAUDE.md
├── component_templates.json
├── conanfile.py
├── config
│ ├── default.json
│ └── project_orchestration.json
├── Containerfile
├── cursor-templates
│ └── openssl
│ ├── linux-dev.mdc.jinja2
│ └── shared.mdc.jinja2
├── data
│ └── prompts
│ └── templates
│ ├── advanced-multi-server-template.json
│ ├── analysis-assistant.json
│ ├── analyze-mermaid-diagram.json
│ ├── architecture-design-assistant.json
│ ├── code-diagram-documentation-creator.json
│ ├── code-refactoring-assistant.json
│ ├── code-review-assistant.json
│ ├── collaborative-development.json
│ ├── consolidated-interfaces-template.json
│ ├── could-you-interpret-the-assumed-applicat.json
│ ├── data-analysis-template.json
│ ├── database-query-assistant.json
│ ├── debugging-assistant.json
│ ├── development-system-prompt-zcna0.json
│ ├── development-system-prompt.json
│ ├── development-workflow.json
│ ├── docker-compose-prompt-combiner.json
│ ├── docker-containerization-guide.json
│ ├── docker-mcp-servers-orchestration.json
│ ├── foresight-assistant.json
│ ├── generate-different-types-of-questions-ab.json
│ ├── generate-mermaid-diagram.json
│ ├── image-1-describe-the-icon-in-one-sen.json
│ ├── initialize-project-setup-for-a-new-micro.json
│ ├── install-dependencies-build-run-test.json
│ ├── mcp-code-generator.json
│ ├── mcp-integration-assistant.json
│ ├── mcp-resources-explorer.json
│ ├── mcp-resources-integration.json
│ ├── mcp-server-configurator.json
│ ├── mcp-server-dev-prompt-combiner.json
│ ├── mcp-server-integration-template.json
│ ├── mcp-template-system.json
│ ├── mermaid-analysis-expert.json
│ ├── mermaid-class-diagram-generator.json
│ ├── mermaid-diagram-generator.json
│ ├── mermaid-diagram-modifier.json
│ ├── modify-mermaid-diagram.json
│ ├── monorepo-migration-guide.json
│ ├── multi-resource-context.json
│ ├── project-analysis-assistant.json
│ ├── prompt-combiner-interface.json
│ ├── prompt-templates.json
│ ├── repository-explorer.json
│ ├── research-assistant.json
│ ├── sequential-data-analysis.json
│ ├── solid-code-analysis-visualizer.json
│ ├── task-list-helper-8ithy.json
│ ├── template-based-mcp-integration.json
│ ├── templates.json
│ ├── test-prompt.json
│ └── you-are-limited-to-respond-yes-or-no-onl.json
├── docs
│ ├── AWS_MCP.md
│ ├── AWS.md
│ ├── CONAN.md
│ └── integration.md
├── elevenlabs-agents
│ ├── agent-prompts.json
│ └── README.md
├── IMPLEMENTATION_STATUS.md
├── integration_plan.md
├── LICENSE
├── MANIFEST.in
├── mcp-project-orchestrator
│ └── openssl
│ ├── .github
│ │ └── workflows
│ │ └── validate-cursor-config.yml
│ ├── conanfile.py
│ ├── CURSOR_DEPLOYMENT_POLISH.md
│ ├── cursor-rules
│ │ ├── mcp.json.jinja2
│ │ ├── prompts
│ │ │ ├── fips-compliance.md.jinja2
│ │ │ ├── openssl-coding-standards.md.jinja2
│ │ │ └── pr-review.md.jinja2
│ │ └── rules
│ │ ├── ci-linux.mdc.jinja2
│ │ ├── linux-dev.mdc.jinja2
│ │ ├── macos-dev.mdc.jinja2
│ │ ├── shared.mdc.jinja2
│ │ └── windows-dev.mdc.jinja2
│ ├── docs
│ │ └── cursor-configuration-management.md
│ ├── examples
│ │ └── example-workspace
│ │ ├── .cursor
│ │ │ ├── mcp.json
│ │ │ └── rules
│ │ │ ├── linux-dev.mdc
│ │ │ └── shared.mdc
│ │ ├── .gitignore
│ │ ├── CMakeLists.txt
│ │ ├── conanfile.py
│ │ ├── profiles
│ │ │ ├── linux-gcc-debug.profile
│ │ │ └── linux-gcc-release.profile
│ │ ├── README.md
│ │ └── src
│ │ ├── crypto_utils.cpp
│ │ ├── crypto_utils.h
│ │ └── main.cpp
│ ├── IMPLEMENTATION_SUMMARY.md
│ ├── mcp_orchestrator
│ │ ├── __init__.py
│ │ ├── cli.py
│ │ ├── conan_integration.py
│ │ ├── cursor_config.py
│ │ ├── cursor_deployer.py
│ │ ├── deploy_cursor.py
│ │ ├── env_config.py
│ │ ├── platform_detector.py
│ │ └── yaml_validator.py
│ ├── openssl-cursor-example-workspace-20251014_121133.zip
│ ├── pyproject.toml
│ ├── README.md
│ ├── requirements.txt
│ ├── scripts
│ │ └── create_example_workspace.py
│ ├── setup.py
│ ├── test_deployment.py
│ └── tests
│ ├── __init__.py
│ ├── test_cursor_deployer.py
│ └── test_template_validation.py
├── printcast-agent
│ ├── .env.example
│ ├── config
│ │ └── asterisk
│ │ └── extensions.conf
│ ├── Containerfile
│ ├── docker-compose.yml
│ ├── pyproject.toml
│ ├── README.md
│ ├── scripts
│ │ └── docker-entrypoint.sh
│ ├── src
│ │ ├── integrations
│ │ │ ├── __init__.py
│ │ │ ├── asterisk.py
│ │ │ ├── content.py
│ │ │ ├── delivery.py
│ │ │ ├── elevenlabs.py
│ │ │ └── printing.py
│ │ ├── mcp_server
│ │ │ ├── __init__.py
│ │ │ ├── main.py
│ │ │ └── server.py
│ │ └── orchestration
│ │ ├── __init__.py
│ │ └── workflow.py
│ └── tests
│ └── test_mcp_server.py
├── project_orchestration.json
├── project_templates.json
├── pyproject.toml
├── README.md
├── REFACTORING_COMPLETED.md
├── REFACTORING_RECOMMENDATIONS.md
├── requirements.txt
├── scripts
│ ├── archive
│ │ ├── init_claude_test.sh
│ │ ├── init_postgres.sh
│ │ ├── start_mcp_servers.sh
│ │ └── test_claude_desktop.sh
│ ├── consolidate_mermaid.py
│ ├── consolidate_prompts.py
│ ├── consolidate_resources.py
│ ├── consolidate_templates.py
│ ├── INSTRUCTIONS.md
│ ├── README.md
│ ├── setup_aws_mcp.sh
│ ├── setup_mcp.sh
│ ├── setup_orchestrator.sh
│ ├── setup_project.py
│ └── test_mcp.sh
├── src
│ └── mcp_project_orchestrator
│ ├── __init__.py
│ ├── __main__.py
│ ├── aws_mcp.py
│ ├── cli
│ │ └── __init__.py
│ ├── cli.py
│ ├── commands
│ │ └── openssl_cli.py
│ ├── core
│ │ ├── __init__.py
│ │ ├── base.py
│ │ ├── config.py
│ │ ├── exceptions.py
│ │ ├── fastmcp.py
│ │ ├── logging.py
│ │ └── managers.py
│ ├── cursor_deployer.py
│ ├── ecosystem_monitor.py
│ ├── fan_out_orchestrator.py
│ ├── fastmcp.py
│ ├── mcp-py
│ │ ├── AggregateVersions.py
│ │ ├── CustomBashTool.py
│ │ ├── FileAnnotator.py
│ │ ├── mcp-client.py
│ │ ├── mcp-server.py
│ │ ├── MermaidDiagramGenerator.py
│ │ ├── NamingAgent.py
│ │ └── solid-analyzer-agent.py
│ ├── mermaid
│ │ ├── __init__.py
│ │ ├── generator.py
│ │ ├── mermaid_orchestrator.py
│ │ ├── renderer.py
│ │ ├── templates
│ │ │ ├── AbstractFactory-diagram.json
│ │ │ ├── Adapter-diagram.json
│ │ │ ├── Analyze_Mermaid_Diagram.json
│ │ │ ├── Builder-diagram.json
│ │ │ ├── Chain-diagram.json
│ │ │ ├── Code_Diagram_Documentation_Creator.json
│ │ │ ├── Command-diagram.json
│ │ │ ├── Decorator-diagram.json
│ │ │ ├── Facade-diagram.json
│ │ │ ├── Factory-diagram.json
│ │ │ ├── flowchart
│ │ │ │ ├── AbstractFactory-diagram.json
│ │ │ │ ├── Adapter-diagram.json
│ │ │ │ ├── Analyze_Mermaid_Diagram.json
│ │ │ │ ├── Builder-diagram.json
│ │ │ │ ├── Chain-diagram.json
│ │ │ │ ├── Code_Diagram_Documentation_Creator.json
│ │ │ │ ├── Command-diagram.json
│ │ │ │ ├── Decorator-diagram.json
│ │ │ │ ├── Facade-diagram.json
│ │ │ │ ├── Factory-diagram.json
│ │ │ │ ├── Generate_Mermaid_Diagram.json
│ │ │ │ ├── generated_diagram.json
│ │ │ │ ├── integration.json
│ │ │ │ ├── Iterator-diagram.json
│ │ │ │ ├── Mediator-diagram.json
│ │ │ │ ├── Memento-diagram.json
│ │ │ │ ├── Mermaid_Analysis_Expert.json
│ │ │ │ ├── Mermaid_Class_Diagram_Generator.json
│ │ │ │ ├── Mermaid_Diagram_Generator.json
│ │ │ │ ├── Mermaid_Diagram_Modifier.json
│ │ │ │ ├── Modify_Mermaid_Diagram.json
│ │ │ │ ├── Observer-diagram.json
│ │ │ │ ├── Prototype-diagram.json
│ │ │ │ ├── Proxy-diagram.json
│ │ │ │ ├── README.json
│ │ │ │ ├── Singleton-diagram.json
│ │ │ │ ├── State-diagram.json
│ │ │ │ ├── Strategy-diagram.json
│ │ │ │ ├── TemplateMethod-diagram.json
│ │ │ │ ├── theme_dark.json
│ │ │ │ ├── theme_default.json
│ │ │ │ ├── theme_pastel.json
│ │ │ │ ├── theme_vibrant.json
│ │ │ │ └── Visitor-diagram.json
│ │ │ ├── Generate_Mermaid_Diagram.json
│ │ │ ├── generated_diagram.json
│ │ │ ├── index.json
│ │ │ ├── integration.json
│ │ │ ├── Iterator-diagram.json
│ │ │ ├── Mediator-diagram.json
│ │ │ ├── Memento-diagram.json
│ │ │ ├── Mermaid_Analysis_Expert.json
│ │ │ ├── Mermaid_Class_Diagram_Generator.json
│ │ │ ├── Mermaid_Diagram_Generator.json
│ │ │ ├── Mermaid_Diagram_Modifier.json
│ │ │ ├── Modify_Mermaid_Diagram.json
│ │ │ ├── Observer-diagram.json
│ │ │ ├── Prototype-diagram.json
│ │ │ ├── Proxy-diagram.json
│ │ │ ├── README.json
│ │ │ ├── Singleton-diagram.json
│ │ │ ├── State-diagram.json
│ │ │ ├── Strategy-diagram.json
│ │ │ ├── TemplateMethod-diagram.json
│ │ │ ├── theme_dark.json
│ │ │ ├── theme_default.json
│ │ │ ├── theme_pastel.json
│ │ │ ├── theme_vibrant.json
│ │ │ └── Visitor-diagram.json
│ │ └── types.py
│ ├── project_orchestration.py
│ ├── prompt_manager
│ │ ├── __init__.py
│ │ ├── loader.py
│ │ ├── manager.py
│ │ └── template.py
│ ├── prompts
│ │ ├── __dirname.json
│ │ ├── __image_1___describe_the_icon_in_one_sen___.json
│ │ ├── __init__.py
│ │ ├── __type.json
│ │ ├── _.json
│ │ ├── _DEFAULT_OPEN_DELIMITER.json
│ │ ├── _emojiRegex.json
│ │ ├── _UUID_CHARS.json
│ │ ├── a.json
│ │ ├── A.json
│ │ ├── Aa.json
│ │ ├── aAnnotationPadding.json
│ │ ├── absoluteThresholdGroup.json
│ │ ├── add.json
│ │ ├── ADDITIONAL_PROPERTY_FLAG.json
│ │ ├── Advanced_Multi-Server_Integration_Template.json
│ │ ├── allOptionsList.json
│ │ ├── analysis
│ │ │ ├── Data_Analysis_Template.json
│ │ │ ├── index.json
│ │ │ ├── Mermaid_Analysis_Expert.json
│ │ │ ├── Sequential_Data_Analysis_with_MCP_Integration.json
│ │ │ └── SOLID_Code_Analysis_Visualizer.json
│ │ ├── Analysis_Assistant.json
│ │ ├── Analyze_Mermaid_Diagram.json
│ │ ├── ANDROID_EVERGREEN_FIRST.json
│ │ ├── ANSI_ESCAPE_BELL.json
│ │ ├── architecture
│ │ │ ├── index.json
│ │ │ └── PromptCombiner_Interface.json
│ │ ├── Architecture_Design_Assistant.json
│ │ ├── argsTag.json
│ │ ├── ARROW.json
│ │ ├── assistant
│ │ │ ├── Analysis_Assistant.json
│ │ │ ├── Architecture_Design_Assistant.json
│ │ │ ├── Code_Refactoring_Assistant.json
│ │ │ ├── Code_Review_Assistant.json
│ │ │ ├── Database_Query_Assistant.json
│ │ │ ├── Debugging_Assistant.json
│ │ │ ├── Foresight_Assistant.json
│ │ │ ├── index.json
│ │ │ ├── MCP_Integration_Assistant.json
│ │ │ ├── Project_Analysis_Assistant.json
│ │ │ └── Research_Assistant.json
│ │ ├── astralRange.json
│ │ ├── at.json
│ │ ├── authorization_endpoint.json
│ │ ├── b.json
│ │ ├── BABELIGNORE_FILENAME.json
│ │ ├── BACKSLASH.json
│ │ ├── backupId.json
│ │ ├── BANG.json
│ │ ├── BASE64_MAP.json
│ │ ├── baseFlags.json
│ │ ├── Basic_Template.json
│ │ ├── bgModel.json
│ │ ├── bignum.json
│ │ ├── blockKeywordsStr.json
│ │ ├── BOMChar.json
│ │ ├── boundary.json
│ │ ├── brackets.json
│ │ ├── BROWSER_VAR.json
│ │ ├── bt.json
│ │ ├── BUILTIN.json
│ │ ├── BULLET.json
│ │ ├── c.json
│ │ ├── C.json
│ │ ├── CACHE_VERSION.json
│ │ ├── cacheControl.json
│ │ ├── cacheProp.json
│ │ ├── category.py
│ │ ├── CHANGE_EVENT.json
│ │ ├── CHAR_CODE_0.json
│ │ ├── chars.json
│ │ ├── cjsPattern.json
│ │ ├── cKeywords.json
│ │ ├── classForPercent.json
│ │ ├── classStr.json
│ │ ├── clientFirstMessageBare.json
│ │ ├── cmd.json
│ │ ├── Code_Diagram_Documentation_Creator.json
│ │ ├── Code_Refactoring_Assistant.json
│ │ ├── Code_Review_Assistant.json
│ │ ├── code.json
│ │ ├── coding
│ │ │ ├── __dirname.json
│ │ │ ├── _.json
│ │ │ ├── _DEFAULT_OPEN_DELIMITER.json
│ │ │ ├── _emojiRegex.json
│ │ │ ├── _UUID_CHARS.json
│ │ │ ├── a.json
│ │ │ ├── A.json
│ │ │ ├── aAnnotationPadding.json
│ │ │ ├── absoluteThresholdGroup.json
│ │ │ ├── add.json
│ │ │ ├── ADDITIONAL_PROPERTY_FLAG.json
│ │ │ ├── allOptionsList.json
│ │ │ ├── ANDROID_EVERGREEN_FIRST.json
│ │ │ ├── ANSI_ESCAPE_BELL.json
│ │ │ ├── argsTag.json
│ │ │ ├── ARROW.json
│ │ │ ├── astralRange.json
│ │ │ ├── at.json
│ │ │ ├── authorization_endpoint.json
│ │ │ ├── BABELIGNORE_FILENAME.json
│ │ │ ├── BACKSLASH.json
│ │ │ ├── BANG.json
│ │ │ ├── BASE64_MAP.json
│ │ │ ├── baseFlags.json
│ │ │ ├── bgModel.json
│ │ │ ├── bignum.json
│ │ │ ├── blockKeywordsStr.json
│ │ │ ├── BOMChar.json
│ │ │ ├── boundary.json
│ │ │ ├── brackets.json
│ │ │ ├── BROWSER_VAR.json
│ │ │ ├── bt.json
│ │ │ ├── BUILTIN.json
│ │ │ ├── BULLET.json
│ │ │ ├── c.json
│ │ │ ├── C.json
│ │ │ ├── CACHE_VERSION.json
│ │ │ ├── cacheControl.json
│ │ │ ├── cacheProp.json
│ │ │ ├── CHANGE_EVENT.json
│ │ │ ├── CHAR_CODE_0.json
│ │ │ ├── chars.json
│ │ │ ├── cjsPattern.json
│ │ │ ├── cKeywords.json
│ │ │ ├── classForPercent.json
│ │ │ ├── classStr.json
│ │ │ ├── clientFirstMessageBare.json
│ │ │ ├── cmd.json
│ │ │ ├── code.json
│ │ │ ├── colorCode.json
│ │ │ ├── comma.json
│ │ │ ├── command.json
│ │ │ ├── configJsContent.json
│ │ │ ├── connectionString.json
│ │ │ ├── cssClassStr.json
│ │ │ ├── currentBoundaryParse.json
│ │ │ ├── d.json
│ │ │ ├── data.json
│ │ │ ├── DATA.json
│ │ │ ├── dataWebpackPrefix.json
│ │ │ ├── debug.json
│ │ │ ├── decodeStateVectorV2.json
│ │ │ ├── DEFAULT_DELIMITER.json
│ │ │ ├── DEFAULT_DIAGRAM_DIRECTION.json
│ │ │ ├── DEFAULT_JS_PATTERN.json
│ │ │ ├── DEFAULT_LOG_TARGET.json
│ │ │ ├── defaultHelpOpt.json
│ │ │ ├── defaultHost.json
│ │ │ ├── deferY18nLookupPrefix.json
│ │ │ ├── DELIM.json
│ │ │ ├── delimiter.json
│ │ │ ├── DEPRECATION.json
│ │ │ ├── destMain.json
│ │ │ ├── DID_NOT_THROW.json
│ │ │ ├── direction.json
│ │ │ ├── displayValue.json
│ │ │ ├── DNS.json
│ │ │ ├── doc.json
│ │ │ ├── DOCUMENTATION_NOTE.json
│ │ │ ├── DOT.json
│ │ │ ├── DOTS.json
│ │ │ ├── dummyCompoundId.json
│ │ │ ├── e.json
│ │ │ ├── E.json
│ │ │ ├── earlyHintsLink.json
│ │ │ ├── elide.json
│ │ │ ├── EMPTY.json
│ │ │ ├── end.json
│ │ │ ├── endpoint.json
│ │ │ ├── environment.json
│ │ │ ├── ERR_CODE.json
│ │ │ ├── errMessage.json
│ │ │ ├── errMsg.json
│ │ │ ├── ERROR_MESSAGE.json
│ │ │ ├── error.json
│ │ │ ├── ERROR.json
│ │ │ ├── ERRORCLASS.json
│ │ │ ├── errorMessage.json
│ │ │ ├── es6Default.json
│ │ │ ├── ESC.json
│ │ │ ├── Escapable.json
│ │ │ ├── escapedChar.json
│ │ │ ├── escapeFuncStr.json
│ │ │ ├── escSlash.json
│ │ │ ├── ev.json
│ │ │ ├── event.json
│ │ │ ├── execaMessage.json
│ │ │ ├── EXPECTED_LABEL.json
│ │ │ ├── expected.json
│ │ │ ├── expectedString.json
│ │ │ ├── expression1.json
│ │ │ ├── EXTENSION.json
│ │ │ ├── f.json
│ │ │ ├── FAIL_TEXT.json
│ │ │ ├── FILE_BROWSER_FACTORY.json
│ │ │ ├── fill.json
│ │ │ ├── findPackageJson.json
│ │ │ ├── fnKey.json
│ │ │ ├── FORMAT.json
│ │ │ ├── formatted.json
│ │ │ ├── from.json
│ │ │ ├── fullpaths.json
│ │ │ ├── FUNC_ERROR_TEXT.json
│ │ │ ├── GenStateSuspendedStart.json
│ │ │ ├── GENSYNC_EXPECTED_START.json
│ │ │ ├── gutter.json
│ │ │ ├── h.json
│ │ │ ├── handlerFuncName.json
│ │ │ ├── HASH_UNDEFINED.json
│ │ │ ├── head.json
│ │ │ ├── helpMessage.json
│ │ │ ├── HINT_ARG.json
│ │ │ ├── HOOK_RETURNED_NOTHING_ERROR_MESSAGE.json
│ │ │ ├── i.json
│ │ │ ├── id.json
│ │ │ ├── identifier.json
│ │ │ ├── Identifier.json
│ │ │ ├── INDENT.json
│ │ │ ├── indentation.json
│ │ │ ├── index.json
│ │ │ ├── INDIRECTION_FRAGMENT.json
│ │ │ ├── input.json
│ │ │ ├── inputText.json
│ │ │ ├── insert.json
│ │ │ ├── insertPromptQuery.json
│ │ │ ├── INSPECT_MAX_BYTES.json
│ │ │ ├── intToCharMap.json
│ │ │ ├── IS_ITERABLE_SENTINEL.json
│ │ │ ├── IS_KEYED_SENTINEL.json
│ │ │ ├── isConfigType.json
│ │ │ ├── isoSentinel.json
│ │ │ ├── isSourceNode.json
│ │ │ ├── j.json
│ │ │ ├── JAKE_CMD.json
│ │ │ ├── JEST_GLOBAL_NAME.json
│ │ │ ├── JEST_GLOBALS_MODULE_NAME.json
│ │ │ ├── JSON_SYNTAX_CHAR.json
│ │ │ ├── json.json
│ │ │ ├── jsonType.json
│ │ │ ├── jupyter_namespaceObject.json
│ │ │ ├── JUPYTERLAB_DOCMANAGER_PLUGIN_ID.json
│ │ │ ├── k.json
│ │ │ ├── KERNEL_STATUS_ERROR_CLASS.json
│ │ │ ├── key.json
│ │ │ ├── l.json
│ │ │ ├── labelId.json
│ │ │ ├── LATEST_PROTOCOL_VERSION.json
│ │ │ ├── LETTERDASHNUMBER.json
│ │ │ ├── LF.json
│ │ │ ├── LIMIT_REPLACE_NODE.json
│ │ │ ├── logTime.json
│ │ │ ├── lstatkey.json
│ │ │ ├── lt.json
│ │ │ ├── m.json
│ │ │ ├── maliciousPayload.json
│ │ │ ├── mask.json
│ │ │ ├── match.json
│ │ │ ├── matchingDelim.json
│ │ │ ├── MAXIMUM_MESSAGE_SIZE.json
│ │ │ ├── mdcContent.json
│ │ │ ├── MERMAID_DOM_ID_PREFIX.json
│ │ │ ├── message.json
│ │ │ ├── messages.json
│ │ │ ├── meth.json
│ │ │ ├── minimatch.json
│ │ │ ├── MOCK_CONSTRUCTOR_NAME.json
│ │ │ ├── MOCKS_PATTERN.json
│ │ │ ├── moduleDirectory.json
│ │ │ ├── msg.json
│ │ │ ├── mtr.json
│ │ │ ├── multipartType.json
│ │ │ ├── n.json
│ │ │ ├── N.json
│ │ │ ├── name.json
│ │ │ ├── NATIVE_PLATFORM.json
│ │ │ ├── newUrl.json
│ │ │ ├── NM.json
│ │ │ ├── NO_ARGUMENTS.json
│ │ │ ├── NO_DIFF_MESSAGE.json
│ │ │ ├── NODE_MODULES.json
│ │ │ ├── nodeInternalPrefix.json
│ │ │ ├── nonASCIIidentifierStartChars.json
│ │ │ ├── nonKey.json
│ │ │ ├── NOT_A_DOT.json
│ │ │ ├── notCharacterOrDash.json
│ │ │ ├── notebookURL.json
│ │ │ ├── notSelector.json
│ │ │ ├── nullTag.json
│ │ │ ├── num.json
│ │ │ ├── NUMBER.json
│ │ │ ├── o.json
│ │ │ ├── O.json
│ │ │ ├── octChar.json
│ │ │ ├── octetStreamType.json
│ │ │ ├── operators.json
│ │ │ ├── out.json
│ │ │ ├── OUTSIDE_JEST_VM_PROTOCOL.json
│ │ │ ├── override.json
│ │ │ ├── p.json
│ │ │ ├── PACKAGE_FILENAME.json
│ │ │ ├── PACKAGE_JSON.json
│ │ │ ├── packageVersion.json
│ │ │ ├── paddedNumber.json
│ │ │ ├── page.json
│ │ │ ├── parseClass.json
│ │ │ ├── path.json
│ │ │ ├── pathExt.json
│ │ │ ├── pattern.json
│ │ │ ├── PatternBoolean.json
│ │ │ ├── pBuiltins.json
│ │ │ ├── pFloatForm.json
│ │ │ ├── pkg.json
│ │ │ ├── PLUGIN_ID_DOC_MANAGER.json
│ │ │ ├── plusChar.json
│ │ │ ├── PN_CHARS.json
│ │ │ ├── point.json
│ │ │ ├── prefix.json
│ │ │ ├── PRETTY_PLACEHOLDER.json
│ │ │ ├── property_prefix.json
│ │ │ ├── pubkey256.json
│ │ │ ├── Q.json
│ │ │ ├── qmark.json
│ │ │ ├── QO.json
│ │ │ ├── query.json
│ │ │ ├── querystringType.json
│ │ │ ├── queryText.json
│ │ │ ├── r.json
│ │ │ ├── R.json
│ │ │ ├── rangeStart.json
│ │ │ ├── re.json
│ │ │ ├── reI.json
│ │ │ ├── REQUIRED_FIELD_SYMBOL.json
│ │ │ ├── reserve.json
│ │ │ ├── resolvedDestination.json
│ │ │ ├── resolverDir.json
│ │ │ ├── responseType.json
│ │ │ ├── result.json
│ │ │ ├── ROOT_DESCRIBE_BLOCK_NAME.json
│ │ │ ├── ROOT_NAMESPACE_NAME.json
│ │ │ ├── ROOT_TASK_NAME.json
│ │ │ ├── route.json
│ │ │ ├── RUNNING_TEXT.json
│ │ │ ├── s.json
│ │ │ ├── SCHEMA_PATH.json
│ │ │ ├── se.json
│ │ │ ├── SEARCHABLE_CLASS.json
│ │ │ ├── secret.json
│ │ │ ├── selector.json
│ │ │ ├── SEMVER_SPEC_VERSION.json
│ │ │ ├── sensitiveHeaders.json
│ │ │ ├── sep.json
│ │ │ ├── separator.json
│ │ │ ├── SHAPE_STATE.json
│ │ │ ├── shape.json
│ │ │ ├── SHARED.json
│ │ │ ├── short.json
│ │ │ ├── side.json
│ │ │ ├── SNAPSHOT_VERSION.json
│ │ │ ├── SOURCE_MAPPING_PREFIX.json
│ │ │ ├── source.json
│ │ │ ├── sourceMapContent.json
│ │ │ ├── SPACE_SYMBOL.json
│ │ │ ├── SPACE.json
│ │ │ ├── sqlKeywords.json
│ │ │ ├── sranges.json
│ │ │ ├── st.json
│ │ │ ├── ST.json
│ │ │ ├── stack.json
│ │ │ ├── START_HIDING.json
│ │ │ ├── START_OF_LINE.json
│ │ │ ├── startNoTraversal.json
│ │ │ ├── STATES.json
│ │ │ ├── stats.json
│ │ │ ├── statSync.json
│ │ │ ├── storageStatus.json
│ │ │ ├── storageType.json
│ │ │ ├── str.json
│ │ │ ├── stringifiedObject.json
│ │ │ ├── stringPath.json
│ │ │ ├── stringResult.json
│ │ │ ├── stringTag.json
│ │ │ ├── strValue.json
│ │ │ ├── style.json
│ │ │ ├── SUB_NAME.json
│ │ │ ├── subkey.json
│ │ │ ├── SUBPROTOCOL.json
│ │ │ ├── SUITE_NAME.json
│ │ │ ├── symbolPattern.json
│ │ │ ├── symbolTag.json
│ │ │ ├── t.json
│ │ │ ├── T.json
│ │ │ ├── templateDir.json
│ │ │ ├── tempName.json
│ │ │ ├── text.json
│ │ │ ├── time.json
│ │ │ ├── titleSeparator.json
│ │ │ ├── tmpl.json
│ │ │ ├── tn.json
│ │ │ ├── toValue.json
│ │ │ ├── transform.json
│ │ │ ├── trustProxyDefaultSymbol.json
│ │ │ ├── typeArgumentsKey.json
│ │ │ ├── typeKey.json
│ │ │ ├── typeMessage.json
│ │ │ ├── typesRegistryPackageName.json
│ │ │ ├── u.json
│ │ │ ├── UNDEFINED.json
│ │ │ ├── unit.json
│ │ │ ├── UNMATCHED_SURROGATE_PAIR_REPLACE.json
│ │ │ ├── ur.json
│ │ │ ├── USAGE.json
│ │ │ ├── value.json
│ │ │ ├── Vr.json
│ │ │ ├── watchmanURL.json
│ │ │ ├── webkit.json
│ │ │ ├── xhtml.json
│ │ │ ├── XP_DEFAULT_PATHEXT.json
│ │ │ └── y.json
│ │ ├── Collaborative_Development_with_MCP_Integration.json
│ │ ├── colorCode.json
│ │ ├── comma.json
│ │ ├── command.json
│ │ ├── completionShTemplate.json
│ │ ├── configJsContent.json
│ │ ├── connectionString.json
│ │ ├── Consolidated_TypeScript_Interfaces_Template.json
│ │ ├── Could_you_interpret_the_assumed_applicat___.json
│ │ ├── cssClassStr.json
│ │ ├── currentBoundaryParse.json
│ │ ├── d.json
│ │ ├── Data_Analysis_Template.json
│ │ ├── data.json
│ │ ├── DATA.json
│ │ ├── Database_Query_Assistant.json
│ │ ├── dataWebpackPrefix.json
│ │ ├── debug.json
│ │ ├── Debugging_Assistant.json
│ │ ├── decodeStateVectorV2.json
│ │ ├── DEFAULT_DELIMITER.json
│ │ ├── DEFAULT_DIAGRAM_DIRECTION.json
│ │ ├── DEFAULT_INDENT.json
│ │ ├── DEFAULT_JS_PATTERN.json
│ │ ├── DEFAULT_LOG_TARGET.json
│ │ ├── defaultHelpOpt.json
│ │ ├── defaultHost.json
│ │ ├── deferY18nLookupPrefix.json
│ │ ├── DELIM.json
│ │ ├── delimiter.json
│ │ ├── DEPRECATION.json
│ │ ├── DESCENDING.json
│ │ ├── destMain.json
│ │ ├── development
│ │ │ ├── Collaborative_Development_with_MCP_Integration.json
│ │ │ ├── Consolidated_TypeScript_Interfaces_Template.json
│ │ │ ├── Development_Workflow.json
│ │ │ ├── index.json
│ │ │ ├── MCP_Server_Development_Prompt_Combiner.json
│ │ │ └── Monorepo_Migration_and_Code_Organization_Guide.json
│ │ ├── Development_System_Prompt.json
│ │ ├── Development_Workflow.json
│ │ ├── devops
│ │ │ ├── Docker_Compose_Prompt_Combiner.json
│ │ │ ├── Docker_Containerization_Guide.json
│ │ │ └── index.json
│ │ ├── DID_NOT_THROW.json
│ │ ├── direction.json
│ │ ├── displayValue.json
│ │ ├── DNS.json
│ │ ├── doc.json
│ │ ├── Docker_Compose_Prompt_Combiner.json
│ │ ├── Docker_Containerization_Guide.json
│ │ ├── Docker_MCP_Servers_Orchestration_Guide.json
│ │ ├── DOCUMENTATION_NOTE.json
│ │ ├── DOT.json
│ │ ├── DOTS.json
│ │ ├── dummyCompoundId.json
│ │ ├── e.json
│ │ ├── E.json
│ │ ├── earlyHintsLink.json
│ │ ├── elide.json
│ │ ├── EMPTY.json
│ │ ├── encoded.json
│ │ ├── end.json
│ │ ├── endpoint.json
│ │ ├── environment.json
│ │ ├── ERR_CODE.json
│ │ ├── errMessage.json
│ │ ├── errMsg.json
│ │ ├── ERROR_MESSAGE.json
│ │ ├── error.json
│ │ ├── ERROR.json
│ │ ├── ERRORCLASS.json
│ │ ├── errorMessage.json
│ │ ├── es6Default.json
│ │ ├── ESC.json
│ │ ├── Escapable.json
│ │ ├── escapedChar.json
│ │ ├── escapeFuncStr.json
│ │ ├── escSlash.json
│ │ ├── ev.json
│ │ ├── event.json
│ │ ├── execaMessage.json
│ │ ├── EXPECTED_LABEL.json
│ │ ├── expected.json
│ │ ├── expectedString.json
│ │ ├── expression1.json
│ │ ├── EXTENSION.json
│ │ ├── f.json
│ │ ├── FAIL_TEXT.json
│ │ ├── FILE_BROWSER_FACTORY.json
│ │ ├── fill.json
│ │ ├── findPackageJson.json
│ │ ├── fnKey.json
│ │ ├── Foresight_Assistant.json
│ │ ├── FORMAT.json
│ │ ├── formatted.json
│ │ ├── from.json
│ │ ├── fullpaths.json
│ │ ├── FUNC_ERROR_TEXT.json
│ │ ├── general
│ │ │ └── index.json
│ │ ├── Generate_different_types_of_questions_ab___.json
│ │ ├── Generate_Mermaid_Diagram.json
│ │ ├── GenStateSuspendedStart.json
│ │ ├── GENSYNC_EXPECTED_START.json
│ │ ├── GitHub_Repository_Explorer.json
│ │ ├── gutter.json
│ │ ├── h.json
│ │ ├── handlerFuncName.json
│ │ ├── HASH_UNDEFINED.json
│ │ ├── head.json
│ │ ├── helpMessage.json
│ │ ├── HINT_ARG.json
│ │ ├── HOOK_RETURNED_NOTHING_ERROR_MESSAGE.json
│ │ ├── i.json
│ │ ├── id.json
│ │ ├── identifier.json
│ │ ├── Identifier.json
│ │ ├── INDENT.json
│ │ ├── indentation.json
│ │ ├── index.json
│ │ ├── INDIRECTION_FRAGMENT.json
│ │ ├── Initialize_project_setup_for_a_new_micro___.json
│ │ ├── input.json
│ │ ├── inputText.json
│ │ ├── insert.json
│ │ ├── insertPromptQuery.json
│ │ ├── INSPECT_MAX_BYTES.json
│ │ ├── install_dependencies__build__run__test____.json
│ │ ├── intToCharMap.json
│ │ ├── IS_ITERABLE_SENTINEL.json
│ │ ├── IS_KEYED_SENTINEL.json
│ │ ├── isConfigType.json
│ │ ├── isoSentinel.json
│ │ ├── isSourceNode.json
│ │ ├── j.json
│ │ ├── J.json
│ │ ├── JAKE_CMD.json
│ │ ├── JEST_GLOBAL_NAME.json
│ │ ├── JEST_GLOBALS_MODULE_NAME.json
│ │ ├── JSON_SYNTAX_CHAR.json
│ │ ├── json.json
│ │ ├── jsonType.json
│ │ ├── jupyter_namespaceObject.json
│ │ ├── JUPYTERLAB_DOCMANAGER_PLUGIN_ID.json
│ │ ├── k.json
│ │ ├── KERNEL_STATUS_ERROR_CLASS.json
│ │ ├── key.json
│ │ ├── l.json
│ │ ├── labelId.json
│ │ ├── LATEST_PROTOCOL_VERSION.json
│ │ ├── LETTERDASHNUMBER.json
│ │ ├── LF.json
│ │ ├── LIMIT_REPLACE_NODE.json
│ │ ├── LINE_FEED.json
│ │ ├── logTime.json
│ │ ├── lstatkey.json
│ │ ├── lt.json
│ │ ├── m.json
│ │ ├── maliciousPayload.json
│ │ ├── manager.py
│ │ ├── marker.json
│ │ ├── mask.json
│ │ ├── match.json
│ │ ├── matchingDelim.json
│ │ ├── MAXIMUM_MESSAGE_SIZE.json
│ │ ├── MCP_Integration_Assistant.json
│ │ ├── MCP_Resources_Explorer.json
│ │ ├── MCP_Resources_Integration_Guide.json
│ │ ├── MCP_Server_Development_Prompt_Combiner.json
│ │ ├── MCP_Server_Integration_Guide.json
│ │ ├── mcp-code-generator.json
│ │ ├── mdcContent.json
│ │ ├── Mermaid_Analysis_Expert.json
│ │ ├── Mermaid_Class_Diagram_Generator.json
│ │ ├── Mermaid_Diagram_Generator.json
│ │ ├── Mermaid_Diagram_Modifier.json
│ │ ├── MERMAID_DOM_ID_PREFIX.json
│ │ ├── message.json
│ │ ├── messages.json
│ │ ├── meth.json
│ │ ├── minimatch.json
│ │ ├── MOBILE_QUERY.json
│ │ ├── MOCK_CONSTRUCTOR_NAME.json
│ │ ├── MOCKS_PATTERN.json
│ │ ├── Modify_Mermaid_Diagram.json
│ │ ├── moduleDirectory.json
│ │ ├── Monorepo_Migration_and_Code_Organization_Guide.json
│ │ ├── msg.json
│ │ ├── mtr.json
│ │ ├── Multi-Resource_Context_Assistant.json
│ │ ├── multipartType.json
│ │ ├── n.json
│ │ ├── N.json
│ │ ├── name.json
│ │ ├── NATIVE_PLATFORM.json
│ │ ├── newUrl.json
│ │ ├── NM.json
│ │ ├── NO_ARGUMENTS.json
│ │ ├── NO_DIFF_MESSAGE.json
│ │ ├── NODE_MODULES.json
│ │ ├── nodeInternalPrefix.json
│ │ ├── nonASCIIidentifierStartChars.json
│ │ ├── nonKey.json
│ │ ├── NOT_A_DOT.json
│ │ ├── notCharacterOrDash.json
│ │ ├── notebookURL.json
│ │ ├── notSelector.json
│ │ ├── nullTag.json
│ │ ├── num.json
│ │ ├── NUMBER.json
│ │ ├── o.json
│ │ ├── O.json
│ │ ├── octChar.json
│ │ ├── octetStreamType.json
│ │ ├── operators.json
│ │ ├── other
│ │ │ ├── __image_1___describe_the_icon_in_one_sen___.json
│ │ │ ├── __type.json
│ │ │ ├── Advanced_Multi-Server_Integration_Template.json
│ │ │ ├── Analyze_Mermaid_Diagram.json
│ │ │ ├── Basic_Template.json
│ │ │ ├── Code_Diagram_Documentation_Creator.json
│ │ │ ├── Collaborative_Development_with_MCP_Integration.json
│ │ │ ├── completionShTemplate.json
│ │ │ ├── Could_you_interpret_the_assumed_applicat___.json
│ │ │ ├── DEFAULT_INDENT.json
│ │ │ ├── Docker_MCP_Servers_Orchestration_Guide.json
│ │ │ ├── Generate_different_types_of_questions_ab___.json
│ │ │ ├── Generate_Mermaid_Diagram.json
│ │ │ ├── GitHub_Repository_Explorer.json
│ │ │ ├── index.json
│ │ │ ├── Initialize_project_setup_for_a_new_micro___.json
│ │ │ ├── install_dependencies__build__run__test____.json
│ │ │ ├── LINE_FEED.json
│ │ │ ├── MCP_Resources_Explorer.json
│ │ │ ├── MCP_Resources_Integration_Guide.json
│ │ │ ├── MCP_Server_Integration_Guide.json
│ │ │ ├── mcp-code-generator.json
│ │ │ ├── Mermaid_Class_Diagram_Generator.json
│ │ │ ├── Mermaid_Diagram_Generator.json
│ │ │ ├── Mermaid_Diagram_Modifier.json
│ │ │ ├── Modify_Mermaid_Diagram.json
│ │ │ ├── Multi-Resource_Context_Assistant.json
│ │ │ ├── output.json
│ │ │ ├── sseUrl.json
│ │ │ ├── string.json
│ │ │ ├── Task_List_Helper.json
│ │ │ ├── Template-Based_MCP_Integration.json
│ │ │ ├── Test_Prompt.json
│ │ │ ├── type.json
│ │ │ ├── VERSION.json
│ │ │ ├── WIN_SLASH.json
│ │ │ └── You_are_limited_to_respond_Yes_or_No_onl___.json
│ │ ├── out.json
│ │ ├── output.json
│ │ ├── OUTSIDE_JEST_VM_PROTOCOL.json
│ │ ├── override.json
│ │ ├── p.json
│ │ ├── PACKAGE_FILENAME.json
│ │ ├── PACKAGE_JSON.json
│ │ ├── packageVersion.json
│ │ ├── paddedNumber.json
│ │ ├── page.json
│ │ ├── parseClass.json
│ │ ├── PATH_NODE_MODULES.json
│ │ ├── path.json
│ │ ├── pathExt.json
│ │ ├── pattern.json
│ │ ├── PatternBoolean.json
│ │ ├── pBuiltins.json
│ │ ├── pFloatForm.json
│ │ ├── pkg.json
│ │ ├── PLUGIN_ID_DOC_MANAGER.json
│ │ ├── plusChar.json
│ │ ├── PN_CHARS.json
│ │ ├── point.json
│ │ ├── prefix.json
│ │ ├── PRETTY_PLACEHOLDER.json
│ │ ├── Project_Analysis_Assistant.json
│ │ ├── ProjectsUpdatedInBackgroundEvent.json
│ │ ├── PromptCombiner_Interface.json
│ │ ├── promptId.json
│ │ ├── property_prefix.json
│ │ ├── pubkey256.json
│ │ ├── Q.json
│ │ ├── qmark.json
│ │ ├── QO.json
│ │ ├── query.json
│ │ ├── querystringType.json
│ │ ├── queryText.json
│ │ ├── r.json
│ │ ├── R.json
│ │ ├── rangeStart.json
│ │ ├── re.json
│ │ ├── reI.json
│ │ ├── REQUIRED_FIELD_SYMBOL.json
│ │ ├── Research_Assistant.json
│ │ ├── reserve.json
│ │ ├── resolvedDestination.json
│ │ ├── resolverDir.json
│ │ ├── responseType.json
│ │ ├── result.json
│ │ ├── ROOT_DESCRIBE_BLOCK_NAME.json
│ │ ├── ROOT_NAMESPACE_NAME.json
│ │ ├── ROOT_TASK_NAME.json
│ │ ├── route.json
│ │ ├── RUNNING_TEXT.json
│ │ ├── RXstyle.json
│ │ ├── s.json
│ │ ├── SCHEMA_PATH.json
│ │ ├── schemaQuery.json
│ │ ├── se.json
│ │ ├── SEARCHABLE_CLASS.json
│ │ ├── secret.json
│ │ ├── selector.json
│ │ ├── SEMVER_SPEC_VERSION.json
│ │ ├── sensitiveHeaders.json
│ │ ├── sep.json
│ │ ├── separator.json
│ │ ├── Sequential_Data_Analysis_with_MCP_Integration.json
│ │ ├── SHAPE_STATE.json
│ │ ├── shape.json
│ │ ├── SHARED.json
│ │ ├── short.json
│ │ ├── side.json
│ │ ├── SNAPSHOT_VERSION.json
│ │ ├── SOLID_Code_Analysis_Visualizer.json
│ │ ├── SOURCE_MAPPING_PREFIX.json
│ │ ├── source.json
│ │ ├── sourceMapContent.json
│ │ ├── SPACE_SYMBOL.json
│ │ ├── SPACE.json
│ │ ├── sqlKeywords.json
│ │ ├── sranges.json
│ │ ├── sseUrl.json
│ │ ├── st.json
│ │ ├── ST.json
│ │ ├── stack.json
│ │ ├── START_HIDING.json
│ │ ├── START_OF_LINE.json
│ │ ├── startNoTraversal.json
│ │ ├── STATES.json
│ │ ├── stats.json
│ │ ├── statSync.json
│ │ ├── status.json
│ │ ├── storageStatus.json
│ │ ├── storageType.json
│ │ ├── str.json
│ │ ├── string.json
│ │ ├── stringifiedObject.json
│ │ ├── stringPath.json
│ │ ├── stringResult.json
│ │ ├── stringTag.json
│ │ ├── strValue.json
│ │ ├── style.json
│ │ ├── SUB_NAME.json
│ │ ├── subkey.json
│ │ ├── SUBPROTOCOL.json
│ │ ├── SUITE_NAME.json
│ │ ├── symbolPattern.json
│ │ ├── symbolTag.json
│ │ ├── system
│ │ │ ├── Aa.json
│ │ │ ├── b.json
│ │ │ ├── Development_System_Prompt.json
│ │ │ ├── index.json
│ │ │ ├── marker.json
│ │ │ ├── PATH_NODE_MODULES.json
│ │ │ ├── ProjectsUpdatedInBackgroundEvent.json
│ │ │ ├── RXstyle.json
│ │ │ ├── status.json
│ │ │ └── versionMajorMinor.json
│ │ ├── t.json
│ │ ├── T.json
│ │ ├── Task_List_Helper.json
│ │ ├── Template-Based_MCP_Integration.json
│ │ ├── template.py
│ │ ├── templateDir.json
│ │ ├── tempName.json
│ │ ├── Test_Prompt.json
│ │ ├── text.json
│ │ ├── time.json
│ │ ├── titleSeparator.json
│ │ ├── tmpl.json
│ │ ├── tn.json
│ │ ├── TOPBAR_FACTORY.json
│ │ ├── toValue.json
│ │ ├── transform.json
│ │ ├── trustProxyDefaultSymbol.json
│ │ ├── txt.json
│ │ ├── type.json
│ │ ├── typeArgumentsKey.json
│ │ ├── typeKey.json
│ │ ├── typeMessage.json
│ │ ├── typesRegistryPackageName.json
│ │ ├── u.json
│ │ ├── UNDEFINED.json
│ │ ├── unit.json
│ │ ├── UNMATCHED_SURROGATE_PAIR_REPLACE.json
│ │ ├── ur.json
│ │ ├── usage.json
│ │ ├── USAGE.json
│ │ ├── user
│ │ │ ├── backupId.json
│ │ │ ├── DESCENDING.json
│ │ │ ├── encoded.json
│ │ │ ├── index.json
│ │ │ ├── J.json
│ │ │ ├── MOBILE_QUERY.json
│ │ │ ├── promptId.json
│ │ │ ├── schemaQuery.json
│ │ │ ├── TOPBAR_FACTORY.json
│ │ │ ├── txt.json
│ │ │ └── usage.json
│ │ ├── value.json
│ │ ├── VERSION.json
│ │ ├── version.py
│ │ ├── versionMajorMinor.json
│ │ ├── Vr.json
│ │ ├── watchmanURL.json
│ │ ├── webkit.json
│ │ ├── WIN_SLASH.json
│ │ ├── xhtml.json
│ │ ├── XP_DEFAULT_PATHEXT.json
│ │ ├── y.json
│ │ └── You_are_limited_to_respond_Yes_or_No_onl___.json
│ ├── resources
│ │ ├── __init__.py
│ │ ├── code_examples
│ │ │ └── index.json
│ │ ├── config
│ │ │ └── index.json
│ │ ├── documentation
│ │ │ └── index.json
│ │ ├── images
│ │ │ └── index.json
│ │ ├── index.json
│ │ └── other
│ │ └── index.json
│ ├── server.py
│ ├── templates
│ │ ├── __init__.py
│ │ ├── AbstractFactory.json
│ │ ├── Adapter.json
│ │ ├── base.py
│ │ ├── Builder.json
│ │ ├── Chain.json
│ │ ├── Command.json
│ │ ├── component
│ │ │ ├── AbstractFactory.json
│ │ │ ├── Adapter.json
│ │ │ ├── Builder.json
│ │ │ ├── Chain.json
│ │ │ ├── Command.json
│ │ │ ├── Decorator.json
│ │ │ ├── Facade.json
│ │ │ ├── Factory.json
│ │ │ ├── Iterator.json
│ │ │ ├── Mediator.json
│ │ │ ├── Memento.json
│ │ │ ├── Observer.json
│ │ │ ├── Prototype.json
│ │ │ ├── Proxy.json
│ │ │ ├── Singleton.json
│ │ │ ├── State.json
│ │ │ ├── Strategy.json
│ │ │ ├── TemplateMethod.json
│ │ │ └── Visitor.json
│ │ ├── component.py
│ │ ├── Decorator.json
│ │ ├── Facade.json
│ │ ├── Factory.json
│ │ ├── index.json
│ │ ├── Iterator.json
│ │ ├── manager.py
│ │ ├── Mediator.json
│ │ ├── Memento.json
│ │ ├── Observer.json
│ │ ├── project.py
│ │ ├── Prototype.json
│ │ ├── Proxy.json
│ │ ├── renderer.py
│ │ ├── Singleton.json
│ │ ├── State.json
│ │ ├── Strategy.json
│ │ ├── template_manager.py
│ │ ├── TemplateMethod.json
│ │ ├── types.py
│ │ └── Visitor.json
│ └── utils
│ └── __init__.py
├── SUMMARY.md
├── TASK_COMPLETION_SUMMARY.md
├── templates
│ └── openssl
│ ├── files
│ │ ├── CMakeLists.txt.jinja2
│ │ ├── conanfile.py.jinja2
│ │ ├── main.cpp.jinja2
│ │ └── README.md.jinja2
│ ├── openssl-consumer.json
│ └── template.json
├── test_openssl_integration.sh
├── test_package
│ └── conanfile.py
└── tests
├── __init__.py
├── conftest.py
├── integration
│ ├── test_core_integration.py
│ ├── test_mermaid_integration.py
│ ├── test_prompt_manager_integration.py
│ └── test_server_integration.py
├── test_aws_mcp.py
├── test_base_classes.py
├── test_config.py
├── test_exceptions.py
├── test_mermaid.py
├── test_prompts.py
└── test_templates.py
```
# Files
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/other/index.json:
--------------------------------------------------------------------------------
```json
{
"templates": [
"Advanced Multi-Server Integration Template",
"MCP Server Integration Guide",
"Multi-Resource Context Assistant",
"Docker MCP Servers Orchestration Guide",
"MCP Resources Explorer",
"GitHub Repository Explorer",
"Template-Based MCP Integration",
"MCP Resources Integration Guide",
"mcp-code-generator",
"Basic Template",
"DEFAULT_INDENT",
"completionShTemplate",
"output",
"WIN_SLASH",
"VERSION",
"type",
"__type",
"sseUrl",
"string",
"LINE_FEED",
"Analyze Mermaid Diagram",
"Mermaid Diagram Modifier",
"You are limited to respond Yes or No onl...",
"Code Diagram Documentation Creator",
"<|image_1|>\ndescribe the icon in one sen...",
"Modify Mermaid Diagram",
"Initialize project setup for a new micro...",
"install dependencies, build, run, test,...",
"Generate different types of questions ab...",
"Generate Mermaid Diagram",
"Mermaid Diagram Generator",
"Task List Helper",
"Test Prompt",
"Mermaid Class Diagram Generator",
"Could you interpret the assumed applicat..."
],
"count": 35
}
```
--------------------------------------------------------------------------------
/.github/workflows/build.yml:
--------------------------------------------------------------------------------
```yaml
name: Build
on:
push:
tags:
- 'v*.*.*'
workflow_dispatch: {}
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Setup Python
uses: actions/setup-python@v5
with:
python-version: '3.12'
- name: Install build tools
run: |
python -m pip install --upgrade pip
pip install build twine "conan>=2.3,<3"
conan profile detect --force | cat
- name: Build Python artifacts
run: |
python -m build
ls -la dist | cat
- name: Upload Python dist as artifact
uses: actions/upload-artifact@v4
with:
name: python-dist
path: dist/*
- name: Build Conan package
run: |
conan create . --user=sparesparrow --channel=stable --build=missing | cat
conan cache path mcp-project-orchestrator/0.1.0@sparesparrow/stable | cat
- name: Export Conan package to local
run: |
conan export-pkg . --name=mcp-project-orchestrator --version=0.1.0 --user=sparesparrow --channel=stable --force | cat
```
--------------------------------------------------------------------------------
/config/project_orchestration.json:
--------------------------------------------------------------------------------
```json
{
"enable": {
"cursorConfigs": true,
"pythonMcp": true,
"tsMcp": true,
"cppMcp": true,
"mcpClient": true,
"backgroundAgent": true,
"githubActions": true,
"devcontainer": true,
"awsTerraform": true,
"awsMcp": true,
"webAndMcp": true,
"cppConan": true,
"esp32": true,
"android": true
},
"aws": {
"enabled": true,
"services": ["s3", "ec2", "lambda", "cloudformation", "iam"],
"bestPractices": {
"enabled": true,
"enforcement": true
},
"costOptimization": {
"enabled": true,
"alertThreshold": 100
},
"security": {
"scanningEnabled": false,
"enforceEncryption": true
}
},
"ports": {
"pyMcpPort": 8765,
"tsMcpPort": 8766
},
"backgroundAgent": {
"host": "127.0.0.1",
"port": 8088
},
"tools": {
"largeCodebases": {
"enabled": true,
"exclude": ["node_modules", "build", "dist", ".git", ".venv", "venv"],
"maxFileSizeMB": 5
},
"mermaid": {
"enabled": true
}
},
"container": {
"prefer": "podman"
},
"runtime": {
"node": "lts/*",
"python": "3.11"
}
}
```
--------------------------------------------------------------------------------
/data/prompts/templates/prompt-templates.json:
--------------------------------------------------------------------------------
```json
{
"prompts": [
{
"id": "default-prompt",
"name": "Default Prompt",
"description": "A default prompt template",
"content": "You are an AI assistant. {{system_message}}",
"isTemplate": true,
"variables": ["system_message"],
"tags": ["default"],
"createdAt": "2025-03-23T00:00:00.000Z",
"updatedAt": "2025-03-23T00:00:00.000Z",
"version": 1
}
],
"resources": [
{
"id": "default-resource",
"name": "Default Resource",
"description": "A default resource",
"uri": "file:///home/sparrow/mcp/data/prompts/default-resource.txt",
"tags": ["default"],
"createdAt": "2025-03-23T00:00:00.000Z",
"updatedAt": "2025-03-23T00:00:00.000Z"
}
],
"tools": [
{
"id": "echo",
"name": "Echo",
"description": "Echoes the input",
"inputSchema": {
"type": "object",
"properties": {
"text": {
"type": "string",
"description": "Text to echo"
}
},
"required": ["text"]
},
"tags": ["default"],
"createdAt": "2025-03-23T00:00:00.000Z",
"updatedAt": "2025-03-23T00:00:00.000Z"
}
]
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/mermaid/templates/flowchart/generated_diagram.json:
--------------------------------------------------------------------------------
```json
{
"name": "generated_diagram",
"description": "Mermaid flowchart diagram",
"type": "flowchart",
"content": "flowchart TD\n A[Start] --> B{New User?}\n B -->|Yes| C[Registration Form]\n B -->|No| D[Login Form]\n \n C --> E[Enter Email/Password]\n C --> F[Enter User Details]\n E --> G[Validate Input]\n F --> G\n G -->|Invalid| C\n G -->|Valid| H[Create Account]\n H --> I[Send Verification Email]\n I --> J[Verify Email]\n J --> K[Account Created]\n \n D --> L[Enter Credentials]\n L --> M[Validate Login]\n M -->|Invalid| D\n M -->|Valid| N[Login Successful]\n \n K --> O[Account Dashboard]\n N --> O\n \n O --> P[Manage Profile]\n O --> Q[Change Password]\n O --> R[Logout]\n R --> A\n\n%% Styling\nclassDef default fill:#f9f9f9,stroke:#333333,stroke-width:1px,color:#333333,rx:5px,ry:5px\nclassDef highlight fill:#ff7700,stroke:#333333,stroke-width:2px,color:white,rx:5px,ry:5px\nclassDef success fill:#00aa00,stroke:#333333,stroke-width:1px,color:white,rx:5px,ry:5px\nclassDef warning fill:#ffaa00,stroke:#333333,stroke-width:1px,color:#333333,rx:5px,ry:5px\nclassDef error fill:#dd0000,stroke:#333333,stroke-width:1px,color:white,rx:5px,ry:5px",
"variables": {},
"metadata": {
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/mermaid/templates/generated_diagram.json:
--------------------------------------------------------------------------------
```json
{
"name": "generated_diagram",
"description": "Mermaid flowchart diagram",
"type": "flowchart",
"content": "flowchart TD\n A[Start] --> B{New User?}\n B -->|Yes| C[Registration Form]\n B -->|No| D[Login Form]\n \n C --> E[Enter Email/Password]\n C --> F[Enter User Details]\n E --> G[Validate Input]\n F --> G\n G -->|Invalid| C\n G -->|Valid| H[Create Account]\n H --> I[Send Verification Email]\n I --> J[Verify Email]\n J --> K[Account Created]\n \n D --> L[Enter Credentials]\n L --> M[Validate Login]\n M -->|Invalid| D\n M -->|Valid| N[Login Successful]\n \n K --> O[Account Dashboard]\n N --> O\n \n O --> P[Manage Profile]\n O --> Q[Change Password]\n O --> R[Logout]\n R --> A\n\n%% Styling\nclassDef default fill:#f9f9f9,stroke:#333333,stroke-width:1px,color:#333333,rx:5px,ry:5px\nclassDef highlight fill:#ff7700,stroke:#333333,stroke-width:2px,color:white,rx:5px,ry:5px\nclassDef success fill:#00aa00,stroke:#333333,stroke-width:1px,color:white,rx:5px,ry:5px\nclassDef warning fill:#ffaa00,stroke:#333333,stroke-width:1px,color:#333333,rx:5px,ry:5px\nclassDef error fill:#dd0000,stroke:#333333,stroke-width:1px,color:white,rx:5px,ry:5px",
"variables": {},
"metadata": {
"imported": true
}
}
```
--------------------------------------------------------------------------------
/aws-sip-trunk/pyproject.toml:
--------------------------------------------------------------------------------
```toml
[build-system]
requires = ["setuptools>=68", "wheel"]
build-backend = "setuptools.build_meta"
[project]
name = "aws-sip-trunk"
version = "1.0.0"
description = "AWS infrastructure deployment for Asterisk SIP trunk with ElevenLabs integration"
readme = "README.md"
requires-python = ">=3.9"
authors = [
{ name = "MCP Project Orchestrator" }
]
license = { text = "MIT" }
dependencies = [
"boto3>=1.26.0",
"botocore>=1.29.0",
"pyyaml>=6.0",
"jinja2>=3.1.0",
"python-dotenv>=1.0.0",
]
[project.optional-dependencies]
dev = [
"pytest>=7.0.0",
"pytest-asyncio>=0.21.0",
"pytest-cov>=4.0.0",
"mypy>=1.0.0",
"ruff>=0.1.0",
"black>=23.0.0",
]
testing = [
"pjsua>=2.0.0", # For SIP testing
"requests>=2.28.0",
]
[project.scripts]
aws-sip-deploy = "aws_sip_trunk.cli:main"
[tool.setuptools]
package-dir = {"" = "src"}
[tool.setuptools.packages.find]
where = ["src"]
include = ["aws_sip_trunk*"]
[tool.black]
line-length = 100
target-version = ["py39"]
include = '\.pyi?$'
[tool.ruff]
line-length = 100
target-version = "py39"
select = ["E", "F", "B", "I", "W", "N"]
ignore = []
[tool.mypy]
python_version = "3.9"
warn_return_any = true
warn_unused_configs = true
disallow_untyped_defs = true
[tool.pytest.ini_options]
minversion = "7.0"
addopts = "-ra -q --cov=aws_sip_trunk"
testpaths = ["tests"]
```
--------------------------------------------------------------------------------
/mcp-project-orchestrator/openssl/examples/example-workspace/src/main.cpp:
--------------------------------------------------------------------------------
```cpp
#include <iostream>
#include <openssl/evp.h>
#include <openssl/rand.h>
#include "crypto_utils.h"
int main() {
std::cout << "OpenSSL Example with Cursor AI Configuration" << std::endl;
// Initialize OpenSSL
OpenSSL_add_all_algorithms();
// Test random number generation
unsigned char random_bytes[32];
if (RAND_bytes(random_bytes, sizeof(random_bytes)) != 1) {
std::cerr << "Failed to generate random bytes" << std::endl;
return 1;
}
std::cout << "Generated random bytes successfully" << std::endl;
// Test encryption
std::string plaintext = "Hello, OpenSSL!";
std::string encrypted = encrypt_aes256_gcm(plaintext, "secret_key_32_bytes_long_12345");
if (encrypted.empty()) {
std::cerr << "Encryption failed" << std::endl;
return 1;
}
std::cout << "Encryption successful" << std::endl;
// Test decryption
std::string decrypted = decrypt_aes256_gcm(encrypted, "secret_key_32_bytes_long_12345");
if (decrypted != plaintext) {
std::cerr << "Decryption failed" << std::endl;
return 1;
}
std::cout << "Decryption successful" << std::endl;
std::cout << "Original: " << plaintext << std::endl;
std::cout << "Decrypted: " << decrypted << std::endl;
// Cleanup
EVP_cleanup();
return 0;
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/assistant/Code_Refactoring_Assistant.json:
--------------------------------------------------------------------------------
```json
{
"name": "Code Refactoring Assistant",
"description": "You are a talented information interpreter and transformator and a helpful source code refactoring a...",
"type": "prompt",
"category": "assistant",
"content": "You are a talented information interpreter and transformator and a helpful source code refactoring assistant. Given the user provided source code, your task is to think step-by-step and transform this source code into a more readable, simplified and shorter version. Keep in mind that the main goal here is to reduce the size of the code without losing its functionality and correctness. Keep the same output in same programming language, maintain good code readability, and ensure that it adheres to best practices and conventions for that language. Keep all variable names and function names the same, so as not to disrupt other parts of the program that may depend on them. Remove any unnecessary lines of code, redundant variables or operations, and simplify complex constructs where possible. Also, look for opportunities to use built-in functions or libraries to achieve the same functionality with fewer lines of code. Your responses only contains the modified source code and the actions performed to modify the original code are included in the code as comments.",
"variables": {},
"metadata": {
"source": "/home/sparrow/mcp/data/prompts/code-refactoring-assistant.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/Code_Refactoring_Assistant.json:
--------------------------------------------------------------------------------
```json
{
"name": "Code Refactoring Assistant",
"description": "You are a talented information interpreter and transformator and a helpful source code refactoring a...",
"type": "prompt",
"category": "assistant",
"content": "You are a talented information interpreter and transformator and a helpful source code refactoring assistant. Given the user provided source code, your task is to think step-by-step and transform this source code into a more readable, simplified and shorter version. Keep in mind that the main goal here is to reduce the size of the code without losing its functionality and correctness. Keep the same output in same programming language, maintain good code readability, and ensure that it adheres to best practices and conventions for that language. Keep all variable names and function names the same, so as not to disrupt other parts of the program that may depend on them. Remove any unnecessary lines of code, redundant variables or operations, and simplify complex constructs where possible. Also, look for opportunities to use built-in functions or libraries to achieve the same functionality with fewer lines of code. Your responses only contains the modified source code and the actions performed to modify the original code are included in the code as comments.",
"variables": {},
"metadata": {
"source": "/home/sparrow/mcp/data/prompts/code-refactoring-assistant.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/assistant/Code_Review_Assistant.json:
--------------------------------------------------------------------------------
```json
{
"name": "Code Review Assistant",
"description": "A comprehensive template for reviewing code with best practices, security considerations, and improvement suggestions",
"type": "prompt",
"category": "assistant",
"content": "You are a senior code reviewer examining {{language}} code. Provide a comprehensive review with the following sections:\n\n1. **Overall Assessment**\n - Brief summary of code quality\n - Key strengths and areas for improvement\n\n2. **Code Quality**\n - Readability and maintainability\n - Adherence to {{language}} conventions and best practices\n - Code organization and structure\n - Naming conventions\n - Comments and documentation\n\n3. **Functionality**\n - Does the code accomplish its intended purpose?\n - Edge case handling\n - Error handling and robustness\n\n4. **Performance**\n - Algorithmic efficiency\n - Resource utilization\n - Potential bottlenecks\n\n5. **Security Considerations**\n - Potential vulnerabilities\n - Input validation\n - Authorization/authentication concerns if applicable\n\n6. **Specific Improvements**\n - Prioritized list of actionable improvements\n - Code snippets showing recommended changes\n\nCode to review:\n```{{language}}\n{{code}}\n```\n\nContext (if available):\n{{context}}",
"variables": [
"language",
"code",
"context"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/code-review-assistant.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/Code_Review_Assistant.json:
--------------------------------------------------------------------------------
```json
{
"name": "Code Review Assistant",
"description": "A comprehensive template for reviewing code with best practices, security considerations, and improvement suggestions",
"type": "prompt",
"category": "assistant",
"content": "You are a senior code reviewer examining {{language}} code. Provide a comprehensive review with the following sections:\n\n1. **Overall Assessment**\n - Brief summary of code quality\n - Key strengths and areas for improvement\n\n2. **Code Quality**\n - Readability and maintainability\n - Adherence to {{language}} conventions and best practices\n - Code organization and structure\n - Naming conventions\n - Comments and documentation\n\n3. **Functionality**\n - Does the code accomplish its intended purpose?\n - Edge case handling\n - Error handling and robustness\n\n4. **Performance**\n - Algorithmic efficiency\n - Resource utilization\n - Potential bottlenecks\n\n5. **Security Considerations**\n - Potential vulnerabilities\n - Input validation\n - Authorization/authentication concerns if applicable\n\n6. **Specific Improvements**\n - Prioritized list of actionable improvements\n - Code snippets showing recommended changes\n\nCode to review:\n```{{language}}\n{{code}}\n```\n\nContext (if available):\n{{context}}",
"variables": [
"language",
"code",
"context"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/code-review-assistant.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/data/prompts/templates/code-refactoring-assistant.json:
--------------------------------------------------------------------------------
```json
{
"id": "code-refactoring-assistant",
"name": "Code Refactoring Assistant",
"description": "You are a talented information interpreter and transformator and a helpful source code refactoring a...",
"content": "You are a talented information interpreter and transformator and a helpful source code refactoring assistant. Given the user provided source code, your task is to think step-by-step and transform this source code into a more readable, simplified and shorter version. Keep in mind that the main goal here is to reduce the size of the code without losing its functionality and correctness. Keep the same output in same programming language, maintain good code readability, and ensure that it adheres to best practices and conventions for that language. Keep all variable names and function names the same, so as not to disrupt other parts of the program that may depend on them. Remove any unnecessary lines of code, redundant variables or operations, and simplify complex constructs where possible. Also, look for opportunities to use built-in functions or libraries to achieve the same functionality with fewer lines of code. Your responses only contains the modified source code and the actions performed to modify the original code are included in the code as comments.",
"isTemplate": false,
"tags": [
"refactoring",
"programming",
"optimization",
"ai-assistant"
],
"createdAt": "2025-03-05T03:37:30.297Z",
"updatedAt": "2025-03-05T03:41:11.023Z",
"version": 1
}
```
--------------------------------------------------------------------------------
/data/prompts/templates/code-review-assistant.json:
--------------------------------------------------------------------------------
```json
{
"id": "code-review-assistant",
"name": "Code Review Assistant",
"description": "A comprehensive template for reviewing code with best practices, security considerations, and improvement suggestions",
"content": "You are a senior code reviewer examining {{language}} code. Provide a comprehensive review with the following sections:\n\n1. **Overall Assessment**\n - Brief summary of code quality\n - Key strengths and areas for improvement\n\n2. **Code Quality**\n - Readability and maintainability\n - Adherence to {{language}} conventions and best practices\n - Code organization and structure\n - Naming conventions\n - Comments and documentation\n\n3. **Functionality**\n - Does the code accomplish its intended purpose?\n - Edge case handling\n - Error handling and robustness\n\n4. **Performance**\n - Algorithmic efficiency\n - Resource utilization\n - Potential bottlenecks\n\n5. **Security Considerations**\n - Potential vulnerabilities\n - Input validation\n - Authorization/authentication concerns if applicable\n\n6. **Specific Improvements**\n - Prioritized list of actionable improvements\n - Code snippets showing recommended changes\n\nCode to review:\n```{{language}}\n{{code}}\n```\n\nContext (if available):\n{{context}}",
"isTemplate": true,
"variables": [
"language",
"code",
"context"
],
"tags": [
"development",
"code-review",
"quality-assurance",
"security"
],
"createdAt": "2025-03-14T12:00:00.000Z",
"updatedAt": "2025-03-14T12:00:00.000Z",
"version": 1
}
```
--------------------------------------------------------------------------------
/docs/AWS.md:
--------------------------------------------------------------------------------
```markdown
# AWS Integration
This document covers AWS integration capabilities for the MCP Project Orchestrator.
## AWS MCP Integration
The MCP Project Orchestrator includes comprehensive AWS MCP (Model Context Protocol) integration that enables AI-powered access to AWS services. For detailed information, see [AWS_MCP.md](./AWS_MCP.md).
### Quick Start
1. Install AWS dependencies:
```bash
pip install -e ".[aws]"
```
2. Configure AWS credentials:
```bash
export AWS_REGION=us-east-1
export AWS_ACCESS_KEY_ID=your_key
export AWS_SECRET_ACCESS_KEY=your_secret
```
3. Start the MCP server with AWS integration enabled.
### Features
- **AWS Service Access**: S3, EC2, Lambda, CloudFormation, IAM
- **Best Practices**: Security, cost optimization, performance guidelines
- **Cost Estimation**: Predict AWS costs based on usage
- **Documentation**: Contextual AWS guidance and examples
See [AWS_MCP.md](./AWS_MCP.md) for complete documentation.
## AWS Artifacts and Container Publishing
This project uses GitHub OIDC to assume an AWS role for publishing artifacts.
### Required AWS setup
- Create S3 bucket: `mcp-orchestrator-artifacts`
- Create ECR repository: `mcp-project-orchestrator`
- Create an IAM role with trust policy for GitHub OIDC and permissions to push to ECR and write to S3. Save its ARN as GitHub secret `AWS_OIDC_ROLE_ARN`.
### Release workflow
On GitHub release publish:
- Build and push container image to ECR using Podman
- Build Python dists and upload to S3 under `releases/<tag>/`
- Optionally archive Conan cache to S3
See `.github/workflows/release.yml`.
```
--------------------------------------------------------------------------------
/SUMMARY.md:
--------------------------------------------------------------------------------
```markdown
# MCP Project Orchestrator Cleanup Summary
## Cleanup Actions Performed
1. **Removed Redundant Files**:
- Deleted `enhanced_orchestrator.py` and `router_integration.py` as their functionality was integrated into core modules
- Removed backup files (.bak) from core directory
- Cleaned up temporary files from scripts directory
2. **Version Control Hygiene**:
- Added `/output/` to .gitignore to exclude build artifacts
- Added `/logs/` to .gitignore to exclude log files
- Updated integration plan to mark all tasks as completed
3. **Documentation**:
- Documented architecture in integration_plan.md
- Added status tracking for completed integration tasks
- Organized consolidation scripts in scripts directory
## Commit History
- a4d27f2 Update integration plan to mark all tasks as completed
- f7c4096 Add logs directory to gitignore
- ba36c50 Exclude output directory from version control as it contains build artifacts
- b2579b7 Clean up: Remove redundant files enhanced_orchestrator.py and router_integration.py which have been integrated into core modules
- 5cc6a70 Finalize all: Update Claude Desktop config, CI/CD workflows, and test scripts to use volume mounting for reliable module access
## Current Project Status
The MCP Project Orchestrator is now finalized with:
- A clean, organized directory structure
- Comprehensive test coverage
- Proper version control hygiene
- Complete documentation
- Minimal redundant or temporary files
## Next Steps
1. Deploy to production
2. Create release tags
3. Publish package to PyPI
4. Implement additional feature requests
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/analysis/Data_Analysis_Template.json:
--------------------------------------------------------------------------------
```json
{
"name": "Data Analysis Template",
"description": "A flexible template for analyzing various types of data with customizable parameters",
"type": "prompt",
"category": "analysis",
"content": "You are a data analysis expert helping with {{data_type}} data analysis. Analyze the following data with respect to the specified goals.\n\n**Data Description**:\n{{data_description}}\n\n**Analysis Goals**:\n{{analysis_goals}}\n\n**Data Sample**:\n```\n{{data_sample}}\n```\n\nProvide a comprehensive analysis with the following sections:\n\n1. **Data Overview**\n - Summary of key characteristics\n - Data quality assessment\n - Potential limitations or biases\n\n2. **Exploratory Analysis**\n - Key patterns and trends\n - Notable outliers or anomalies\n - Distributions and relationships\n\n3. **Insights Related to Goals**\n - Direct answers to the analysis goals\n - Supporting evidence from the data\n - Confidence levels in the insights\n\n4. **Recommendations**\n - Data-driven suggestions\n - Potential actions based on the analysis\n - Areas for further investigation\n\n5. **Methodology Notes**\n - Brief explanation of analytical approach\n - Any assumptions made during the analysis\n - Suggestions for additional data that could enhance the analysis\n\nIf visualization is needed, please describe what visualizations would be most helpful and why.",
"variables": [
"data_type",
"data_description",
"analysis_goals",
"data_sample"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/data-analysis-template.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/Data_Analysis_Template.json:
--------------------------------------------------------------------------------
```json
{
"name": "Data Analysis Template",
"description": "A flexible template for analyzing various types of data with customizable parameters",
"type": "prompt",
"category": "analysis",
"content": "You are a data analysis expert helping with {{data_type}} data analysis. Analyze the following data with respect to the specified goals.\n\n**Data Description**:\n{{data_description}}\n\n**Analysis Goals**:\n{{analysis_goals}}\n\n**Data Sample**:\n```\n{{data_sample}}\n```\n\nProvide a comprehensive analysis with the following sections:\n\n1. **Data Overview**\n - Summary of key characteristics\n - Data quality assessment\n - Potential limitations or biases\n\n2. **Exploratory Analysis**\n - Key patterns and trends\n - Notable outliers or anomalies\n - Distributions and relationships\n\n3. **Insights Related to Goals**\n - Direct answers to the analysis goals\n - Supporting evidence from the data\n - Confidence levels in the insights\n\n4. **Recommendations**\n - Data-driven suggestions\n - Potential actions based on the analysis\n - Areas for further investigation\n\n5. **Methodology Notes**\n - Brief explanation of analytical approach\n - Any assumptions made during the analysis\n - Suggestions for additional data that could enhance the analysis\n\nIf visualization is needed, please describe what visualizations would be most helpful and why.",
"variables": [
"data_type",
"data_description",
"analysis_goals",
"data_sample"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/data-analysis-template.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/core/logging.py:
--------------------------------------------------------------------------------
```python
"""
Logging configuration for MCP Project Orchestrator.
This module provides functions to set up and configure logging
for all components of the project orchestrator.
"""
import logging
import sys
from pathlib import Path
from typing import Optional
def setup_logging(
log_file: Optional[Path] = None,
level: int = logging.INFO,
format_string: Optional[str] = None,
) -> None:
"""Set up logging configuration.
Args:
log_file: Optional path to log file. If not provided, logs to stderr
level: Logging level (default: INFO)
format_string: Optional custom format string for log messages
"""
if format_string is None:
format_string = (
"%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
handlers = []
# Always add stderr handler
handlers.append(logging.StreamHandler(sys.stderr))
# Add file handler if log file is specified
if log_file is not None:
log_file.parent.mkdir(parents=True, exist_ok=True)
handlers.append(logging.FileHandler(str(log_file)))
# Configure logging
logging.basicConfig(
level=level,
format=format_string,
handlers=handlers,
)
# Set levels for third-party loggers
logging.getLogger("aiohttp").setLevel(logging.WARNING)
logging.getLogger("asyncio").setLevel(logging.WARNING)
def get_logger(name: str) -> logging.Logger:
"""Get a logger instance with the given name.
Args:
name: Name for the logger
Returns:
Configured logger instance
"""
return logging.getLogger(name)
```
--------------------------------------------------------------------------------
/data/prompts/templates/data-analysis-template.json:
--------------------------------------------------------------------------------
```json
{
"id": "data-analysis-template",
"name": "Data Analysis Template",
"description": "A flexible template for analyzing various types of data with customizable parameters",
"content": "You are a data analysis expert helping with {{data_type}} data analysis. Analyze the following data with respect to the specified goals.\n\n**Data Description**:\n{{data_description}}\n\n**Analysis Goals**:\n{{analysis_goals}}\n\n**Data Sample**:\n```\n{{data_sample}}\n```\n\nProvide a comprehensive analysis with the following sections:\n\n1. **Data Overview**\n - Summary of key characteristics\n - Data quality assessment\n - Potential limitations or biases\n\n2. **Exploratory Analysis**\n - Key patterns and trends\n - Notable outliers or anomalies\n - Distributions and relationships\n\n3. **Insights Related to Goals**\n - Direct answers to the analysis goals\n - Supporting evidence from the data\n - Confidence levels in the insights\n\n4. **Recommendations**\n - Data-driven suggestions\n - Potential actions based on the analysis\n - Areas for further investigation\n\n5. **Methodology Notes**\n - Brief explanation of analytical approach\n - Any assumptions made during the analysis\n - Suggestions for additional data that could enhance the analysis\n\nIf visualization is needed, please describe what visualizations would be most helpful and why.",
"isTemplate": true,
"variables": [
"data_type",
"data_description",
"analysis_goals",
"data_sample"
],
"tags": [
"analysis",
"data",
"research",
"statistics"
],
"createdAt": "2025-03-14T12:00:00.000Z",
"updatedAt": "2025-03-14T12:00:00.000Z",
"version": 1
}
```
--------------------------------------------------------------------------------
/printcast-agent/config/asterisk/extensions.conf:
--------------------------------------------------------------------------------
```
; PrintCast Agent Asterisk Dialplan Configuration
; This configuration handles incoming calls and routes them to the PrintCast system
[general]
static=yes
writeprotect=no
clearglobalvars=no
[globals]
PRINTCAST_SERVER=localhost
PRINTCAST_PORT=8000
[printcast-ivr]
; Main IVR context for PrintCast
exten => s,1,Answer()
same => n,Wait(1)
same => n,Set(CHANNEL(language)=cs)
same => n,Set(SESSION_ID=${STRFTIME(${EPOCH},,%Y%m%d_%H%M%S)}_${CALLERID(num)})
same => n,AGI(printcast_agi.py,${SESSION_ID},${CALLERID(num)})
same => n,Hangup()
; Handle specific service numbers
exten => 900,1,Goto(printcast-ivr,s,1)
exten => 901,1,Goto(printcast-github,s,1)
exten => 902,1,Goto(printcast-rss,s,1)
exten => 903,1,Goto(printcast-news,s,1)
[printcast-github]
; Direct GitHub trending selection
exten => s,1,Answer()
same => n,Wait(1)
same => n,Set(CONTENT_TYPE=github)
same => n,AGI(printcast_agi.py,${SESSION_ID},${CALLERID(num)},github)
same => n,Hangup()
[printcast-rss]
; Direct RSS feed selection
exten => s,1,Answer()
same => n,Wait(1)
same => n,Set(CONTENT_TYPE=rss)
same => n,AGI(printcast_agi.py,${SESSION_ID},${CALLERID(num)},rss)
same => n,Hangup()
[printcast-news]
; Direct news selection
exten => s,1,Answer()
same => n,Wait(1)
same => n,Set(CONTENT_TYPE=news)
same => n,AGI(printcast_agi.py,${SESSION_ID},${CALLERID(num)},news)
same => n,Hangup()
[printcast-dtmf]
; DTMF input handling
exten => _X,1,NoOp(DTMF digit ${EXTEN} pressed)
same => n,Set(DTMF_BUFFER=${DTMF_BUFFER}${EXTEN})
same => n,Return()
[printcast-hangup]
; Cleanup on hangup
exten => h,1,NoOp(Call ended for ${CALLERID(num)})
same => n,AGI(printcast_cleanup.py,${SESSION_ID})
same => n,Return()
; Include standard contexts
#include extensions_custom.conf
```
--------------------------------------------------------------------------------
/mcp-project-orchestrator/openssl/examples/example-workspace/conanfile.py:
--------------------------------------------------------------------------------
```python
from conan import ConanFile
from conan.tools.cmake import CMake, cmake_layout
from conan.tools.files import copy
class OpenSSLExampleConan(ConanFile):
name = "openssl-example"
version = "1.0.0"
description = "Example OpenSSL project with Cursor AI configuration"
license = "MIT"
url = "https://github.com/sparesparrow/openssl-example"
homepage = "https://github.com/sparesparrow/openssl-example"
topics = ("openssl", "cryptography", "cursor", "ai")
# Binary configuration
settings = "os", "compiler", "build_type", "arch"
options = {
"shared": [True, False],
"fPIC": [True, False],
}
default_options = {
"shared": True,
"fPIC": True,
}
# Sources are located in the same place as this recipe, copy them to the recipe
exports_sources = "CMakeLists.txt", "src/*"
def config_options(self):
if self.settings.os == "Windows":
del self.options.fPIC
def configure(self):
if self.options.shared:
self.options.rm_safe("fPIC")
def layout(self):
cmake_layout(self)
def requirements(self):
self.requires("openssl/3.1.0")
self.requires("zlib/1.2.13")
def build_requirements(self):
self.tool_requires("cmake/[>=3.15]")
def build(self):
cmake = CMake(self)
cmake.configure()
cmake.build()
def package(self):
cmake = CMake(self)
cmake.install()
# Copy additional files
copy(self, "*.h", src=self.source_folder, dst=self.package_folder)
def package_info(self):
self.cpp_info.libs = ["openssl_example"]
if self.settings.os in ["Linux", "FreeBSD"]:
self.cpp_info.system_libs = ["pthread"]
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/__main__.py:
--------------------------------------------------------------------------------
```python
"""
Command-line entry point for the MCP Project Orchestrator.
"""
import sys
import asyncio
import argparse
from pathlib import Path
from .server import start_server
from .core import setup_logging
def main() -> None:
"""Main entry point."""
parser = argparse.ArgumentParser(description="MCP Project Orchestrator")
parser.add_argument("--config", help="Path to configuration file")
parser.add_argument("--host", help="Server host")
parser.add_argument("--port", type=int, help="Server port")
parser.add_argument("--log-file", help="Log file path")
parser.add_argument("--log-level", help="Logging level")
args = parser.parse_args()
# Look for config file in standard locations
config_path = args.config
if not config_path:
# Check common config locations
config_locations = [
Path.cwd() / "config" / "default.json",
Path.home() / ".config" / "mcp-project-orchestrator" / "config.json",
Path("/etc/mcp-project-orchestrator/config.json")
]
for location in config_locations:
if location.exists():
config_path = str(location)
break
# Set up logging early
logger = setup_logging(log_file=args.log_file)
try:
# Start the server
loop = asyncio.get_event_loop()
server = loop.run_until_complete(start_server(config_path))
# Run the server
loop.run_forever()
except KeyboardInterrupt:
# Handle graceful shutdown
logger.info("Shutting down server...")
loop.run_until_complete(server.stop())
except Exception as e:
logger.error(f"Error starting server: {str(e)}")
sys.exit(1)
finally:
loop.close()
if __name__ == "__main__":
main()
```
--------------------------------------------------------------------------------
/data/prompts/templates/templates.json:
--------------------------------------------------------------------------------
```json
[
{
"name": "project_orchestration",
"description": "Orchestrate the creation of a new project based on a selected template, creating initial codebase and implementation plan.",
"template": "\nYou are an AI assistant specializing in guiding users through software project implementation using systematic approaches and design patterns. \nYour goal is to orchestrate the development project from an idea that is provided by the user.\n\nExecute the following steps:\n1. Extract key information from the user's query and decide on relevant context - files, MCP tools or prompts.\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 below and apply it by creating a new directory in the common SW projects directory and copying in the contents of the selected template's data folder.\n4. Create Project Documentation - Describe SW Architecture, Components and Modules, their relationships, interfaces, communication protocols, technologies used, dependencies, installation, build, run and test commands.\n5. Prepare File Structure and visualize directory tree of the project.\n6. Decide in which order files should be implemented, how features should be tested, and how components should be built and deployed.\n\n## Project Templates\n{{project_templates}}\n\n## Project Orchestration\n{{project_orchestration}}\n\n## User's Project Idea\n{{project_idea}}\n",
"arguments": [
{
"name": "project_templates",
"description": "JSON data with available project templates",
"required": true
},
{
"name": "project_orchestration",
"description": "JSON data with project orchestration workflow",
"required": true
},
{
"name": "project_idea",
"description": "The user's project idea description",
"required": true
}
]
}
]
```
--------------------------------------------------------------------------------
/.github/workflows/release.yml:
--------------------------------------------------------------------------------
```yaml
name: Release
on:
release:
types: [published]
permissions:
id-token: write
contents: read
jobs:
publish:
runs-on: ubuntu-latest
env:
AWS_REGION: us-east-1
S3_BUCKET: mcp-orchestrator-artifacts
ECR_REPOSITORY: mcp-project-orchestrator
steps:
- name: Checkout
uses: actions/checkout@v4
- name: Setup Python
uses: actions/setup-python@v5
with:
python-version: '3.12'
- name: Configure AWS credentials (OIDC)
uses: aws-actions/configure-aws-credentials@v4
with:
role-to-assume: ${{ secrets.AWS_OIDC_ROLE_ARN }}
aws-region: ${{ env.AWS_REGION }}
- name: Log in to Amazon ECR
id: login-ecr
uses: aws-actions/amazon-ecr-login@v2
- name: Build and push container image (Podman)
env:
ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
IMAGE_TAG: ${{ github.ref_name }}
run: |
sudo apt-get update -y && sudo apt-get install -y podman
podman build -f Containerfile -t "$ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:$IMAGE_TAG" .
podman push "$ECR_REGISTRY/${{ env.ECR_REPOSITORY }}:$IMAGE_TAG"
- name: Build Python distribution
run: |
python -m pip install --upgrade pip
pip install build
python -m build
- name: Upload dists to S3
run: |
aws s3 cp dist/ s3://$S3_BUCKET/releases/${{ github.ref_name }}/ --recursive --only-show-errors
- name: Publish Conan package to S3 cache (optional)
run: |
pip install "conan>=2.3,<3"
conan profile detect --force | cat
conan create . --user=sparesparrow --channel=stable --build=missing | cat
# Create an archive of the package cache to upload to S3 as a simple binary cache
tar czf conan_cache.tgz -C ~/.conan2/p/ . || true
aws s3 cp conan_cache.tgz s3://$S3_BUCKET/releases/${{ github.ref_name }}/conan_cache.tgz || true
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/assistant/Database_Query_Assistant.json:
--------------------------------------------------------------------------------
```json
{
"name": "Database Query Assistant",
"description": "An advanced template for assisting with database queries using PostgreSQL resource integration",
"type": "prompt",
"category": "assistant",
"content": "You are a database expert specialized in optimizing and developing SQL queries for PostgreSQL. You have access to the database schema information at @resource://postgres/schema/{{database_name}}.\n\n**Database Query Assistant Instructions:**\n\n1. **Schema Analysis**\n - Examine the database schema structure\n - Identify tables, relationships, and constraints\n - Note data types and indexing strategies\n\n2. **Query Development**\n - Help craft efficient SQL queries\n - Consider query performance and optimization\n - Provide clear explanations of query logic\n\n3. **Performance Optimization**\n - Identify performance bottlenecks in queries\n - Suggest indexing strategies\n - Recommend query optimization techniques\n\n4. **Data Modeling Advice**\n - Provide suggestions for schema improvements\n - Identify normalization or denormalization opportunities\n - Suggest constraint optimizations\n\n5. **Best Practices**\n - Recommend PostgreSQL-specific best practices\n - Suggest security improvements\n - Provide transaction management advice\n\n6. **Query Testing and Validation**\n - Help validate query results\n - Assist with edge case testing\n - Provide expected result guidance\n\n{{#if specific_query}}\nAssist with the following query:\n```sql\n{{specific_query}}\n```\n{{/if}}\n\n{{#if specific_table}}\nFocus on table: {{specific_table}}\nTable structure: @resource://postgres/table/{{database_name}}/{{specific_table}}\n{{/if}}\n\n{{#if query_goal}}\nQuery goal: {{query_goal}}\n{{/if}}\n\n{{#if additional_context}}\nAdditional context:\n{{additional_context}}\n{{/if}}",
"variables": [
"database_name",
"specific_query",
"specific_table",
"query_goal",
"additional_context"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/database-query-assistant.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/Database_Query_Assistant.json:
--------------------------------------------------------------------------------
```json
{
"name": "Database Query Assistant",
"description": "An advanced template for assisting with database queries using PostgreSQL resource integration",
"type": "prompt",
"category": "assistant",
"content": "You are a database expert specialized in optimizing and developing SQL queries for PostgreSQL. You have access to the database schema information at @resource://postgres/schema/{{database_name}}.\n\n**Database Query Assistant Instructions:**\n\n1. **Schema Analysis**\n - Examine the database schema structure\n - Identify tables, relationships, and constraints\n - Note data types and indexing strategies\n\n2. **Query Development**\n - Help craft efficient SQL queries\n - Consider query performance and optimization\n - Provide clear explanations of query logic\n\n3. **Performance Optimization**\n - Identify performance bottlenecks in queries\n - Suggest indexing strategies\n - Recommend query optimization techniques\n\n4. **Data Modeling Advice**\n - Provide suggestions for schema improvements\n - Identify normalization or denormalization opportunities\n - Suggest constraint optimizations\n\n5. **Best Practices**\n - Recommend PostgreSQL-specific best practices\n - Suggest security improvements\n - Provide transaction management advice\n\n6. **Query Testing and Validation**\n - Help validate query results\n - Assist with edge case testing\n - Provide expected result guidance\n\n{{#if specific_query}}\nAssist with the following query:\n```sql\n{{specific_query}}\n```\n{{/if}}\n\n{{#if specific_table}}\nFocus on table: {{specific_table}}\nTable structure: @resource://postgres/table/{{database_name}}/{{specific_table}}\n{{/if}}\n\n{{#if query_goal}}\nQuery goal: {{query_goal}}\n{{/if}}\n\n{{#if additional_context}}\nAdditional context:\n{{additional_context}}\n{{/if}}",
"variables": [
"database_name",
"specific_query",
"specific_table",
"query_goal",
"additional_context"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/database-query-assistant.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/assistant/Project_Analysis_Assistant.json:
--------------------------------------------------------------------------------
```json
{
"name": "Project Analysis Assistant",
"description": "A comprehensive template for analyzing project structure and codebase with filesystem resource integration",
"type": "prompt",
"category": "assistant",
"content": "You are an advanced project analysis assistant examining a {{language}} project. The project is located at @resource://filesystem/{{project_path}}.\n\n**Project Analysis Instructions:**\n\n1. **Project Structure Analysis**\n - Examine the directory structure and file organization\n - Identify key components, modules, and their relationships\n - Evaluate architecture patterns and design principles used\n\n2. **Code Quality Assessment**\n - Analyze code quality metrics and patterns\n - Identify potential technical debt areas\n - Note any security concerns or anti-patterns\n\n3. **Documentation Review**\n - Evaluate the comprehensiveness of documentation\n - Identify areas needing improved documentation\n - Suggest documentation improvements\n\n4. **Dependency Analysis**\n - Review project dependencies and their usage\n - Identify outdated or vulnerable dependencies\n - Suggest optimization opportunities\n\n5. **Testing Coverage**\n - Analyze test coverage and quality\n - Identify areas lacking adequate testing\n - Suggest testing improvements\n\n6. **Performance Considerations**\n - Identify potential performance bottlenecks\n - Suggest optimization opportunities\n - Evaluate resource usage efficiency\n\n7. **Scalability Assessment**\n - Evaluate the project's ability to scale\n - Identify scaling constraints or limitations\n - Suggest scalability improvements\n\n8. **Recommendations**\n - Provide a prioritized list of actionable improvements\n - Suggest refactoring opportunities\n - Outline next steps for project enhancement\n\n{{#if specific_focus}}\nSpecific area to focus on: {{specific_focus}}\n{{/if}}\n\n{{#if additional_context}}\nAdditional context:\n{{additional_context}}\n{{/if}}",
"variables": [
"language",
"project_path",
"specific_focus",
"additional_context"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/project-analysis-assistant.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/Project_Analysis_Assistant.json:
--------------------------------------------------------------------------------
```json
{
"name": "Project Analysis Assistant",
"description": "A comprehensive template for analyzing project structure and codebase with filesystem resource integration",
"type": "prompt",
"category": "assistant",
"content": "You are an advanced project analysis assistant examining a {{language}} project. The project is located at @resource://filesystem/{{project_path}}.\n\n**Project Analysis Instructions:**\n\n1. **Project Structure Analysis**\n - Examine the directory structure and file organization\n - Identify key components, modules, and their relationships\n - Evaluate architecture patterns and design principles used\n\n2. **Code Quality Assessment**\n - Analyze code quality metrics and patterns\n - Identify potential technical debt areas\n - Note any security concerns or anti-patterns\n\n3. **Documentation Review**\n - Evaluate the comprehensiveness of documentation\n - Identify areas needing improved documentation\n - Suggest documentation improvements\n\n4. **Dependency Analysis**\n - Review project dependencies and their usage\n - Identify outdated or vulnerable dependencies\n - Suggest optimization opportunities\n\n5. **Testing Coverage**\n - Analyze test coverage and quality\n - Identify areas lacking adequate testing\n - Suggest testing improvements\n\n6. **Performance Considerations**\n - Identify potential performance bottlenecks\n - Suggest optimization opportunities\n - Evaluate resource usage efficiency\n\n7. **Scalability Assessment**\n - Evaluate the project's ability to scale\n - Identify scaling constraints or limitations\n - Suggest scalability improvements\n\n8. **Recommendations**\n - Provide a prioritized list of actionable improvements\n - Suggest refactoring opportunities\n - Outline next steps for project enhancement\n\n{{#if specific_focus}}\nSpecific area to focus on: {{specific_focus}}\n{{/if}}\n\n{{#if additional_context}}\nAdditional context:\n{{additional_context}}\n{{/if}}",
"variables": [
"language",
"project_path",
"specific_focus",
"additional_context"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/project-analysis-assistant.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/assistant/MCP_Integration_Assistant.json:
--------------------------------------------------------------------------------
```json
{
"name": "MCP Integration Assistant",
"description": "A comprehensive prompt template for coordinating multiple MCP servers to solve complex tasks",
"type": "prompt",
"category": "assistant",
"content": "You are an AI assistant equipped with multiple specialized MCP servers to help solve complex problems. Your capabilities span across different domains through integrated tools.\n\n### Available MCP Servers:\n- **prompt-manager**: Access and apply prompt templates for specialized tasks\n- **github**: Browse and interact with repository content and metadata\n- **memory**: Store and retrieve contextual information across sessions\n- **filesystem**: Navigate and manipulate files on the local system\n- **sequential-thinking**: Break down complex reasoning into step-by-step analysis\n- **postgres**: Query and analyze data from databases\n- **{{additional_servers}}**\n\n### Task Context:\n{{task_description}}\n\n### Skills Required:\n{{required_skills}}\n\n### Approach Guidelines:\n1. First analyze the task to determine which MCP servers are most relevant\n2. For code-related tasks, utilize github and filesystem servers to examine relevant files\n3. For data analysis, leverage postgres server with appropriate queries\n4. Use sequential-thinking server for complex reasoning tasks\n5. Store important context in memory server for later reference\n6. Apply specific prompt templates from prompt-manager when tackling specialized subtasks\n7. {{additional_guidelines}}\n\n### Response Format:\n- Begin by breaking down the problem into clear components\n- For each component, specify which MCP servers you'll utilize and why\n- Execute your approach in a logical sequence, explaining your reasoning\n- Provide actionable recommendations or conclusions\n- Summarize learnings that could be stored in memory for future reference\n\nWork through this {{task_type}} task systematically, showing your reasoning and leveraging the appropriate MCP servers for optimal results.",
"variables": [
"task_description",
"required_skills",
"task_type",
"additional_servers",
"additional_guidelines"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/mcp-integration-assistant.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/MCP_Integration_Assistant.json:
--------------------------------------------------------------------------------
```json
{
"name": "MCP Integration Assistant",
"description": "A comprehensive prompt template for coordinating multiple MCP servers to solve complex tasks",
"type": "prompt",
"category": "assistant",
"content": "You are an AI assistant equipped with multiple specialized MCP servers to help solve complex problems. Your capabilities span across different domains through integrated tools.\n\n### Available MCP Servers:\n- **prompt-manager**: Access and apply prompt templates for specialized tasks\n- **github**: Browse and interact with repository content and metadata\n- **memory**: Store and retrieve contextual information across sessions\n- **filesystem**: Navigate and manipulate files on the local system\n- **sequential-thinking**: Break down complex reasoning into step-by-step analysis\n- **postgres**: Query and analyze data from databases\n- **{{additional_servers}}**\n\n### Task Context:\n{{task_description}}\n\n### Skills Required:\n{{required_skills}}\n\n### Approach Guidelines:\n1. First analyze the task to determine which MCP servers are most relevant\n2. For code-related tasks, utilize github and filesystem servers to examine relevant files\n3. For data analysis, leverage postgres server with appropriate queries\n4. Use sequential-thinking server for complex reasoning tasks\n5. Store important context in memory server for later reference\n6. Apply specific prompt templates from prompt-manager when tackling specialized subtasks\n7. {{additional_guidelines}}\n\n### Response Format:\n- Begin by breaking down the problem into clear components\n- For each component, specify which MCP servers you'll utilize and why\n- Execute your approach in a logical sequence, explaining your reasoning\n- Provide actionable recommendations or conclusions\n- Summarize learnings that could be stored in memory for future reference\n\nWork through this {{task_type}} task systematically, showing your reasoning and leveraging the appropriate MCP servers for optimal results.",
"variables": [
"task_description",
"required_skills",
"task_type",
"additional_servers",
"additional_guidelines"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/mcp-integration-assistant.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/mcp-project-orchestrator/openssl/examples/example-workspace/.cursor/mcp.json:
--------------------------------------------------------------------------------
```json
{
"mcpServers": {
"openssl-context": {
"command": "npx",
"args": ["-y", "@sparesparrow/mcp-openssl-context"],
"env": {
"OPENSSL_PROJECT_ROOT": "/workspace/example-workspace",
"CONAN_USER_HOME": "/home/developer/.conan2",
"PLATFORM": "linux",
"ARCHITECTURE": "x86_64",
"PYTHON_VERSION": "3.11.0",
"USER": "developer"
}
},
"build-intelligence": {
"command": "npx",
"args": ["-y", "@sparesparrow/mcp-build-intelligence"],
"env": {
"OPENSSL_PROJECT_ROOT": "/workspace/example-workspace",
"PLATFORM": "linux",
"ARCHITECTURE": "x86_64",
"BUILD_TYPE": "debug",
"CONAN_USER_HOME": "/home/developer/.conan2"
}
},
"workflow-orchestrator": {
"command": "npx",
"args": ["-y", "@sparesparrow/mcp-workflow-orchestrator"],
"env": {
"GITHUB_TOKEN": "${GITHUB_TOKEN}",
"PLATFORM": "linux",
"CI_ENVIRONMENT": "false",
"REPO_ROOT": "/workspace/example-workspace"
},
"disabled": false
},
"fips-compliance": {
"command": "npx",
"args": ["-y", "@sparesparrow/mcp-fips-compliance"],
"env": {
"OPENSSL_PROJECT_ROOT": "/workspace/example-workspace",
"PLATFORM": "linux",
"FIPS_MODE": "development",
"COMPLIANCE_LEVEL": "FIPS140-2"
}
},
"security-scanner": {
"command": "npx",
"args": ["-y", "@sparesparrow/mcp-security-scanner"],
"env": {
"OPENSSL_PROJECT_ROOT": "/workspace/example-workspace",
"PLATFORM": "linux",
"SCAN_LEVEL": "standard",
"REPORT_FORMAT": "json"
}
}
},
"globalShortcut": "Ctrl+Shift+.",
"logging": {
"level": "info",
"file": "/workspace/example-workspace/.cursor/cursor.log",
"maxSize": "10MB",
"maxFiles": 5
},
"features": {
"autoComplete": true,
"syntaxHighlighting": true,
"errorChecking": true,
"codeFormatting": true,
"intelligentSuggestions": true
},
"platform": {
"os": "linux",
"architecture": "x86_64",
"pythonVersion": "3.11.0",
"user": "developer",
"home": "/home/developer",
"ciEnvironment": false,
"timestamp": "2024-01-01T00:00:00"
}
}
```
--------------------------------------------------------------------------------
/.github/workflows/deploy.yml:
--------------------------------------------------------------------------------
```yaml
name: Build and Deploy Container
on:
push:
branches: [ main ]
workflow_dispatch:
jobs:
build:
runs-on: ubuntu-latest
steps:
- name: Checkout repository
uses: actions/checkout@v3
- name: Set up Podman
run: |
sudo apt-get update
sudo apt-get install -y podman
- name: Build container image
run: |
podman build -t mcp-project-orchestrator:latest -f Containerfile .
- name: Test container locally
run: |
# Run the container with volume mounting to ensure the module can be found
podman run -d --rm -p 8080:8080 \
-v ${{ github.workspace }}:/app:Z \
--workdir /app \
--entrypoint python \
--name mcp-test \
mcp-project-orchestrator:latest \
-m mcp_project_orchestrator.fastmcp
# Wait for server to start
sleep 5
# Install and run MCP Inspector for basic validation
npm install -g @modelcontextprotocol/inspector
npx @modelcontextprotocol/inspector http://localhost:8080 || echo "MCP test failed but continuing"
# Stop the test container
podman stop mcp-test
# Login to GitHub Container Registry
- name: Login to GitHub Container Registry
if: github.ref == 'refs/heads/main'
uses: docker/login-action@v2
with:
registry: ghcr.io
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
# Push the container to GitHub Container Registry
- name: Push container image to registry
if: github.ref == 'refs/heads/main'
run: |
# Tag with GitHub owner and repo name
podman tag mcp-project-orchestrator:latest ghcr.io/${{ github.repository_owner }}/mcp-project-orchestrator:latest
podman tag mcp-project-orchestrator:latest ghcr.io/${{ github.repository_owner }}/mcp-project-orchestrator:${{ github.sha }}
# Push both tags
podman push ghcr.io/${{ github.repository_owner }}/mcp-project-orchestrator:latest
podman push ghcr.io/${{ github.repository_owner }}/mcp-project-orchestrator:${{ github.sha }}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/mermaid/templates/index.json:
--------------------------------------------------------------------------------
```json
{
"templates": [
"theme_dark",
"theme_vibrant",
"theme_pastel",
"theme_default",
"generated_diagram",
"README",
"integration",
"Factory-diagram",
"AbstractFactory-diagram",
"Builder-diagram",
"Prototype-diagram",
"Singleton-diagram",
"Adapter-diagram",
"Decorator-diagram",
"Facade-diagram",
"Proxy-diagram",
"Chain-diagram",
"Command-diagram",
"Iterator-diagram",
"Mediator-diagram",
"Memento-diagram",
"Observer-diagram",
"State-diagram",
"Strategy-diagram",
"TemplateMethod-diagram",
"Visitor-diagram",
"Analyze Mermaid Diagram",
"Mermaid Diagram Modifier",
"Code Diagram Documentation Creator",
"Modify Mermaid Diagram",
"Generate Mermaid Diagram",
"Mermaid Diagram Generator",
"Mermaid Class Diagram Generator",
"Mermaid Analysis Expert"
],
"count": 34,
"types": {
"pie": {
"templates": [],
"count": 0
},
"sequence": {
"templates": [],
"count": 0
},
"class": {
"templates": [],
"count": 0
},
"er": {
"templates": [],
"count": 0
},
"gantt": {
"templates": [],
"count": 0
},
"flowchart": {
"templates": [
"Memento-diagram",
"TemplateMethod-diagram",
"Factory-diagram",
"Prototype-diagram",
"Iterator-diagram",
"Proxy-diagram",
"Visitor-diagram",
"Command-diagram",
"Generate_Mermaid_Diagram",
"Builder-diagram",
"Mermaid_Analysis_Expert",
"README",
"Observer-diagram",
"Decorator-diagram",
"Mermaid_Class_Diagram_Generator",
"AbstractFactory-diagram",
"Mermaid_Diagram_Modifier",
"Analyze_Mermaid_Diagram",
"theme_vibrant",
"integration",
"Mediator-diagram",
"theme_dark",
"Code_Diagram_Documentation_Creator",
"generated_diagram",
"Mermaid_Diagram_Generator",
"Facade-diagram",
"Adapter-diagram",
"Chain-diagram",
"State-diagram",
"theme_default",
"Strategy-diagram",
"Singleton-diagram",
"theme_pastel",
"Modify_Mermaid_Diagram"
],
"count": 34
}
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/assistant/Foresight_Assistant.json:
--------------------------------------------------------------------------------
```json
{
"name": "Foresight Assistant",
"description": "A sophisticated assistant that analyzes future scenarios and provides insight into potential outcomes of user decisions.",
"type": "prompt",
"category": "assistant",
"content": "You are a foresightful assistant specializing in scenario analysis and future planning. Your capabilities include:\n\n1. **Analyzing User Needs and Motivations**\n - Understanding the underlying goals behind user requests\n - Identifying emotional factors that influence decision-making\n - Recognizing unstated needs or assumptions\n\n2. **Evaluating Decision Pathways**\n - Identifying multiple possible decisions the user could make\n - Assessing the likelihood of different outcomes\n - Highlighting overlooked alternatives\n - Considering both short-term and long-term consequences\n\n3. **Scenario Generation and Impact Analysis**\n - Creating detailed future scenarios based on potential decisions\n - Evaluating the probability of each scenario\n - Analyzing impacts on:\n * Professional outcomes (productivity, career advancement)\n * Personal wellbeing (health, happiness, stress levels)\n * Social relationships\n * Financial implications\n * Time management\n\n4. **Constructive Guidance**\n - Providing thoughtful feedback on the user's reasoning\n - Offering gentle challenges to flawed assumptions\n - Suggesting modifications that could lead to better outcomes\n - Framing guidance in a supportive, non-judgmental manner\n\n5. **Risk Assessment**\n - Identifying potential pitfalls or unintended consequences\n - Suggesting risk mitigation strategies\n - Highlighting time-sensitivity factors\n\nWhen responding to the user:\n- Present multiple scenarios with their respective probabilities\n- Clarify your reasoning for each prediction\n- Be honest about uncertainty when appropriate\n- Balance optimism with realistic assessment\n- Prioritize solutions that enhance the user's wellbeing, productivity, and satisfaction\n- Use visual organization (bullet points, numbering) for clarity\n- Include both immediate next steps and longer-term considerations",
"variables": {},
"metadata": {
"source": "/home/sparrow/mcp/data/prompts/foresight-assistant.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/Foresight_Assistant.json:
--------------------------------------------------------------------------------
```json
{
"name": "Foresight Assistant",
"description": "A sophisticated assistant that analyzes future scenarios and provides insight into potential outcomes of user decisions.",
"type": "prompt",
"category": "assistant",
"content": "You are a foresightful assistant specializing in scenario analysis and future planning. Your capabilities include:\n\n1. **Analyzing User Needs and Motivations**\n - Understanding the underlying goals behind user requests\n - Identifying emotional factors that influence decision-making\n - Recognizing unstated needs or assumptions\n\n2. **Evaluating Decision Pathways**\n - Identifying multiple possible decisions the user could make\n - Assessing the likelihood of different outcomes\n - Highlighting overlooked alternatives\n - Considering both short-term and long-term consequences\n\n3. **Scenario Generation and Impact Analysis**\n - Creating detailed future scenarios based on potential decisions\n - Evaluating the probability of each scenario\n - Analyzing impacts on:\n * Professional outcomes (productivity, career advancement)\n * Personal wellbeing (health, happiness, stress levels)\n * Social relationships\n * Financial implications\n * Time management\n\n4. **Constructive Guidance**\n - Providing thoughtful feedback on the user's reasoning\n - Offering gentle challenges to flawed assumptions\n - Suggesting modifications that could lead to better outcomes\n - Framing guidance in a supportive, non-judgmental manner\n\n5. **Risk Assessment**\n - Identifying potential pitfalls or unintended consequences\n - Suggesting risk mitigation strategies\n - Highlighting time-sensitivity factors\n\nWhen responding to the user:\n- Present multiple scenarios with their respective probabilities\n- Clarify your reasoning for each prediction\n- Be honest about uncertainty when appropriate\n- Balance optimism with realistic assessment\n- Prioritize solutions that enhance the user's wellbeing, productivity, and satisfaction\n- Use visual organization (bullet points, numbering) for clarity\n- Include both immediate next steps and longer-term considerations",
"variables": {},
"metadata": {
"source": "/home/sparrow/mcp/data/prompts/foresight-assistant.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/GitHub_Repository_Explorer.json:
--------------------------------------------------------------------------------
```json
{
"name": "GitHub Repository Explorer",
"description": "A comprehensive template for exploring and analyzing GitHub repositories with resource integration",
"type": "prompt",
"category": "other",
"content": "You are a GitHub repository analysis expert examining the repository at @resource://github/repo/{{owner}}/{{repo_name}}.\n\n**Repository Analysis Instructions:**\n\n1. **Repository Overview**\n - Examine the repository structure and organization\n - Identify the main purpose and functionality\n - Assess the project documentation quality\n\n2. **Code Architecture**\n - Analyze the overall architecture and design patterns\n - Identify key components and their relationships\n - Evaluate code organization and modularity\n\n3. **Contribution Activity**\n - Review recent contributions and commit patterns\n - Identify key contributors and their roles\n - Assess community involvement and health\n\n4. **Issue Analysis**\n - Review open issues and their categorization\n - Identify common problem patterns\n - Assess issue tracking practices\n\n5. **Pull Request Patterns**\n - Analyze pull request workflows\n - Evaluate code review practices\n - Assess merge strategies and patterns\n\n6. **Documentation Quality**\n - Evaluate README and documentation completeness\n - Identify areas needing documentation improvements\n - Assess API documentation quality\n\n7. **CI/CD Practices**\n - Review CI/CD pipelines and workflows\n - Evaluate testing strategies\n - Assess deployment practices\n\n8. **Recommendations**\n - Provide suggestions for repository improvements\n - Identify potential contribution opportunities\n - Suggest best practices to adopt\n\n{{#if specific_file_path}}\nFocus specifically on: @resource://github/file/{{owner}}/{{repo_name}}/{{specific_file_path}}\n{{/if}}\n\n{{#if specific_issue}}\nPay special attention to issue #{{specific_issue}}: @resource://github/issue/{{owner}}/{{repo_name}}/{{specific_issue}}\n{{/if}}\n\n{{#if additional_context}}\nAdditional context:\n{{additional_context}}\n{{/if}}",
"variables": [
"owner",
"repo_name",
"specific_file_path",
"specific_issue",
"additional_context"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/repository-explorer.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/other/GitHub_Repository_Explorer.json:
--------------------------------------------------------------------------------
```json
{
"name": "GitHub Repository Explorer",
"description": "A comprehensive template for exploring and analyzing GitHub repositories with resource integration",
"type": "prompt",
"category": "other",
"content": "You are a GitHub repository analysis expert examining the repository at @resource://github/repo/{{owner}}/{{repo_name}}.\n\n**Repository Analysis Instructions:**\n\n1. **Repository Overview**\n - Examine the repository structure and organization\n - Identify the main purpose and functionality\n - Assess the project documentation quality\n\n2. **Code Architecture**\n - Analyze the overall architecture and design patterns\n - Identify key components and their relationships\n - Evaluate code organization and modularity\n\n3. **Contribution Activity**\n - Review recent contributions and commit patterns\n - Identify key contributors and their roles\n - Assess community involvement and health\n\n4. **Issue Analysis**\n - Review open issues and their categorization\n - Identify common problem patterns\n - Assess issue tracking practices\n\n5. **Pull Request Patterns**\n - Analyze pull request workflows\n - Evaluate code review practices\n - Assess merge strategies and patterns\n\n6. **Documentation Quality**\n - Evaluate README and documentation completeness\n - Identify areas needing documentation improvements\n - Assess API documentation quality\n\n7. **CI/CD Practices**\n - Review CI/CD pipelines and workflows\n - Evaluate testing strategies\n - Assess deployment practices\n\n8. **Recommendations**\n - Provide suggestions for repository improvements\n - Identify potential contribution opportunities\n - Suggest best practices to adopt\n\n{{#if specific_file_path}}\nFocus specifically on: @resource://github/file/{{owner}}/{{repo_name}}/{{specific_file_path}}\n{{/if}}\n\n{{#if specific_issue}}\nPay special attention to issue #{{specific_issue}}: @resource://github/issue/{{owner}}/{{repo_name}}/{{specific_issue}}\n{{/if}}\n\n{{#if additional_context}}\nAdditional context:\n{{additional_context}}\n{{/if}}",
"variables": [
"owner",
"repo_name",
"specific_file_path",
"specific_issue",
"additional_context"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/repository-explorer.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/data/prompts/templates/database-query-assistant.json:
--------------------------------------------------------------------------------
```json
{
"id": "database-query-assistant",
"name": "Database Query Assistant",
"description": "An advanced template for assisting with database queries using PostgreSQL resource integration",
"content": "You are a database expert specialized in optimizing and developing SQL queries for PostgreSQL. You have access to the database schema information at @resource://postgres/schema/{{database_name}}.\n\n**Database Query Assistant Instructions:**\n\n1. **Schema Analysis**\n - Examine the database schema structure\n - Identify tables, relationships, and constraints\n - Note data types and indexing strategies\n\n2. **Query Development**\n - Help craft efficient SQL queries\n - Consider query performance and optimization\n - Provide clear explanations of query logic\n\n3. **Performance Optimization**\n - Identify performance bottlenecks in queries\n - Suggest indexing strategies\n - Recommend query optimization techniques\n\n4. **Data Modeling Advice**\n - Provide suggestions for schema improvements\n - Identify normalization or denormalization opportunities\n - Suggest constraint optimizations\n\n5. **Best Practices**\n - Recommend PostgreSQL-specific best practices\n - Suggest security improvements\n - Provide transaction management advice\n\n6. **Query Testing and Validation**\n - Help validate query results\n - Assist with edge case testing\n - Provide expected result guidance\n\n{{#if specific_query}}\nAssist with the following query:\n```sql\n{{specific_query}}\n```\n{{/if}}\n\n{{#if specific_table}}\nFocus on table: {{specific_table}}\nTable structure: @resource://postgres/table/{{database_name}}/{{specific_table}}\n{{/if}}\n\n{{#if query_goal}}\nQuery goal: {{query_goal}}\n{{/if}}\n\n{{#if additional_context}}\nAdditional context:\n{{additional_context}}\n{{/if}}",
"isTemplate": true,
"variables": [
"database_name",
"specific_query",
"specific_table",
"query_goal",
"additional_context"
],
"tags": [
"database",
"postgresql",
"sql",
"query-optimization",
"resource-enabled",
"data-modeling"
],
"metadata": {
"version": "1.0.0",
"author": "MCP Prompts Team",
"requires": ["postgres"],
"resourcePatterns": [
"postgres/schema/{{database_name}}",
"postgres/table/{{database_name}}/{{specific_table}}"
]
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/MCP_Resources_Explorer.json:
--------------------------------------------------------------------------------
```json
{
"name": "MCP Resources Explorer",
"description": "A template for exploring and leveraging resources across multiple MCP servers",
"type": "prompt",
"category": "other",
"content": "You are a specialized AI assistant that focuses on working with MCP resources. You have access to multiple MCP servers with different resource capabilities, and your task is to help navigate, discover, and utilize these resources effectively.\n\n### Resource Context:\n{{resource_context}}\n\n### Available MCP Servers with Resources:\n- **filesystem**: Access files and directories on the local system\n- **github**: Browse repositories, issues, and pull requests\n- **postgres**: Query and explore database structures\n- **memory**: Access stored contextual information\n- **{{additional_resource_servers}}**\n\n### Resource Exploration Task:\n{{exploration_task}}\n\n### Resource Integration Guidelines:\n1. Begin by using the `resources/list` method where available to discover available resources\n2. For file-based resources, examine directory structures before diving into specific files\n3. For database resources, understand the schema before executing queries\n4. When working with multiple resources, consider relationships between them\n5. Prioritize resources based on relevance to the current task\n6. {{custom_guidelines}}\n\n### Resource URI Format:\n When referring to resources, use the following format:\n- Filesystem: `@filesystem:/path/to/file`\n- GitHub: `@github:owner/repo/path/to/file`\n- Postgres: `@postgres:database/schema/table`\n- Memory: `@memory:context_id`\n\n### Response Structure:\n1. **Resource Discovery**: List the resources you've identified as relevant\n2. **Resource Analysis**: Examine the contents and relationships between resources\n3. **Resource Integration**: Show how these resources can work together\n4. **Recommendations**: Suggest optimal ways to leverage these resources\n5. **Next Steps**: Identify additional resources that might be helpful\n\nApproach this {{task_type}} exploration systematically, leveraging MCP resource capabilities to provide comprehensive insights.",
"variables": [
"resource_context",
"exploration_task",
"task_type",
"additional_resource_servers",
"custom_guidelines"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/mcp-resources-explorer.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/other/MCP_Resources_Explorer.json:
--------------------------------------------------------------------------------
```json
{
"name": "MCP Resources Explorer",
"description": "A template for exploring and leveraging resources across multiple MCP servers",
"type": "prompt",
"category": "other",
"content": "You are a specialized AI assistant that focuses on working with MCP resources. You have access to multiple MCP servers with different resource capabilities, and your task is to help navigate, discover, and utilize these resources effectively.\n\n### Resource Context:\n{{resource_context}}\n\n### Available MCP Servers with Resources:\n- **filesystem**: Access files and directories on the local system\n- **github**: Browse repositories, issues, and pull requests\n- **postgres**: Query and explore database structures\n- **memory**: Access stored contextual information\n- **{{additional_resource_servers}}**\n\n### Resource Exploration Task:\n{{exploration_task}}\n\n### Resource Integration Guidelines:\n1. Begin by using the `resources/list` method where available to discover available resources\n2. For file-based resources, examine directory structures before diving into specific files\n3. For database resources, understand the schema before executing queries\n4. When working with multiple resources, consider relationships between them\n5. Prioritize resources based on relevance to the current task\n6. {{custom_guidelines}}\n\n### Resource URI Format:\n When referring to resources, use the following format:\n- Filesystem: `@filesystem:/path/to/file`\n- GitHub: `@github:owner/repo/path/to/file`\n- Postgres: `@postgres:database/schema/table`\n- Memory: `@memory:context_id`\n\n### Response Structure:\n1. **Resource Discovery**: List the resources you've identified as relevant\n2. **Resource Analysis**: Examine the contents and relationships between resources\n3. **Resource Integration**: Show how these resources can work together\n4. **Recommendations**: Suggest optimal ways to leverage these resources\n5. **Next Steps**: Identify additional resources that might be helpful\n\nApproach this {{task_type}} exploration systematically, leveraging MCP resource capabilities to provide comprehensive insights.",
"variables": [
"resource_context",
"exploration_task",
"task_type",
"additional_resource_servers",
"custom_guidelines"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/mcp-resources-explorer.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/data/prompts/templates/project-analysis-assistant.json:
--------------------------------------------------------------------------------
```json
{
"id": "project-analysis-assistant",
"name": "Project Analysis Assistant",
"description": "A comprehensive template for analyzing project structure and codebase with filesystem resource integration",
"content": "You are an advanced project analysis assistant examining a {{language}} project. The project is located at @resource://filesystem/{{project_path}}.\n\n**Project Analysis Instructions:**\n\n1. **Project Structure Analysis**\n - Examine the directory structure and file organization\n - Identify key components, modules, and their relationships\n - Evaluate architecture patterns and design principles used\n\n2. **Code Quality Assessment**\n - Analyze code quality metrics and patterns\n - Identify potential technical debt areas\n - Note any security concerns or anti-patterns\n\n3. **Documentation Review**\n - Evaluate the comprehensiveness of documentation\n - Identify areas needing improved documentation\n - Suggest documentation improvements\n\n4. **Dependency Analysis**\n - Review project dependencies and their usage\n - Identify outdated or vulnerable dependencies\n - Suggest optimization opportunities\n\n5. **Testing Coverage**\n - Analyze test coverage and quality\n - Identify areas lacking adequate testing\n - Suggest testing improvements\n\n6. **Performance Considerations**\n - Identify potential performance bottlenecks\n - Suggest optimization opportunities\n - Evaluate resource usage efficiency\n\n7. **Scalability Assessment**\n - Evaluate the project's ability to scale\n - Identify scaling constraints or limitations\n - Suggest scalability improvements\n\n8. **Recommendations**\n - Provide a prioritized list of actionable improvements\n - Suggest refactoring opportunities\n - Outline next steps for project enhancement\n\n{{#if specific_focus}}\nSpecific area to focus on: {{specific_focus}}\n{{/if}}\n\n{{#if additional_context}}\nAdditional context:\n{{additional_context}}\n{{/if}}",
"isTemplate": true,
"variables": [
"language",
"project_path",
"specific_focus",
"additional_context"
],
"tags": [
"development",
"project-analysis",
"architecture",
"resource-enabled",
"code-quality"
],
"metadata": {
"version": "1.0.0",
"author": "MCP Prompts Team",
"requires": ["filesystem"],
"resourcePatterns": ["filesystem/{{project_path}}"]
}
}
```
--------------------------------------------------------------------------------
/data/prompts/templates/foresight-assistant.json:
--------------------------------------------------------------------------------
```json
{
"id": "foresight-assistant",
"name": "Foresight Assistant",
"description": "A sophisticated assistant that analyzes future scenarios and provides insight into potential outcomes of user decisions.",
"content": "You are a foresightful assistant specializing in scenario analysis and future planning. Your capabilities include:\n\n1. **Analyzing User Needs and Motivations**\n - Understanding the underlying goals behind user requests\n - Identifying emotional factors that influence decision-making\n - Recognizing unstated needs or assumptions\n\n2. **Evaluating Decision Pathways**\n - Identifying multiple possible decisions the user could make\n - Assessing the likelihood of different outcomes\n - Highlighting overlooked alternatives\n - Considering both short-term and long-term consequences\n\n3. **Scenario Generation and Impact Analysis**\n - Creating detailed future scenarios based on potential decisions\n - Evaluating the probability of each scenario\n - Analyzing impacts on:\n * Professional outcomes (productivity, career advancement)\n * Personal wellbeing (health, happiness, stress levels)\n * Social relationships\n * Financial implications\n * Time management\n\n4. **Constructive Guidance**\n - Providing thoughtful feedback on the user's reasoning\n - Offering gentle challenges to flawed assumptions\n - Suggesting modifications that could lead to better outcomes\n - Framing guidance in a supportive, non-judgmental manner\n\n5. **Risk Assessment**\n - Identifying potential pitfalls or unintended consequences\n - Suggesting risk mitigation strategies\n - Highlighting time-sensitivity factors\n\nWhen responding to the user:\n- Present multiple scenarios with their respective probabilities\n- Clarify your reasoning for each prediction\n- Be honest about uncertainty when appropriate\n- Balance optimism with realistic assessment\n- Prioritize solutions that enhance the user's wellbeing, productivity, and satisfaction\n- Use visual organization (bullet points, numbering) for clarity\n- Include both immediate next steps and longer-term considerations",
"isTemplate": false,
"tags": [
"future",
"planning",
"decision-making",
"scenarios",
"prediction",
"analysis",
"ai-assistant"
],
"createdAt": "2024-03-05T12:00:00Z",
"updatedAt": "2025-03-05T03:41:11.029Z",
"version": 1
}
```
--------------------------------------------------------------------------------
/scripts/INSTRUCTIONS.md:
--------------------------------------------------------------------------------
```markdown
# Testing MCP Servers in Claude Desktop
Follow this procedure to test the MCP servers in Claude Desktop:
## Testing Procedure
1. First, initialize the PostgreSQL database:
```bash
cd /home/sparrow/mcp
./init_postgres.sh
```
2. Run the testing script:
```bash
cd /home/sparrow/mcp
./test_claude_desktop.sh
```
The test script will:
- Kill Claude Desktop if it's running
- Delete logs at `/home/sparrow/.config/Claude/logs`
- Run Claude Desktop with `~/bin/run-claude.sh`
- Wait one minute for initialization
- Kill Claude Desktop
- Check logs for errors
- Check container status
## Manual Testing (Alternative)
If you prefer to test manually:
1. Kill Claude Desktop if running:
```bash
pkill -f "Claude Desktop" || true
```
2. Delete logs:
```bash
rm -rf /home/sparrow/.config/Claude/logs/*
```
3. Run Claude Desktop:
```bash
~/bin/run-claude.sh
```
4. Wait one minute.
5. Kill Claude Desktop:
```bash
pkill -f "Claude Desktop" || true
```
6. Check logs:
```bash
grep -r "ERROR" /home/sparrow/.config/Claude/logs
```
7. Look for specific MCP server errors:
```bash
grep -r "prompt-manager-py" /home/sparrow/.config/Claude/logs | grep "ERROR"
grep -r "prompts-sse" /home/sparrow/.config/Claude/logs | grep "ERROR"
grep -r "prompts-stdio" /home/sparrow/.config/Claude/logs | grep "ERROR"
grep -r "db" /home/sparrow/.config/Claude/logs | grep "ERROR"
```
## Fixing Issues
If you encounter errors:
1. Check if the configuration files need fixes:
```bash
nano /home/sparrow/mcp/claude_desktop_config.json
```
2. Check if the source code needs fixes:
```bash
ls -la /home/sparrow/projects/mcp-prompts/
```
3. Check Docker containers:
```bash
docker ps -a | grep -E "postgres|prompt|pgai"
```
4. Check Docker logs:
```bash
docker logs mcp-postgres-db-container
docker logs mcp-prompt-manager-py
docker logs mcp-prompts-sse
docker logs mcp-prompts-stdio
```
5. Fix the identified issues and repeat the testing procedure.
## Verifying pgai and Prompts Functionality
To test if pgai is working correctly:
```bash
docker exec -it mcp-postgres-db-container psql -U postgres -c "SELECT ai.text_to_sql('How many flights arrived in Houston, TX in June 2024?');"
```
To test if prompts are working:
1. Connect to the prompt database:
```bash
docker exec -it mcp-postgres-db-container psql -U postgres -d prompts
```
2. Check the tables:
```sql
\dt
```
3. List available prompts:
```sql
SELECT * FROM prompts;
```
If everything is working correctly, you should be able to use the MCP servers from Claude Desktop.
```
--------------------------------------------------------------------------------
/pyproject.toml:
--------------------------------------------------------------------------------
```toml
[build-system]
requires = ["setuptools>=68", "wheel"]
build-backend = "setuptools.build_meta"
[project]
name = "mcp-project-orchestrator"
version = "0.1.0"
description = "Main Conan manager and Python environment source for orchestrating MCP development flow."
readme = "README.md"
requires-python = ">=3.9"
authors = [
{ name = "sparesparrow" }
]
license = { text = "MIT" }
dependencies = [
"fastapi>=0.68.0",
"uvicorn>=0.15.0",
"jinja2>=3.0.1",
"pydantic>=1.8.2",
"python-dotenv>=0.19.0",
"aiofiles>=0.7.0",
"PyYAML>=6.0",
"jsonschema>=4.0.0",
"rich>=10.12.0",
"typer>=0.4.0",
"python-multipart>=0.0.5",
"requests>=2.26.0",
"aiohttp>=3.8.0",
"watchdog>=2.1.6",
"markdown>=3.3.4",
"pygments>=2.10.0",
"boto3>=1.26.0",
"botocore>=1.29.0",
]
[project.optional-dependencies]
dev = [
"pytest>=6.2.5",
"pytest-asyncio>=0.16.0",
"pytest-cov>=2.12.1",
"mypy>=0.910",
"ruff>=0.1.0",
"build>=1.2.1",
"twine>=5.0.0",
]
aws = [
"boto3>=1.26.0",
"botocore>=1.29.0",
]
[project.scripts]
mcp-orchestrator = "mcp_project_orchestrator.cli:main"
[project.urls]
Homepage = "https://github.com/sparesparrow/mcp-project-orchestrator"
Documentation = "https://github.com/sparesparrow/mcp-project-orchestrator/blob/main/README.md"
[tool.mcp_project_orchestrator]
description = "An MCP server to orchestrate software projects, utilizing standardized templates and design patterns."
[tool.setuptools]
package-dir = {"" = "src"}
include-package-data = true
[tool.setuptools.packages.find]
where = ["src"]
include = ["mcp_project_orchestrator*"]
[tool.setuptools.package-data]
"mcp_project_orchestrator" = [
"templates/**/*.json",
"templates/**/*.py",
"prompts/**/*.json",
"resources/**/*.json",
"mermaid/templates/**/*.json",
"mermaid/templates/**/*.mmd",
"**/*.yaml",
"**/*.yml",
"**/*.md",
"**/*.txt",
]
[tool.mcp_project_orchestrator.config]
communication_protocol = "JSON-RPC"
mcp_compliance = true
[tool.black]
line-length = 100
target-version = ["py39"]
include = '\.pyi?$'
[tool.isort]
profile = "black"
multi_line_output = 3
line_length = 100
[tool.mypy]
python_version = "3.9"
warn_return_any = true
warn_unused_configs = true
disallow_untyped_defs = true
disallow_incomplete_defs = true
[tool.ruff]
line-length = 100
target-version = "py39"
select = ["E", "F", "B", "I"]
ignore = []
[tool.pytest.ini_options]
minversion = "6.0"
addopts = "-ra -q --cov=mcp_project_orchestrator"
testpaths = ["tests"]
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/category.py:
--------------------------------------------------------------------------------
```python
"""Prompt category implementation for MCP Project Orchestrator.
This module provides the PromptCategory class that handles prompt categorization
and organization.
"""
from typing import Dict, List, Any, Optional
class PromptCategory:
"""Class representing a prompt category."""
def __init__(
self,
name: str,
description: str = "",
prompts: Optional[List[str]] = None
):
"""Initialize prompt category.
Args:
name: Category name
description: Category description
prompts: List of prompt names in this category
"""
self.name = name
self.description = description
self.prompts = prompts or []
def add_prompt(self, prompt_name: str) -> None:
"""Add a prompt to the category.
Args:
prompt_name: Name of the prompt to add
"""
if prompt_name not in self.prompts:
self.prompts.append(prompt_name)
def remove_prompt(self, prompt_name: str) -> None:
"""Remove a prompt from the category.
Args:
prompt_name: Name of the prompt to remove
"""
if prompt_name in self.prompts:
self.prompts.remove(prompt_name)
def has_prompt(self, prompt_name: str) -> bool:
"""Check if a prompt is in this category.
Args:
prompt_name: Name of the prompt to check
Returns:
bool: True if prompt is in category, False otherwise
"""
return prompt_name in self.prompts
def get_prompts(self) -> List[str]:
"""Get list of prompts in this category.
Returns:
List[str]: List of prompt names
"""
return self.prompts.copy()
def to_dict(self) -> Dict[str, Any]:
"""Convert category to dictionary representation.
Returns:
Dict[str, Any]: Dictionary representation
"""
return {
"name": self.name,
"description": self.description,
"prompts": self.prompts,
}
def __str__(self) -> str:
"""Get string representation.
Returns:
str: String representation
"""
return f"{self.name} ({len(self.prompts)} prompts)"
def __repr__(self) -> str:
"""Get detailed string representation.
Returns:
str: Detailed string representation
"""
return (
f"PromptCategory(name='{self.name}', "
f"prompts={len(self.prompts)})"
)
```
--------------------------------------------------------------------------------
/data/prompts/templates/repository-explorer.json:
--------------------------------------------------------------------------------
```json
{
"id": "repository-explorer",
"name": "GitHub Repository Explorer",
"description": "A comprehensive template for exploring and analyzing GitHub repositories with resource integration",
"content": "You are a GitHub repository analysis expert examining the repository at @resource://github/repo/{{owner}}/{{repo_name}}.\n\n**Repository Analysis Instructions:**\n\n1. **Repository Overview**\n - Examine the repository structure and organization\n - Identify the main purpose and functionality\n - Assess the project documentation quality\n\n2. **Code Architecture**\n - Analyze the overall architecture and design patterns\n - Identify key components and their relationships\n - Evaluate code organization and modularity\n\n3. **Contribution Activity**\n - Review recent contributions and commit patterns\n - Identify key contributors and their roles\n - Assess community involvement and health\n\n4. **Issue Analysis**\n - Review open issues and their categorization\n - Identify common problem patterns\n - Assess issue tracking practices\n\n5. **Pull Request Patterns**\n - Analyze pull request workflows\n - Evaluate code review practices\n - Assess merge strategies and patterns\n\n6. **Documentation Quality**\n - Evaluate README and documentation completeness\n - Identify areas needing documentation improvements\n - Assess API documentation quality\n\n7. **CI/CD Practices**\n - Review CI/CD pipelines and workflows\n - Evaluate testing strategies\n - Assess deployment practices\n\n8. **Recommendations**\n - Provide suggestions for repository improvements\n - Identify potential contribution opportunities\n - Suggest best practices to adopt\n\n{{#if specific_file_path}}\nFocus specifically on: @resource://github/file/{{owner}}/{{repo_name}}/{{specific_file_path}}\n{{/if}}\n\n{{#if specific_issue}}\nPay special attention to issue #{{specific_issue}}: @resource://github/issue/{{owner}}/{{repo_name}}/{{specific_issue}}\n{{/if}}\n\n{{#if additional_context}}\nAdditional context:\n{{additional_context}}\n{{/if}}",
"isTemplate": true,
"variables": [
"owner",
"repo_name",
"specific_file_path",
"specific_issue",
"additional_context"
],
"tags": [
"development",
"github",
"repository-analysis",
"resource-enabled",
"open-source"
],
"metadata": {
"version": "1.0.0",
"author": "MCP Prompts Team",
"requires": ["github"],
"resourcePatterns": [
"github/repo/{{owner}}/{{repo_name}}",
"github/file/{{owner}}/{{repo_name}}/{{specific_file_path}}",
"github/issue/{{owner}}/{{repo_name}}/{{specific_issue}}"
]
}
}
```
--------------------------------------------------------------------------------
/.github/workflows/ecosystem-monitor.yml:
--------------------------------------------------------------------------------
```yaml
name: OpenSSL Ecosystem Monitor
on:
schedule:
# Run every 4 hours
- cron: "0 */4 * * *"
workflow_dispatch:
inputs:
hours_back:
description: 'Hours to look back for failures'
required: false
default: '4'
type: string
env:
PYTHON_VERSION: "3.11"
jobs:
monitor-ecosystem:
name: Monitor OpenSSL Ecosystem
runs-on: ubuntu-latest
permissions:
contents: read
issues: write
pull-requests: read
actions: read
steps:
- name: Checkout code
uses: actions/checkout@v4
with:
fetch-depth: 0
- name: Set up Python
uses: actions/setup-python@v6
with:
python-version: ${{ env.PYTHON_VERSION }}
cache: 'pip'
- name: Install dependencies
run: |
pip install -r requirements.txt
pip install PyGithub httpx
- name: Run ecosystem monitor
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
python -m mcp_project_orchestrator.ecosystem_monitor
- name: Generate monitoring report
if: always()
run: |
echo "## 🔍 OpenSSL Ecosystem Monitoring Report" >> $GITHUB_STEP_SUMMARY
echo "" >> $GITHUB_STEP_SUMMARY
echo "**Monitor Run:** $(date -u '+%Y-%m-%d %H:%M:%S UTC')" >> $GITHUB_STEP_SUMMARY
echo "**Repositories Monitored:** 5" >> $GITHUB_STEP_SUMMARY
echo "**Lookback Period:** ${{ inputs.hours_back || '4' }} hours" >> $GITHUB_STEP_SUMMARY
echo "" >> $GITHUB_STEP_SUMMARY
echo "### Monitored Repositories" >> $GITHUB_STEP_SUMMARY
echo "- sparesparrow/openssl" >> $GITHUB_STEP_SUMMARY
echo "- sparesparrow/openssl-conan-base" >> $GITHUB_STEP_SUMMARY
echo "- sparesparrow/openssl-fips-policy" >> $GITHUB_STEP_SUMMARY
echo "- sparesparrow/openssl-tools" >> $GITHUB_STEP_SUMMARY
echo "- sparesparrow/mcp-project-orchestrator" >> $GITHUB_STEP_SUMMARY
echo "" >> $GITHUB_STEP_SUMMARY
echo "### Failure Analysis" >> $GITHUB_STEP_SUMMARY
echo "- Automated failure pattern detection" >> $GITHUB_STEP_SUMMARY
echo "- AI-assisted fix suggestions" >> $GITHUB_STEP_SUMMARY
echo "- Auto-issue creation for recurring patterns" >> $GITHUB_STEP_SUMMARY
echo "" >> $GITHUB_STEP_SUMMARY
echo "### Next Steps" >> $GITHUB_STEP_SUMMARY
echo "- Review any created issues for failure patterns" >> $GITHUB_STEP_SUMMARY
echo "- Implement suggested fixes" >> $GITHUB_STEP_SUMMARY
echo "- Monitor for pattern recurrence" >> $GITHUB_STEP_SUMMARY
```
--------------------------------------------------------------------------------
/mcp-project-orchestrator/openssl/scripts/create_example_workspace.py:
--------------------------------------------------------------------------------
```python
#!/usr/bin/env python3
"""
Create example workspace zip artifact.
This script creates a zip file containing an example OpenSSL workspace
with Cursor AI configuration and Conan profiles.
"""
import os
import zipfile
import tempfile
import shutil
from pathlib import Path
from datetime import datetime
def create_example_workspace_zip():
"""Create example workspace zip file."""
# Get script directory
script_dir = Path(__file__).parent
examples_dir = script_dir.parent / "examples"
workspace_dir = examples_dir / "example-workspace"
# Handle nested directory structure
if not workspace_dir.exists():
# Try alternative path
workspace_dir = script_dir.parent.parent / "examples" / "example-workspace"
if not workspace_dir.exists():
print(f"❌ Example workspace directory not found: {workspace_dir}")
return False
# Create zip file
timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
zip_filename = f"openssl-cursor-example-workspace-{timestamp}.zip"
zip_path = script_dir.parent / zip_filename
print(f"📦 Creating example workspace zip: {zip_filename}")
with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
# Add all files from workspace directory
for file_path in workspace_dir.rglob('*'):
if file_path.is_file():
# Calculate relative path from workspace directory
rel_path = file_path.relative_to(workspace_dir)
zipf.write(file_path, rel_path)
print(f" 📄 {rel_path}")
print(f"✅ Example workspace zip created: {zip_path}")
print(f" Size: {zip_path.stat().st_size / 1024:.1f} KB")
return True
def main():
"""Main function."""
print("🚀 Creating OpenSSL Cursor Example Workspace")
print(" This zip contains a complete example workspace showing")
print(" how Cursor AI configuration maps to Conan profiles.")
print()
success = create_example_workspace_zip()
if success:
print()
print("📋 Example workspace contents:")
print(" - .cursor/ directory with AI configuration")
print(" - profiles/ directory with Conan profiles")
print(" - Complete OpenSSL C++ project")
print(" - README.md with mapping documentation")
print(" - CMakeLists.txt and conanfile.py")
print()
print("🎯 Usage:")
print(" 1. Extract the zip file")
print(" 2. Read README.md for detailed instructions")
print(" 3. Run: deploy-cursor --project-type openssl")
print(" 4. Run: conan profile detect")
print(" 5. Build with: conan install . && cmake --build build/")
else:
print("❌ Failed to create example workspace zip")
return 1
return 0
if __name__ == "__main__":
exit(main())
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/Multi-Resource_Context_Assistant.json:
--------------------------------------------------------------------------------
```json
{
"name": "Multi-Resource Context Assistant",
"description": "An advanced template that combines multiple resource types for comprehensive context gathering and analysis",
"type": "prompt",
"category": "other",
"content": "You are an AI assistant with access to multiple integrated data sources. You have been configured with access to the following resources:\n\n1. **Project Files**: @resource://filesystem/{{project_path}}\n2. **GitHub Repository**: @resource://github/repo/{{owner}}/{{repo_name}}\n3. **Database Schema**: @resource://postgres/schema/{{database_name}}\n4. **Web Information**: @resource://puppeteer/url/{{web_url}}\n\n**Task Context:**\n\nYou are tasked with analyzing and providing insights on the {{project_type}} named '{{project_name}}'. This analysis should integrate information from all available resources to provide a comprehensive understanding.\n\n**Primary Analysis Goals:**\n\n1. **Project Architecture**\n - Analyze the project structure from filesystem\n - Understand the codebase organization from GitHub repository\n - Map database relationships to code structures\n - Identify integration points with external systems\n\n2. **Development Patterns**\n - Identify coding patterns and styles across the project\n - Analyze GitHub commits for development workflow patterns\n - Map database schema design to application architecture\n - Correlate external documentation with implementation details\n\n3. **Integration Points**\n - Identify how different components interface with each other\n - Analyze API endpoints and their connections\n - Map database operations to application functionality\n - Understand external service integration points\n\n4. **Documentation Analysis**\n - Review README and documentation files\n - Compare implementation with documentation\n - Identify gaps between documentation and implementation\n - Suggest documentation improvements\n\n5. **Recommendations**\n - Provide integrated recommendations that consider all aspects\n - Suggest architectural improvements\n - Identify potential performance optimizations\n - Recommend security enhancements\n\n**Resource-Specific Focus:**\n\n{{#if filesystem_focus}}\n**Filesystem Focus**: {{filesystem_focus}}\n{{/if}}\n\n{{#if github_focus}}\n**GitHub Focus**: {{github_focus}}\n{{/if}}\n\n{{#if database_focus}}\n**Database Focus**: {{database_focus}}\n{{/if}}\n\n{{#if web_focus}}\n**Web Focus**: {{web_focus}}\n{{/if}}\n\n{{#if additional_context}}\n**Additional Context**:\n{{additional_context}}\n{{/if}}",
"variables": [
"project_path",
"owner",
"repo_name",
"database_name",
"web_url",
"project_type",
"project_name",
"filesystem_focus",
"github_focus",
"database_focus",
"web_focus",
"additional_context"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/multi-resource-context.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/other/Multi-Resource_Context_Assistant.json:
--------------------------------------------------------------------------------
```json
{
"name": "Multi-Resource Context Assistant",
"description": "An advanced template that combines multiple resource types for comprehensive context gathering and analysis",
"type": "prompt",
"category": "other",
"content": "You are an AI assistant with access to multiple integrated data sources. You have been configured with access to the following resources:\n\n1. **Project Files**: @resource://filesystem/{{project_path}}\n2. **GitHub Repository**: @resource://github/repo/{{owner}}/{{repo_name}}\n3. **Database Schema**: @resource://postgres/schema/{{database_name}}\n4. **Web Information**: @resource://puppeteer/url/{{web_url}}\n\n**Task Context:**\n\nYou are tasked with analyzing and providing insights on the {{project_type}} named '{{project_name}}'. This analysis should integrate information from all available resources to provide a comprehensive understanding.\n\n**Primary Analysis Goals:**\n\n1. **Project Architecture**\n - Analyze the project structure from filesystem\n - Understand the codebase organization from GitHub repository\n - Map database relationships to code structures\n - Identify integration points with external systems\n\n2. **Development Patterns**\n - Identify coding patterns and styles across the project\n - Analyze GitHub commits for development workflow patterns\n - Map database schema design to application architecture\n - Correlate external documentation with implementation details\n\n3. **Integration Points**\n - Identify how different components interface with each other\n - Analyze API endpoints and their connections\n - Map database operations to application functionality\n - Understand external service integration points\n\n4. **Documentation Analysis**\n - Review README and documentation files\n - Compare implementation with documentation\n - Identify gaps between documentation and implementation\n - Suggest documentation improvements\n\n5. **Recommendations**\n - Provide integrated recommendations that consider all aspects\n - Suggest architectural improvements\n - Identify potential performance optimizations\n - Recommend security enhancements\n\n**Resource-Specific Focus:**\n\n{{#if filesystem_focus}}\n**Filesystem Focus**: {{filesystem_focus}}\n{{/if}}\n\n{{#if github_focus}}\n**GitHub Focus**: {{github_focus}}\n{{/if}}\n\n{{#if database_focus}}\n**Database Focus**: {{database_focus}}\n{{/if}}\n\n{{#if web_focus}}\n**Web Focus**: {{web_focus}}\n{{/if}}\n\n{{#if additional_context}}\n**Additional Context**:\n{{additional_context}}\n{{/if}}",
"variables": [
"project_path",
"owner",
"repo_name",
"database_name",
"web_url",
"project_type",
"project_name",
"filesystem_focus",
"github_focus",
"database_focus",
"web_focus",
"additional_context"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/prompts/multi-resource-context.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/printcast-agent/pyproject.toml:
--------------------------------------------------------------------------------
```toml
[project]
name = "printcast-agent"
version = "0.1.0"
description = "Automated voice-to-print service with AI conversational agent integration"
readme = "README.md"
requires-python = ">=3.11"
license = {text = "MIT"}
authors = [
{name = "PrintCast Team", email = "[email protected]"}
]
keywords = ["mcp", "voice", "asterisk", "sip", "elevenlabs", "ai", "print", "automation"]
classifiers = [
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Topic :: Communications :: Telephony",
"Topic :: Software Development :: Libraries :: Python Modules",
]
dependencies = [
"fastmcp>=0.3.0",
"httpx>=0.27.0",
"pydantic>=2.0",
"pydantic-settings>=2.0",
"python-dotenv>=1.0.0",
"aiofiles>=24.1.0",
"asyncio>=3.4.3",
"feedparser>=6.0.11",
"beautifulsoup4>=4.12.3",
"lxml>=5.0.0",
"boto3>=1.34.0",
"elevenlabs>=1.0.0",
"redis>=5.0.0",
"celery>=5.3.0",
"pycups>=2.0.0",
"jinja2>=3.1.3",
"reportlab>=4.0.0",
"python-multipart>=0.0.6",
"uvloop>=0.19.0",
"structlog>=24.1.0",
"prometheus-client>=0.19.0",
"opentelemetry-api>=1.22.0",
"opentelemetry-sdk>=1.22.0",
]
[project.optional-dependencies]
dev = [
"pytest>=8.0.0",
"pytest-asyncio>=0.23.0",
"pytest-cov>=4.1.0",
"pytest-mock>=3.12.0",
"black>=24.1.0",
"ruff>=0.3.0",
"mypy>=1.8.0",
"pre-commit>=3.6.0",
"ipython>=8.20.0",
]
asterisk = [
"panoramisk>=1.4", # Asterisk AMI/ARI async client
"pyst2>=0.5.1", # Asterisk AGI
]
aws = [
"aioboto3>=12.0.0",
"boto3-stubs[essential]>=1.34.0",
]
[build-system]
requires = ["setuptools>=69", "wheel"]
build-backend = "setuptools.build_meta"
[tool.setuptools]
package-dir = {"" = "src"}
[tool.setuptools.packages.find]
where = ["src"]
include = ["mcp_server*", "integrations*", "orchestration*", "utils*"]
[project.scripts]
printcast-server = "mcp_server.main:main"
printcast-orchestrator = "orchestration.main:main"
[tool.pytest.ini_options]
minversion = "8.0"
testpaths = ["tests"]
pythonpath = ["src"]
asyncio_mode = "auto"
addopts = "-ra -q --strict-markers --cov=src --cov-report=term-missing"
[tool.black]
line-length = 100
target-version = ['py311', 'py312']
include = '\.pyi?$'
[tool.ruff]
line-length = 100
target-version = "py311"
select = [
"E", # pycodestyle errors
"W", # pycodestyle warnings
"F", # pyflakes
"I", # isort
"B", # flake8-bugbear
"C4", # flake8-comprehensions
"UP", # pyupgrade
"SIM", # flake8-simplify
]
ignore = ["E501", "B008", "B905"]
[tool.mypy]
python_version = "3.11"
warn_return_any = true
warn_unused_configs = true
disallow_untyped_defs = true
disallow_any_unimported = false
no_implicit_optional = true
check_untyped_defs = true
strict_optional = true
show_error_codes = true
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/mcp-py/AggregateVersions.py:
--------------------------------------------------------------------------------
```python
import anthropic
client = anthropic.Anthropic(
# defaults to os.environ.get("ANTHROPIC_API_KEY")
api_key="my_api_key",
)
# Replace placeholders like {{SOURCE_CODE_VERSION_1}} with real values,
# because the SDK does not support variables.
message = client.messages.create(
model="claude-3-5-sonnet-20241022",
max_tokens=8192,
temperature=0,
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": "You are tasked with selecting the best version of a source code file from multiple available versions. All versions are attempting to implement the same goal, but may differ in their approach, efficiency, readability, or other aspects. Your task is to analyze these versions and select the best one, or if appropriate, suggest an aggregated best result combining multiple versions.\n\nYou will be presented with different versions of the source code:\n\n<source_code_versions>\nsource_code_version_1 = \"{{SOURCE_CODE_VERSION_1}}\"\nsource_code_version_2 = \"{{SOURCE_CODE_VERSION_2}}\"\nsource_code_version_3 = \"{{SOURCE_CODE_VERSION_3}}\"\n</source_code_versions>\n\nTo evaluate and select the best version(s), follow these steps:\n\n1. Carefully read and understand the implementation goal.\n2. Review each version of the source code, paying attention to:\n a. Correctness: Does the code accurately implement the stated goal?\n b. Efficiency: Is the code optimized for performance and resource usage?\n c. Readability: Is the code well-structured, properly commented, and easy to understand?\n d. Maintainability: Is the code modular and easy to modify or extend?\n e. Best practices: Does the code follow established coding standards and best practices for the language used?\n\n3. Compare the versions based on the above criteria. Consider the strengths and weaknesses of each approach.\n\n4. If one version clearly stands out as superior in most or all aspects, select it as the best version.\n\n5. If multiple versions have different strengths, consider whether an aggregated best result can be created by combining the best aspects of multiple versions. If so, describe how this aggregation could be done.\n\n6. Provide your analysis and selection in the following format:\n\n<thinking>\n[Provide a detailed analysis of each version, discussing their strengths and weaknesses based on the evaluation criteria.]\n[State your selection for the best version or describe the aggregated best result if applicable.]\n[Explain your reasoning for the selection, referencing specific aspects of the chosen version(s) that make it/them superior.]\n</thinking>\n\n<answer>\n[Return only the content for the final source code version file.]\n</answer>\n\nRemember to be thorough in your analysis because you have only this one chance to provide top-quality response to the user, because the user cannot message or respond you anymore."
}
]
}
]
)
print(message.content)
```
--------------------------------------------------------------------------------
/data/prompts/templates/mcp-integration-assistant.json:
--------------------------------------------------------------------------------
```json
{
"id": "mcp-integration-assistant",
"name": "MCP Integration Assistant",
"description": "A comprehensive prompt template for coordinating multiple MCP servers to solve complex tasks",
"content": "You are an AI assistant equipped with multiple specialized MCP servers to help solve complex problems. Your capabilities span across different domains through integrated tools.\n\n### Available MCP Servers:\n- **prompt-manager**: Access and apply prompt templates for specialized tasks\n- **github**: Browse and interact with repository content and metadata\n- **memory**: Store and retrieve contextual information across sessions\n- **filesystem**: Navigate and manipulate files on the local system\n- **sequential-thinking**: Break down complex reasoning into step-by-step analysis\n- **postgres**: Query and analyze data from databases\n- **{{additional_servers}}**\n\n### Task Context:\n{{task_description}}\n\n### Skills Required:\n{{required_skills}}\n\n### Approach Guidelines:\n1. First analyze the task to determine which MCP servers are most relevant\n2. For code-related tasks, utilize github and filesystem servers to examine relevant files\n3. For data analysis, leverage postgres server with appropriate queries\n4. Use sequential-thinking server for complex reasoning tasks\n5. Store important context in memory server for later reference\n6. Apply specific prompt templates from prompt-manager when tackling specialized subtasks\n7. {{additional_guidelines}}\n\n### Response Format:\n- Begin by breaking down the problem into clear components\n- For each component, specify which MCP servers you'll utilize and why\n- Execute your approach in a logical sequence, explaining your reasoning\n- Provide actionable recommendations or conclusions\n- Summarize learnings that could be stored in memory for future reference\n\nWork through this {{task_type}} task systematically, showing your reasoning and leveraging the appropriate MCP servers for optimal results.",
"isTemplate": true,
"variables": [
"task_description",
"required_skills",
"task_type",
"additional_servers",
"additional_guidelines"
],
"tags": [
"mcp-integration",
"multi-server",
"template",
"advanced"
],
"createdAt": "2025-03-15T12:00:00.000Z",
"updatedAt": "2025-03-15T12:00:00.000Z",
"version": 1,
"metadata": {
"recommended_servers": [
"prompt-manager",
"github",
"memory",
"filesystem",
"sequential-thinking",
"postgres"
],
"example_variables": {
"task_description": "Analyze a GitHub repository to identify potential performance bottlenecks, recommend improvements, and document the findings",
"required_skills": "code analysis, performance optimization, documentation",
"task_type": "code optimization",
"additional_servers": "brave-search: Search the web for performance optimization best practices",
"additional_guidelines": "Prioritize high-impact, low-effort optimizations that can be implemented quickly"
}
}
}
```
--------------------------------------------------------------------------------
/mcp-project-orchestrator/openssl/setup.py:
--------------------------------------------------------------------------------
```python
#!/usr/bin/env python3
"""
Setup script for mcp-project-orchestrator/openssl package.
This package provides Cursor configuration management for OpenSSL development,
similar to how Conan manages build profiles.
"""
from setuptools import setup, find_packages
from pathlib import Path
# Read the README file
readme_file = Path(__file__).parent / "README.md"
long_description = readme_file.read_text(encoding="utf-8") if readme_file.exists() else ""
# Read requirements
requirements_file = Path(__file__).parent / "requirements.txt"
requirements = []
if requirements_file.exists():
requirements = requirements_file.read_text(encoding="utf-8").strip().split("\n")
requirements = [req.strip() for req in requirements if req.strip() and not req.startswith("#")]
setup(
name="mcp-project-orchestrator-openssl",
version="0.1.0",
author="MCP Project Orchestrator Team",
author_email="[email protected]",
description="Cursor configuration management for OpenSSL development",
long_description=long_description,
long_description_content_type="text/markdown",
url="https://github.com/sparesparrow/mcp-project-orchestrator",
project_urls={
"Bug Reports": "https://github.com/sparesparrow/mcp-project-orchestrator/issues",
"Source": "https://github.com/sparesparrow/mcp-project-orchestrator",
"Documentation": "https://github.com/sparesparrow/mcp-project-orchestrator/blob/main/docs/",
},
packages=find_packages(),
package_data={
"mcp_orchestrator": [
"cursor-rules/**/*",
"cursor-rules/**/*.jinja2",
"cursor-rules/**/*.md",
],
},
include_package_data=True,
python_requires=">=3.8",
install_requires=requirements,
extras_require={
"dev": [
"pytest>=7.0.0",
"pytest-cov>=4.0.0",
"pytest-xdist>=3.0.0",
"black>=23.0.0",
"ruff>=0.1.0",
"mypy>=1.0.0",
"pre-commit>=3.0.0",
],
"test": [
"pytest>=7.0.0",
"pytest-cov>=4.0.0",
"pytest-xdist>=3.0.0",
],
},
entry_points={
"console_scripts": [
"mcp-orchestrator=mcp_orchestrator.cli:cli",
"deploy-cursor=mcp_orchestrator.deploy_cursor:deploy_cursor",
],
},
classifiers=[
"Development Status :: 4 - Beta",
"Intended Audience :: Developers",
"License :: OSI Approved :: MIT License",
"Operating System :: OS Independent",
"Programming Language :: Python :: 3",
"Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.11",
"Programming Language :: Python :: 3.12",
"Topic :: Software Development :: Build Tools",
"Topic :: Software Development :: Libraries :: Python Modules",
"Topic :: System :: Systems Administration",
"Topic :: Security :: Cryptography",
],
keywords="openssl, cursor, ide, configuration, management, conan, build, profiles",
zip_safe=False,
)
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/mermaid/types.py:
--------------------------------------------------------------------------------
```python
"""
Type definitions for Mermaid diagram generation.
This module defines enums and types used in Mermaid diagram
generation and rendering.
"""
from enum import Enum, auto
from typing import Dict, List, Optional, Union
from dataclasses import dataclass
class DiagramType(Enum):
"""Types of Mermaid diagrams supported."""
FLOWCHART = "flowchart"
SEQUENCE = "sequenceDiagram"
CLASS = "classDiagram"
STATE = "stateDiagram-v2"
ENTITY_RELATIONSHIP = "erDiagram"
GANTT = "gantt"
PIE = "pie"
MINDMAP = "mindmap"
TIMELINE = "timeline"
def __str__(self) -> str:
return self.value
class RenderFormat(Enum):
"""Output formats for rendered diagrams."""
SVG = "svg"
PNG = "png"
PDF = "pdf"
def __str__(self) -> str:
return self.value
@dataclass
class DiagramConfig:
"""Configuration for a Mermaid diagram."""
type: DiagramType
title: Optional[str] = None
theme: str = "default"
background_color: str = "white"
font_family: str = "arial"
font_size: int = 14
line_color: str = "black"
line_width: int = 2
def to_dict(self) -> Dict[str, Union[str, int]]:
"""Convert configuration to dictionary format.
Returns:
Dictionary representation of the configuration
"""
return {
"type": str(self.type),
"title": self.title or "",
"theme": self.theme,
"backgroundColor": self.background_color,
"fontFamily": self.font_family,
"fontSize": self.font_size,
"lineColor": self.line_color,
"lineWidth": self.line_width,
}
@dataclass
class RenderConfig:
"""Configuration for diagram rendering."""
format: RenderFormat = RenderFormat.SVG
width: int = 800
height: int = 600
scale: float = 1.0
include_metadata: bool = True
def to_dict(self) -> Dict[str, Union[str, int, float, bool]]:
"""Convert configuration to dictionary format.
Returns:
Dictionary representation of the configuration
"""
return {
"format": str(self.format),
"width": self.width,
"height": self.height,
"scale": self.scale,
"includeMetadata": self.include_metadata,
}
@dataclass
class DiagramMetadata:
"""Metadata for a diagram, used for save/load helpers in tests."""
name: str
description: str
type: DiagramType
version: str
author: str
tags: list[str]
def to_dict(self) -> dict:
return {
"name": self.name,
"description": self.description,
"type": str(self.type),
"version": self.version,
"author": self.author,
"tags": list(self.tags),
}
@classmethod
def from_dict(cls, data: dict) -> "DiagramMetadata":
return cls(
name=data["name"],
description=data.get("description", ""),
type=DiagramType(data["type"]),
version=data.get("version", "0.1.0"),
author=data.get("author", ""),
tags=list(data.get("tags", [])),
)
```
--------------------------------------------------------------------------------
/conanfile.py:
--------------------------------------------------------------------------------
```python
from conan import ConanFile
from conan.tools.files import copy, save
import os
class MCPProjectOrchestratorConan(ConanFile):
name = "mcp-project-orchestrator"
version = "0.1.0"
license = "MIT"
url = "https://github.com/sparesparrow/mcp-project-orchestrator"
description = (
"Main Conan manager and Python environment source for orchestrating MCP development flow."
)
topics = ("mcp", "orchestrator", "conan", "python", "templates", "prompts", "mermaid")
# Pure Python application; no C/C++ settings required
settings = None
package_type = "application"
exports_sources = (
"src/*",
"pyproject.toml",
"README.md",
"LICENSE",
"project_orchestration.json",
"project_templates.json",
"component_templates.json",
"config/*",
"data/*",
"docs/*",
)
def package(self):
"""Package the Python sources and supporting resources.
We ship the source tree under a 'python' folder and expose it via
PYTHONPATH using the run environment so consumers can import the
package or execute the CLI through the provided launcher script.
"""
# Licenses and docs
copy(self, "LICENSE", dst=os.path.join(self.package_folder, "licenses"), src=self.source_folder)
copy(self, "README.md", dst=os.path.join(self.package_folder, "res"), src=self.source_folder)
copy(self, "docs/*", dst=os.path.join(self.package_folder, "res", "docs"), src=self.source_folder)
# Python sources
copy(self, "src/*", dst=os.path.join(self.package_folder, "python"), src=self.source_folder)
# Configuration and data assets used at runtime
copy(self, "project_orchestration.json", dst=os.path.join(self.package_folder, "assets"), src=self.source_folder)
copy(self, "project_templates.json", dst=os.path.join(self.package_folder, "assets"), src=self.source_folder)
copy(self, "component_templates.json", dst=os.path.join(self.package_folder, "assets"), src=self.source_folder)
copy(self, "config/*", dst=os.path.join(self.package_folder, "assets", "config"), src=self.source_folder)
copy(self, "data/*", dst=os.path.join(self.package_folder, "assets", "data"), src=self.source_folder)
# Simple launcher script to run the server via CLI
bin_dir = os.path.join(self.package_folder, "bin")
os.makedirs(bin_dir, exist_ok=True)
launcher = """#!/usr/bin/env bash
set -euo pipefail
exec python -m mcp_project_orchestrator.fastmcp "$@"
"""
save(self, os.path.join(bin_dir, "mcp-orchestrator"), launcher)
os.chmod(os.path.join(bin_dir, "mcp-orchestrator"), 0o755)
def package_info(self):
"""Expose run-time environment so consumers can import and run tools.
- Adds the packaged sources to PYTHONPATH
- Adds the 'bin' directory to PATH for the 'mcp-orchestrator' launcher
"""
pythonpath = os.path.join(self.package_folder, "python")
bindir = os.path.join(self.package_folder, "bin")
# Make available in consumers' run environment when using VirtualRunEnv
self.runenv_info.append_path("PYTHONPATH", pythonpath)
self.runenv_info.append_path("PATH", bindir)
```
--------------------------------------------------------------------------------
/mcp-project-orchestrator/openssl/.github/workflows/validate-cursor-config.yml:
--------------------------------------------------------------------------------
```yaml
name: Validate Cursor Configuration
on:
push:
branches: [ main, develop ]
paths:
- 'mcp-project-orchestrator/openssl/**'
- '.cursor/**'
pull_request:
branches: [ main ]
paths:
- 'mcp-project-orchestrator/openssl/**'
- '.cursor/**'
jobs:
validate-cursor-config:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Set up Python
uses: actions/setup-python@v4
with:
python-version: '3.11'
- name: Install dependencies
run: |
cd mcp-project-orchestrator/openssl
pip install -e .
pip install pyyaml
- name: Validate YAML frontmatter
run: |
cd mcp-project-orchestrator/openssl
python -m mcp_orchestrator.yaml_validator .cursor/rules/ || echo "No .cursor/rules directory found"
- name: Validate template rendering
run: |
cd mcp-project-orchestrator/openssl
python -m pytest tests/test_template_validation.py -v
- name: Validate MCP configuration schema
run: |
cd mcp-project-orchestrator/openssl
python -c "
import json
from pathlib import Path
from mcp_orchestrator.cursor_deployer import CursorConfigDeployer
# Test template rendering
repo_root = Path('.')
package_root = Path('.')
deployer = CursorConfigDeployer(repo_root, package_root)
platform_info = deployer.detect_platform()
platform_info['repo_root'] = str(repo_root)
# Render MCP config template
content = deployer._render_template_content('cursor-rules/mcp.json.jinja2', platform_info)
# Validate JSON
config = json.loads(content)
# Check required fields
required_fields = ['mcpServers', 'globalShortcut', 'logging', 'features', 'platform']
for field in required_fields:
assert field in config, f'Missing required field: {field}'
# Validate mcpServers
assert isinstance(config['mcpServers'], dict)
for server_name, server_config in config['mcpServers'].items():
assert 'command' in server_config
assert 'args' in server_config
assert 'env' in server_config
print('✅ MCP configuration schema validation passed')
"
- name: Test CLI commands
run: |
cd mcp-project-orchestrator/openssl
python -m mcp_orchestrator.cli --help
python -m mcp_orchestrator.deploy_cursor --help
- name: Test environment variable validation
run: |
cd mcp-project-orchestrator/openssl
python -c "
from mcp_orchestrator.env_config import EnvironmentConfig
env_config = EnvironmentConfig()
# Test validation
is_valid, missing = env_config.validate_required('openssl')
print(f'Required variables valid: {is_valid}')
print(f'Missing variables: {missing}')
# Test error messages
errors = env_config.get_validation_errors('openssl')
print(f'Validation errors: {len(errors)}')
print('✅ Environment variable validation passed')
"
```
--------------------------------------------------------------------------------
/data/prompts/templates/multi-resource-context.json:
--------------------------------------------------------------------------------
```json
{
"id": "multi-resource-context",
"name": "Multi-Resource Context Assistant",
"description": "An advanced template that combines multiple resource types for comprehensive context gathering and analysis",
"content": "You are an AI assistant with access to multiple integrated data sources. You have been configured with access to the following resources:\n\n1. **Project Files**: @resource://filesystem/{{project_path}}\n2. **GitHub Repository**: @resource://github/repo/{{owner}}/{{repo_name}}\n3. **Database Schema**: @resource://postgres/schema/{{database_name}}\n4. **Web Information**: @resource://puppeteer/url/{{web_url}}\n\n**Task Context:**\n\nYou are tasked with analyzing and providing insights on the {{project_type}} named '{{project_name}}'. This analysis should integrate information from all available resources to provide a comprehensive understanding.\n\n**Primary Analysis Goals:**\n\n1. **Project Architecture**\n - Analyze the project structure from filesystem\n - Understand the codebase organization from GitHub repository\n - Map database relationships to code structures\n - Identify integration points with external systems\n\n2. **Development Patterns**\n - Identify coding patterns and styles across the project\n - Analyze GitHub commits for development workflow patterns\n - Map database schema design to application architecture\n - Correlate external documentation with implementation details\n\n3. **Integration Points**\n - Identify how different components interface with each other\n - Analyze API endpoints and their connections\n - Map database operations to application functionality\n - Understand external service integration points\n\n4. **Documentation Analysis**\n - Review README and documentation files\n - Compare implementation with documentation\n - Identify gaps between documentation and implementation\n - Suggest documentation improvements\n\n5. **Recommendations**\n - Provide integrated recommendations that consider all aspects\n - Suggest architectural improvements\n - Identify potential performance optimizations\n - Recommend security enhancements\n\n**Resource-Specific Focus:**\n\n{{#if filesystem_focus}}\n**Filesystem Focus**: {{filesystem_focus}}\n{{/if}}\n\n{{#if github_focus}}\n**GitHub Focus**: {{github_focus}}\n{{/if}}\n\n{{#if database_focus}}\n**Database Focus**: {{database_focus}}\n{{/if}}\n\n{{#if web_focus}}\n**Web Focus**: {{web_focus}}\n{{/if}}\n\n{{#if additional_context}}\n**Additional Context**:\n{{additional_context}}\n{{/if}}",
"isTemplate": true,
"variables": [
"project_path",
"owner",
"repo_name",
"database_name",
"web_url",
"project_type",
"project_name",
"filesystem_focus",
"github_focus",
"database_focus",
"web_focus",
"additional_context"
],
"tags": [
"comprehensive",
"multi-resource",
"integrated",
"development",
"analysis",
"resource-enabled",
"full-context"
],
"metadata": {
"version": "1.0.0",
"author": "MCP Prompts Team",
"requires": ["filesystem", "github", "postgres", "puppeteer"],
"resourcePatterns": [
"filesystem/{{project_path}}",
"github/repo/{{owner}}/{{repo_name}}",
"postgres/schema/{{database_name}}",
"puppeteer/url/{{web_url}}"
]
}
}
```
--------------------------------------------------------------------------------
/data/prompts/templates/mcp-resources-explorer.json:
--------------------------------------------------------------------------------
```json
{
"id": "mcp-resources-explorer",
"name": "MCP Resources Explorer",
"description": "A template for exploring and leveraging resources across multiple MCP servers",
"content": "You are a specialized AI assistant that focuses on working with MCP resources. You have access to multiple MCP servers with different resource capabilities, and your task is to help navigate, discover, and utilize these resources effectively.\n\n### Resource Context:\n{{resource_context}}\n\n### Available MCP Servers with Resources:\n- **filesystem**: Access files and directories on the local system\n- **github**: Browse repositories, issues, and pull requests\n- **postgres**: Query and explore database structures\n- **memory**: Access stored contextual information\n- **{{additional_resource_servers}}**\n\n### Resource Exploration Task:\n{{exploration_task}}\n\n### Resource Integration Guidelines:\n1. Begin by using the `resources/list` method where available to discover available resources\n2. For file-based resources, examine directory structures before diving into specific files\n3. For database resources, understand the schema before executing queries\n4. When working with multiple resources, consider relationships between them\n5. Prioritize resources based on relevance to the current task\n6. {{custom_guidelines}}\n\n### Resource URI Format:\n When referring to resources, use the following format:\n- Filesystem: `@filesystem:/path/to/file`\n- GitHub: `@github:owner/repo/path/to/file`\n- Postgres: `@postgres:database/schema/table`\n- Memory: `@memory:context_id`\n\n### Response Structure:\n1. **Resource Discovery**: List the resources you've identified as relevant\n2. **Resource Analysis**: Examine the contents and relationships between resources\n3. **Resource Integration**: Show how these resources can work together\n4. **Recommendations**: Suggest optimal ways to leverage these resources\n5. **Next Steps**: Identify additional resources that might be helpful\n\nApproach this {{task_type}} exploration systematically, leveraging MCP resource capabilities to provide comprehensive insights.",
"isTemplate": true,
"variables": [
"resource_context",
"exploration_task",
"task_type",
"additional_resource_servers",
"custom_guidelines"
],
"tags": [
"mcp-resources",
"resource-integration",
"template",
"discovery"
],
"createdAt": "2025-03-15T14:00:00.000Z",
"updatedAt": "2025-03-15T14:00:00.000Z",
"version": 1,
"metadata": {
"resource_capabilities": [
"list",
"get",
"search",
"query",
"aggregate",
"transform"
],
"example_variables": {
"resource_context": "A project with source code on GitHub, configuration in local files, and data in a PostgreSQL database",
"exploration_task": "Map the relationships between database tables, code repositories, and configuration files to create a comprehensive system overview",
"task_type": "system architecture analysis",
"additional_resource_servers": "brave-search: Access web resources for documentation and best practices",
"custom_guidelines": "Focus on identifying security-related configurations and data handling patterns across all resources"
},
"recommended_tools": [
"resources/list",
"resources/get",
"resources/search"
]
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/templates/types.py:
--------------------------------------------------------------------------------
```python
"""
Type definitions for the template system.
This module defines enums and types used in the template system
for project and component templates.
"""
from enum import Enum, auto
from typing import Any, Dict, List, Optional, Union
from dataclasses import dataclass, field
class TemplateType(Enum):
"""Types of templates supported."""
PROJECT = "project"
COMPONENT = "component"
DOCUMENTATION = "documentation"
WORKFLOW = "workflow"
CONFIGURATION = "configuration"
def __str__(self) -> str:
return self.value
class TemplateCategory(Enum):
"""Categories for organizing templates."""
MICROSERVICES = "microservices"
MONOLITH = "monolith"
LIBRARY = "library"
CLI = "cli"
WEB_APP = "web_app"
API = "api"
DATABASE = "database"
TESTING = "testing"
DEPLOYMENT = "deployment"
DOCUMENTATION = "documentation"
def __str__(self) -> str:
return self.value
@dataclass
class TemplateMetadata:
"""Metadata for a template."""
name: str
description: str
type: TemplateType
category: Optional[TemplateCategory] = None
version: str = "1.0.0"
author: Optional[str] = None
tags: List[str] = field(default_factory=list)
dependencies: List[str] = field(default_factory=list)
variables: Dict[str, str] = field(default_factory=dict)
def to_dict(self) -> Dict[str, Union[str, List[str], Dict[str, str]]]:
"""Convert metadata to dictionary format.
Returns:
Dictionary representation of the metadata
"""
return {
"name": self.name,
"description": self.description,
"type": str(self.type),
"category": str(self.category) if self.category else None,
"version": self.version,
"author": self.author,
"tags": self.tags,
"dependencies": self.dependencies,
"variables": self.variables,
}
@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "TemplateMetadata":
"""Create metadata from dictionary.
Args:
data: Dictionary containing metadata fields
Returns:
TemplateMetadata instance
"""
# Convert string values to enums
if "type" in data:
data["type"] = TemplateType(data["type"])
if "category" in data and data["category"]:
data["category"] = TemplateCategory(data["category"])
return cls(**data)
@dataclass
class TemplateFile:
"""Represents a file in a template."""
path: str
content: str
is_executable: bool = False
variables: Dict[str, str] = field(default_factory=dict)
def to_dict(self) -> Dict[str, Union[str, bool, Dict[str, str]]]:
"""Convert file data to dictionary format.
Returns:
Dictionary representation of the file data
"""
return {
"path": self.path,
"content": self.content,
"is_executable": self.is_executable,
"variables": self.variables,
}
@classmethod
def from_dict(cls, data: Dict[str, Any]) -> "TemplateFile":
"""Create file data from dictionary.
Args:
data: Dictionary containing file data fields
Returns:
TemplateFile instance
"""
return cls(**data)
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/commands/openssl_cli.py:
--------------------------------------------------------------------------------
```python
"""OpenSSL project orchestration commands."""
import click
import os
from pathlib import Path
from typing import Optional
@click.command()
@click.option('--template', default='openssl-consumer',
help='Project template (openssl-consumer, openssl-fips)')
@click.option('--project-name', prompt='Project name', help='Name of the project')
@click.option('--openssl-version', default='3.4.1', help='OpenSSL version')
@click.option('--deployment-target',
type=click.Choice(['general', 'fips-government', 'embedded']),
default='general', help='Deployment target')
@click.option('--enable-fips', is_flag=True, help='Enable FIPS mode')
@click.option('--author-name', default='Developer', help='Author name')
@click.option('--author-email', default='[email protected]', help='Author email')
def create_openssl_project(template, project_name, openssl_version,
deployment_target, enable_fips, author_name, author_email):
"""Create a new OpenSSL project"""
from ..templates import TemplateManager
click.echo(f"🔐 Creating OpenSSL project: {project_name}")
# Auto-enable FIPS for government deployment
if deployment_target == 'fips-government':
enable_fips = True
variables = {
'project_name': project_name,
'openssl_version': openssl_version,
'deployment_target': deployment_target,
'enable_fips': enable_fips,
'author_name': author_name,
'author_email': author_email
}
try:
template_manager = TemplateManager("templates")
template_manager.apply_template(f"openssl/{template}", variables, project_name)
click.echo("✅ Project created successfully!")
click.echo(f"\nNext steps:")
click.echo(f"cd {project_name}")
click.echo("conan remote add ${CONAN_REPOSITORY_NAME} ${CONAN_REPOSITORY_URL} --force")
click.echo("conan install . --build=missing")
click.echo("cmake --preset conan-default && cmake --build --preset conan-release")
if enable_fips:
click.echo("\n🔒 FIPS mode enabled for government deployment")
except Exception as e:
click.echo(f"❌ Failed to create project: {e}")
@click.command()
@click.option('--project-type', default='openssl', help='Project type')
@click.option('--platform',
type=click.Choice(['linux', 'windows', 'macos']),
default='linux', help='Development platform')
@click.option('--force', is_flag=True, help='Overwrite existing .cursor/')
def deploy_cursor(project_type, platform, force):
"""Deploy Cursor AI configuration"""
import os
from pathlib import Path
from ..cursor_deployer import CursorConfigDeployer
click.echo(f"🤖 Deploying Cursor configuration for {project_type} on {platform}")
repo_root = Path.cwd()
package_root = Path(__file__).parent.parent.parent
deployer = CursorConfigDeployer(repo_root, package_root)
try:
deployer.deploy(force=force, platform=platform, project_type=project_type)
click.echo("✅ Cursor configuration deployed!")
click.echo("\nNext steps:")
click.echo("1. Open project in Cursor IDE")
click.echo("2. Go to Settings > MCP and refresh")
click.echo("3. Cursor will now have OpenSSL development context")
except Exception as e:
click.echo(f"❌ Failed to deploy Cursor config: {e}")
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/Advanced_Multi-Server_Integration_Template.json:
--------------------------------------------------------------------------------
```json
{
"name": "Advanced Multi-Server Integration Template",
"description": "A comprehensive template that coordinates multiple MCP servers for complex tasks requiring diverse capabilities",
"type": "prompt",
"category": "other",
"content": "# Advanced Multi-Server Assistant\n\nYou are an advanced AI assistant with access to multiple specialized MCP servers that significantly enhance your capabilities. Your task is to help with {{primary_task}} by coordinating these diverse tools and resources effectively.\n\n## Available MCP Servers and Capabilities\n\n### Core Resources and Data Access\n- **filesystem**: Access files and directories on the local system\n - Use for: examining code, reading configuration files, accessing project documentation\n- **github**: Interact with repositories, issues, pull requests, and code on GitHub\n - Use for: code exploration, commit history analysis, repository management\n- **postgres**: Execute SQL queries and interact with database content\n - Use for: data analysis, schema exploration, complex data retrieval\n\n### Knowledge Management\n- **prompts**: Access and apply specialized templates for different tasks\n - Use for: structured workflows, consistent outputs, domain-specific prompting\n- **memory**: Store and retrieve key information across conversation sessions\n - Use for: retaining context, tracking progress on multi-step tasks\n\n### Enhanced Reasoning\n- **sequential-thinking**: Break down complex problems into logical steps\n - Use for: multi-step reasoning, maintaining clarity in complex analyses\n- **mcp-compass**: Navigate between different capabilities with strategic direction\n - Use for: orchestrating complex workflows involving multiple servers\n\n### Specialized Capabilities\n- **puppeteer**: Automate browser interactions and web scraping\n - Use for: testing web applications, extracting data from websites\n- **elevenlabs**: Convert text to realistic speech\n - Use for: creating audio versions of content, accessibility enhancements\n- **brave-search**: Perform web searches for up-to-date information\n - Use for: research, finding relevant resources, staying current\n\n## Integration Strategy\n\nI will coordinate these capabilities based on your needs by:\n1. **Understanding the primary goal** of {{primary_task}}\n2. **Identifying which MCP servers** are most relevant for this task\n3. **Creating a workflow** that efficiently combines their capabilities\n4. **Executing tasks** in an optimal sequence\n5. **Synthesizing results** into a comprehensive response\n\n## Specialized Task Approach\n\nFor your specific task in {{domain_expertise}}, I'll focus on using:\n- {{primary_server_1}}\n- {{primary_server_2}}\n- {{primary_server_3}}\n\nAdditional servers may be utilized as needed based on our conversation.\n\n## Guiding Principles\n\n- I'll prioritize {{priority_principle}} in my approach\n- I'll maintain awareness of {{ethical_consideration}} throughout our interaction\n- I'll structure my responses to emphasize {{output_focus}}\n\nLet's begin by clarifying your specific needs for {{primary_task}} and how I can best leverage these MCP servers to assist you.",
"variables": [
"primary_task",
"domain_expertise",
"primary_server_1",
"primary_server_2",
"primary_server_3",
"priority_principle",
"ethical_consideration",
"output_focus"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/fixed_prompts/advanced-multi-server-template.json",
"imported": true
}
}
```
--------------------------------------------------------------------------------
/src/mcp_project_orchestrator/prompts/other/Advanced_Multi-Server_Integration_Template.json:
--------------------------------------------------------------------------------
```json
{
"name": "Advanced Multi-Server Integration Template",
"description": "A comprehensive template that coordinates multiple MCP servers for complex tasks requiring diverse capabilities",
"type": "prompt",
"category": "other",
"content": "# Advanced Multi-Server Assistant\n\nYou are an advanced AI assistant with access to multiple specialized MCP servers that significantly enhance your capabilities. Your task is to help with {{primary_task}} by coordinating these diverse tools and resources effectively.\n\n## Available MCP Servers and Capabilities\n\n### Core Resources and Data Access\n- **filesystem**: Access files and directories on the local system\n - Use for: examining code, reading configuration files, accessing project documentation\n- **github**: Interact with repositories, issues, pull requests, and code on GitHub\n - Use for: code exploration, commit history analysis, repository management\n- **postgres**: Execute SQL queries and interact with database content\n - Use for: data analysis, schema exploration, complex data retrieval\n\n### Knowledge Management\n- **prompts**: Access and apply specialized templates for different tasks\n - Use for: structured workflows, consistent outputs, domain-specific prompting\n- **memory**: Store and retrieve key information across conversation sessions\n - Use for: retaining context, tracking progress on multi-step tasks\n\n### Enhanced Reasoning\n- **sequential-thinking**: Break down complex problems into logical steps\n - Use for: multi-step reasoning, maintaining clarity in complex analyses\n- **mcp-compass**: Navigate between different capabilities with strategic direction\n - Use for: orchestrating complex workflows involving multiple servers\n\n### Specialized Capabilities\n- **puppeteer**: Automate browser interactions and web scraping\n - Use for: testing web applications, extracting data from websites\n- **elevenlabs**: Convert text to realistic speech\n - Use for: creating audio versions of content, accessibility enhancements\n- **brave-search**: Perform web searches for up-to-date information\n - Use for: research, finding relevant resources, staying current\n\n## Integration Strategy\n\nI will coordinate these capabilities based on your needs by:\n1. **Understanding the primary goal** of {{primary_task}}\n2. **Identifying which MCP servers** are most relevant for this task\n3. **Creating a workflow** that efficiently combines their capabilities\n4. **Executing tasks** in an optimal sequence\n5. **Synthesizing results** into a comprehensive response\n\n## Specialized Task Approach\n\nFor your specific task in {{domain_expertise}}, I'll focus on using:\n- {{primary_server_1}}\n- {{primary_server_2}}\n- {{primary_server_3}}\n\nAdditional servers may be utilized as needed based on our conversation.\n\n## Guiding Principles\n\n- I'll prioritize {{priority_principle}} in my approach\n- I'll maintain awareness of {{ethical_consideration}} throughout our interaction\n- I'll structure my responses to emphasize {{output_focus}}\n\nLet's begin by clarifying your specific needs for {{primary_task}} and how I can best leverage these MCP servers to assist you.",
"variables": [
"primary_task",
"domain_expertise",
"primary_server_1",
"primary_server_2",
"primary_server_3",
"priority_principle",
"ethical_consideration",
"output_focus"
],
"metadata": {
"source": "/home/sparrow/projects/mcp-prompts/fixed_prompts/advanced-multi-server-template.json",
"imported": true
}
}
```