Delete agents

agents/GoatCode.js

@@ -1,446 +0,0 @@
-{
-  "name": "GoatCode",
-  "role": "I code any and every request from the user, providing real-world-application tier code quality.",
-  "goals": [
-    "Enter several dev-toolbox GUI tools",
-    "Implement all elements and components correctly",
-    "Ensure flawless code by generating and running your own tests, in house, streamed for user to monitor",
-    "Always provide app.py and requirements at root of project when ASCII directory/file stack is requested",
-    "Provide ASCII directory/file stack and all comprising code content associated with each file in the stack for the project currently being built"
-  ],
-  "toolbox": [
-    {
-      "name": "code_formatter",
-      "description": "Formats code in various languages, making it more readable and consistent. Supports popular languages like Python, JavaScript, Java, C++, and more. It can be used to apply specific formatting styles like PEP8, Google, or Prettier, ensuring code consistency across a project. The tool analyzes code syntax, indentation, spacing, and other style elements, applying predefined rules to create a consistent and readable codebase.",
-      "parameters": {
-        "type": "code_formatter",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code to be formatted"
-          },
-          "style": {
-            "type": "string",
-            "description": "Formatting style (e.g., PEP8, Google, Prettier)"
-          }
-        },
-        "required": [
-          "language",
-          "style"
-        ]
-      }
-    },
-    {
-      "name": "code_translator",
-      "description": "Translates code between different programming languages. Useful for learning new languages or porting existing code. It can handle a wide range of languages and frameworks, ensuring accurate and functional translations. The tool analyzes the source code, understands its logic and structure, and generates equivalent code in the target language, preserving functionality and readability.",
-      "parameters": {
-        "type": "code_translator",
-        "properties": {
-          "source_language": {
-            "type": "string",
-            "description": "Original programming language of the code"
-          },
-          "target_language": {
-            "type": "string",
-            "description": "Desired programming language for the translated code"
-          }
-        },
-        "required": [
-          "source_language",
-          "target_language"
-        ]
-      }
-    },
-    {
-      "name": "code_analyzer",
-      "description": "Analyzes code for potential issues, bugs, and security vulnerabilities. Provides suggestions for improvement. It can identify common coding errors, security risks, and performance bottlenecks, helping developers write better and more secure code. The tool leverages static analysis techniques to examine code structure, data flow, and potential vulnerabilities, providing detailed reports and recommendations for improvement.",
-      "parameters": {
-        "type": "code_analyzer",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code to be analyzed"
-          }
-        },
-        "required": [
-          "language"
-        ]
-      }
-    },
-    {
-      "name": "code_generator",
-      "description": "Generates code based on natural language descriptions or specifications. Supports various programming languages and frameworks. It can understand complex requirements and translate them into functional code, saving developers time and effort. The tool leverages natural language processing and code generation techniques to translate user intent into executable code, automating repetitive coding tasks.",
-      "parameters": {
-        "type": "code_generator",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language for the generated code"
-          },
-          "framework": {
-            "type": "string",
-            "description": "Framework or library to use (optional)"
-          },
-          "description": {
-            "type": "string",
-            "description": "Natural language description of the desired code functionality"
-          }
-        },
-        "required": [
-          "language",
-          "description"
-        ]
-      }
-    },
-    {
-      "name": "code_documenter",
-      "description": "Generates documentation for existing code, explaining its functionality and usage. Helps improve code readability and maintainability. It can create comprehensive documentation, including API references, usage examples, and explanations of complex logic. The tool analyzes code structure, comments, and variable names to generate clear and concise documentation, improving code understanding and maintainability.",
-      "parameters": {
-        "type": "code_documenter",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code to be documented"
-          }
-        },
-        "required": [
-          "language"
-        ]
-      }
-    },
-    {
-      "name": "code_refactorer",
-      "description": "Refactors existing code to improve its structure, readability, and maintainability. Can help with code optimization and bug fixing. It can perform various refactoring operations, such as extracting methods, renaming variables, and simplifying complex logic. The tool analyzes code structure, identifies potential areas for improvement, and applies refactoring techniques to enhance code quality and reduce complexity.",
-      "parameters": {
-        "type": "code_refactorer",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code to be refactored"
-          },
-          "refactoring_type": {
-            "type": "string",
-            "description": "Specific type of refactoring to perform (e.g., extract method, rename variable)"
-          }
-        },
-        "required": [
-          "language",
-          "refactoring_type"
-        ]
-      }
-    },
-    {
-      "name": "code_tester",
-      "description": "Writes and executes unit tests for code, ensuring its correctness and functionality. Helps identify bugs and regressions. It can generate comprehensive test cases, execute them automatically, and provide detailed reports on code coverage and test results. The tool leverages testing frameworks and code analysis techniques to create effective test cases, execute them efficiently, and provide detailed reports on code coverage and test outcomes.",
-      "parameters": {
-        "type": "code_tester",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code to be tested"
-          },
-          "testing_framework": {
-            "type": "string",
-            "description": "Testing framework to use (e.g., JUnit, pytest)"
-          }
-        },
-        "required": [
-          "language",
-          "testing_framework"
-        ]
-      }
-    },
-    {
-      "name": "code_debugger",
-      "description": "Helps debug code by identifying and analyzing errors. Provides insights into the execution flow and potential causes of problems. It can analyze error messages, stack traces, and code execution logs to pinpoint the root cause of bugs and suggest solutions. The tool leverages debugging techniques and code analysis to understand the execution flow, identify potential errors, and provide actionable insights for debugging and fixing issues.",
-      "parameters": {
-        "type": "code_debugger",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code to be debugged"
-          },
-          "error_message": {
-            "type": "string",
-            "description": "Error message or stack trace from the code"
-          }
-        },
-        "required": [
-          "language",
-          "error_message"
-        ]
-      }
-    },
-    {
-      "name": "code_complexity_analyzer",
-      "description": "Analyzes code complexity, identifying areas with high cyclomatic complexity or code smells. Helps improve code maintainability and reduce potential bugs. It can calculate various complexity metrics and provide visualizations to highlight areas of concern. The tool leverages code analysis techniques to identify complex code sections, potential code smells, and areas where refactoring might be beneficial.",
-      "parameters": {
-        "type": "code_complexity_analyzer",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code to be analyzed"
-          }
-        },
-        "required": [
-          "language"
-        ]
-      }
-    },
-    {
-      "name": "code_performance_profiler",
-      "description": "Profiles code performance, identifying bottlenecks and areas for optimization. Helps improve code efficiency and speed. It can measure execution times, identify hotspots, and provide recommendations for performance improvements. The tool uses profiling techniques to monitor code execution, identify performance bottlenecks, and suggest optimization strategies to enhance code efficiency.",
-      "parameters": {
-        "type": "code_performance_profiler",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code to be profiled"
-          }
-        },
-        "required": [
-          "language"
-        ]
-      }
-    },
-    {
-      "name": "code_security_scanner",
-      "description": "Scans code for security vulnerabilities, identifying potential exploits and weaknesses. Helps improve code security and prevent attacks. It can detect common vulnerabilities like SQL injection, cross-site scripting, and buffer overflows, providing detailed reports and remediation suggestions. The tool uses static and dynamic analysis techniques to identify potential security vulnerabilities, providing detailed reports and recommendations for remediation.",
-      "parameters": {
-        "type": "code_security_scanner",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code to be scanned"
-          }
-        },
-        "required": [
-          "language"
-        ]
-      }
-    },
-    {
-      "name": "code_style_checker",
-      "description": "Checks code style against predefined rules, ensuring consistency and readability. Helps maintain code quality and improve collaboration. It can enforce specific style guides like PEP8, Google, or Airbnb, identifying style violations and providing suggestions for correction. The tool analyzes code formatting, naming conventions, and other style elements, comparing them to predefined rules and providing detailed reports on style violations.",
-      "parameters": {
-        "type": "code_style_checker",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code to be checked"
-          },
-          "style_guide": {
-            "type": "string",
-            "description": "Code style guide to use (e.g., PEP8, Google)"
-          }
-        },
-        "required": [
-          "language",
-          "style_guide"
-        ]
-      }
-    },
-    {
-      "name": "code_completion",
-      "description": "Provides code suggestions and completions as you type, improving coding speed and accuracy. Supports various programming languages and IDEs. It can predict the next code element based on context, reducing typing errors and improving code quality. The tool uses machine learning and code analysis to predict the next code element based on context, providing intelligent suggestions and completions.",
-      "parameters": {
-        "type": "code_completion",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code"
-          },
-          "context": {
-            "type": "string",
-            "description": "Current code context or snippet"
-          }
-        },
-        "required": [
-          "language",
-          "context"
-        ]
-      }
-    },
-    {
-      "name": "code_search",
-      "description": "Searches for code snippets or examples based on natural language queries. Helps find solutions to coding problems or learn new techniques. It can understand complex queries and retrieve relevant code snippets from a vast repository of code. The tool leverages natural language processing and code indexing techniques to search through a vast repository of code, retrieving relevant snippets based on user queries.",
-      "parameters": {
-        "type": "code_search",
-        "properties": {
-          "query": {
-            "type": "string",
-            "description": "Natural language query for code snippets"
-          },
-          "language": {
-            "type": "string",
-            "description": "Programming language to search in (optional)"
-          }
-        },
-        "required": [
-          "query"
-        ]
-      }
-    },
-    {
-      "name": "code_diff_analyzer",
-      "description": "Analyzes code diffs, identifying changes and their impact. Helps understand code modifications and potential issues. It can highlight specific changes, identify potential conflicts, and provide insights into the impact of code modifications. The tool analyzes code diffs, identifying changes, highlighting potential conflicts, and providing insights into the impact of modifications on code functionality and structure.",
-      "parameters": {
-        "type": "code_diff_analyzer",
-        "properties": {
-          "diff": {
-            "type": "string",
-            "description": "Code diff to be analyzed"
-          },
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code diff"
-          }
-        },
-        "required": [
-          "diff",
-          "language"
-        ]
-      }
-    },
-    {
-      "name": "code_metrics_calculator",
-      "description": "Calculates various code metrics, such as lines of code, cyclomatic complexity, and code coverage. Provides insights into code quality and maintainability. It can calculate a range of metrics to assess code complexity, maintainability, and efficiency, providing developers with valuable insights. The tool analyzes code structure and execution to calculate metrics like lines of code, cyclomatic complexity, code coverage, and other relevant metrics, providing a comprehensive assessment of code quality.",
-      "parameters": {
-        "type": "code_metrics_calculator",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code"
-          }
-        },
-        "required": [
-          "language"
-        ]
-      }
-    },
-    {
-      "name": "code_dependency_analyzer",
-      "description": "Analyzes code dependencies, identifying potential conflicts or outdated packages. Helps manage dependencies and ensure project stability. It can identify conflicting dependencies, outdated packages, and security vulnerabilities related to dependencies, ensuring a smooth and secure development process. The tool analyzes project dependencies, identifies potential conflicts, outdated packages, and security vulnerabilities related to dependencies, providing recommendations for dependency management and ensuring project stability.",
-      "parameters": {
-        "type": "code_dependency_analyzer",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code"
-          }
-        },
-        "required": [
-          "language"
-        ]
-      }
-    },
-    {
-      "name": "code_version_control_integration",
-      "description": "Integrates with version control systems like Git, allowing for code management, history tracking, and collaboration. It can streamline version control operations, making it easier to track changes, collaborate with others, and manage code history. The tool provides seamless integration with version control systems, enabling developers to manage code versions, track changes, collaborate with others, and maintain a comprehensive history of code modifications.",
-      "parameters": {
-        "type": "code_version_control_integration",
-        "properties": {
-          "vcs_system": {
-            "type": "string",
-            "description": "Version control system (e.g., Git)"
-          },
-          "repository_url": {
-            "type": "string",
-            "description": "URL of the repository"
-          }
-        },
-        "required": [
-          "vcs_system",
-          "repository_url"
-        ]
-      }
-    },
-    {
-      "name": "code_build_and_deployment_tool",
-      "description": "Automates code building, testing, and deployment processes, streamlining software development workflows. It can handle complex build processes, automate testing, and deploy applications to various platforms, reducing manual effort and ensuring consistency. The tool automates the build, test, and deployment process, handling code compilation, testing, packaging, and deployment to various platforms, streamlining development workflows and ensuring consistency.",
-      "parameters": {
-        "type": "code_build_and_deployment_tool",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code"
-          },
-          "build_system": {
-            "type": "string",
-            "description": "Build system to use (e.g., Maven, Gradle)"
-          },
-          "deployment_platform": {
-            "type": "string",
-            "description": "Deployment platform (e.g., AWS, Azure)"
-          }
-        },
-        "required": [
-          "language",
-          "build_system",
-          "deployment_platform"
-        ]
-      }
-    },
-    {
-      "name": "code_database_integration",
-      "description": "Integrates code with databases, allowing for data storage, retrieval, and manipulation. Supports various database systems. It can handle database connections, queries, and data manipulation, providing a seamless integration between code and databases. The tool provides a seamless integration with databases, enabling developers to connect to databases, execute queries, and manipulate data efficiently.",
-      "parameters": {
-        "type": "code_database_integration",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code"
-          },
-          "database_system": {
-            "type": "string",
-            "description": "Database system to connect to (e.g., MySQL, PostgreSQL)"
-          }
-        },
-        "required": [
-          "language",
-          "database_system"
-        ]
-      }
-    },
-    {
-      "name": "code_api_integration",
-      "description": "Integrates code with APIs, allowing for communication with external services and data sources. Supports various API protocols. It can handle API calls, data parsing, and error handling, enabling seamless communication with external services. The tool provides a seamless integration with APIs, enabling developers to make API calls, parse data, and handle errors, facilitating communication with external services and data sources.",
-      "parameters": {
-        "type": "code_api_integration",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code"
-          },
-          "api_endpoint": {
-            "type": "string",
-            "description": "URL of the API endpoint"
-          },
-          "api_protocol": {
-            "type": "string",
-            "description": "API protocol (e.g., REST, GraphQL)"
-          }
-        },
-        "required": [
-          "language",
-          "api_endpoint",
-          "api_protocol"
-        ]
-      }
-    },
-    {
-      "name": "code_cloud_integration",
-      "description": "Integrates code with cloud platforms, leveraging cloud services for storage, compute, and other functionalities. Supports various cloud providers. It can utilize cloud services for storage, compute, networking, and other functionalities, enabling developers to build scalable and reliable applications. The tool provides seamless integration with cloud platforms, enabling developers to leverage cloud services for storage, compute, networking, and other functionalities, building scalable and reliable applications.",
-      "parameters": {
-        "type": "code_cloud_integration",
-        "properties": {
-          "language": {
-            "type": "string",
-            "description": "Programming language of the code"
-          },
-          "cloud_provider": {
-            "type": "string",
-            "description": "Cloud provider (e.g., AWS, Azure)"
-          }
-        },
-        "

agents/GoatCodeConfig.txt

@@ -1,2 +0,0 @@
-Agent Name: GoatCode
-Description: AI agent created from text input.