mcp server aidd

[
  {
    "description": "Get the current working directory that this server is allowed to access.",
    "inputSchema": {
      "properties": {},
      "required": [],
      "type": "object"
    },
    "name": "get_allowed_directory"
  },
  {
    "description": "Create a new file or overwrite an existing file with new content. Use this to save changes, create new files, or update existing ones. Use with caution as it will overwrite existing files without warning. Path must be relative to the allowed directory. Creates parent directories if needed. Example: Path='notes.txt', Content='Meeting notes for project X'",
    "inputSchema": {
      "properties": {
        "content": {
          "description": "Content to write to the file",
          "type": "string"
        },
        "path": {
          "description": "Path where to write the file",
          "type": "string"
        }
      },
      "required": [
        "path",
        "content"
      ],
      "type": "object"
    },
    "name": "write_file"
  },
  {
    "description": "Change the working directory that this server is allowed to access. Use this to switch between different projects.",
    "inputSchema": {
      "properties": {
        "directory": {
          "description": "Directory to allow access to. Must be an absolute path. Use ~ to refer to the user's home directory.",
          "type": "string"
        }
      },
      "required": [
        "directory"
      ],
      "type": "object"
    },
    "name": "update_allowed_directory"
  },
  {
    "description": "Create a new directory or ensure a directory exists. Can create multiple nested directories in one operation. If the directory already exists, this operation will succeed silently. Useful for setting up project structure or organizing files. Only works within the allowed directory. Example: Enter 'src/components' to create nested directories.",
    "inputSchema": {
      "properties": {
        "path": {
          "description": "Path of the directory to create",
          "type": "string"
        }
      },
      "required": [
        "path"
      ],
      "type": "object"
    },
    "name": "create_directory"
  },
  {
    "description": "Make line-based edits to a text file. Each edit replaces exact line sequences with new content. Returns a git-style diff showing the changes made. Only works within the allowed directory. Always use dryRun first to preview changes before applying them.",
    "inputSchema": {
      "properties": {
        "dryRun": {
          "default": false,
          "description": "Preview changes without applying",
          "type": "boolean"
        },
        "edits": {
          "description": "List of edit operations",
          "items": {
            "properties": {
              "newText": {
                "description": "Text to replace with",
                "type": "string"
              },
              "oldText": {
                "description": "Text to search for (can be substring)",
                "type": "string"
              }
            },
            "required": [
              "oldText",
              "newText"
            ],
            "type": "object"
          },
          "type": "array"
        },
        "options": {
          "properties": {
            "normalizeWhitespace": {
              "default": true,
              "description": "Normalize spaces while preserving structure",
              "type": "boolean"
            },
            "partialMatch": {
              "default": true,
              "description": "Enable fuzzy matching",
              "type": "boolean"
            },
            "preserveIndentation": {
              "default": true,
              "description": "Keep existing indentation",
              "type": "boolean"
            }
          },
          "type": "object"
        },
        "path": {
          "description": "File to edit",
          "type": "string"
        }
      },
      "required": [
        "path",
        "edits"
      ],
      "type": "object"
    },
    "name": "edit_file"
  },
  {
    "description": "Get a detailed listing of files and directories in the specified path. This tool is essential for understanding directory structure and finding specific files within a directory. Only works within the allowed directory. Example: Enter 'src' to list contents of the src directory, or '.' for current directory.",
    "inputSchema": {
      "properties": {
        "path": {
          "description": "Path of the directory to list",
          "type": "string"
        }
      },
      "required": [
        "path"
      ],
      "type": "object"
    },
    "name": "list_directory"
  },
  {
    "description": "Read the complete contents of a file from the file system. Handles various text encodings and provides detailed error messages if the file cannot be read. Use this tool when you need to examine the contents of a single file. Only works within the allowed directory.Example: Enter 'src/main.py' to read a Python file.",
    "inputSchema": {
      "properties": {
        "path": {
          "description": "Path to the file to read",
          "type": "string"
        }
      },
      "required": [
        "path"
      ],
      "type": "object"
    },
    "name": "read_file"
  },
  {
    "description": "Read the contents of multiple files simultaneously. This is more efficient than reading files one by one when you need to analyze or compare multiple files. Each file's content is returned with its path as a reference. Failed reads for individual files won't stop the entire operation. Only works within the allowed directory.Example: Enter ['src/main.py', 'README.md'] to read both files.",
    "inputSchema": {
      "properties": {
        "paths": {
          "description": "List of file paths to read",
          "items": {
            "type": "string"
          },
          "type": "array"
        }
      },
      "required": [
        "paths"
      ],
      "type": "object"
    },
    "name": "read_multiple_files"
  },
  {
    "description": "Move or rename a file or directory to a new location. This tool can be used to reorganize files and directories. Both source and destination must be within the allowed directory. If the destination already exists, the operation will fail. Parent directories of the destination will be created if they don't exist. Example: source='old.txt', destination='new/path/new.txt'",
    "inputSchema": {
      "properties": {
        "destination": {
          "description": "Destination path where to move the file or directory",
          "type": "string"
        },
        "source": {
          "description": "Source path of the file or directory to move",
          "type": "string"
        }
      },
      "required": [
        "source",
        "destination"
      ],
      "type": "object"
    },
    "name": "move_file"
  },
  {
    "description": "Search for files and directories matching a pattern. The search is recursive and case-insensitive. Only searches within the allowed directory. Returns paths relative to the allowed directory. Searches in file and directory names, not content. For searching within file contents, use the tree_sitter_map tool which can locate specific code elements like functions and classes. Example: pattern='.py' finds all Python files, pattern='test' finds all items with 'test' in the name.",
    "inputSchema": {
      "properties": {
        "include_hidden": {
          "description": "Whether to include hidden files and directories (defaults to false)",
          "type": "boolean"
        },
        "path": {
          "description": "Starting directory for the search (defaults to allowed directory)",
          "type": "string"
        },
        "pattern": {
          "description": "Pattern to search for in file and directory names",
          "type": "string"
        }
      },
      "required": [
        "pattern"
      ],
      "type": "object"
    },
    "name": "search_files"
  },
  {
    "description": "Delete a file or empty directory from the file system. Use with caution as this operation cannot be undone. For safety, this tool will not delete non-empty directories. Only works within the allowed directory. Example: path='old_file.txt' removes the specified file.",
    "inputSchema": {
      "properties": {
        "path": {
          "description": "Path to the file or empty directory to delete",
          "type": "string"
        }
      },
      "required": [
        "path"
      ],
      "type": "object"
    },
    "name": "delete_file"
  },
  {
    "description": "Get detailed information about a file or directory. Returns size, creation time, modification time, access time, type (file/directory), and permissions. All times are in ISO 8601 format. This tool is perfect for understanding file characteristics without reading the actual content. Only works within the allowed directory. Example: path='src/main.py' returns details about main.py",
    "inputSchema": {
      "properties": {
        "path": {
          "description": "Path to the file or directory",
          "type": "string"
        }
      },
      "required": [
        "path"
      ],
      "type": "object"
    },
    "name": "get_file_info"
  },
  {
    "description": "Get a recursive tree view of files and directories in the specified path as a JSON structure. Each entry includes 'name', 'type' (file/directory), and 'children' for directories. Files have no children array, while directories always have a children array (which may be empty). The output is formatted with 2-space indentation for readability. Only works within the allowed directory. Useful for understanding project structure. Example: Enter '.' for current directory, or 'src' for a specific directory.",
    "inputSchema": {
      "properties": {
        "path": {
          "description": "Root directory to analyze",
          "type": "string"
        }
      },
      "required": [
        "path"
      ],
      "type": "object"
    },
    "name": "directory_tree"
  },
  {
    "description": "Execute arbitrary code in various programming languages on the user's local machine within the current working directory. Supported languages: python, javascript, ruby, php, go, rust. Always review the code carefully before execution to prevent unintended consequences. You MUST explicitly show the user the code that will be executed and get his confirmation before using this tool. Examples: - Python: code='print(sum(range(10)))'. - JavaScript: code='console.log(Array.from({length: 5}, (_, i) => i*2))'. - Ruby: code='puts (1..5).reduce(:+)'. ",
    "inputSchema": {
      "properties": {
        "code": {
          "description": "Code to execute on the user's local machine in the current working directory",
          "type": "string"
        },
        "language": {
          "description": "Programming language to use",
          "enum": [
            "python",
            "javascript",
            "ruby",
            "php",
            "go",
            "rust"
          ],
          "type": "string"
        },
        "timeout": {
          "default": 5,
          "description": "Maximum execution time in seconds",
          "maximum": 30,
          "minimum": 1,
          "type": "integer"
        }
      },
      "required": [
        "language",
        "code"
      ],
      "type": "object"
    },
    "name": "execute_code"
  },
  {
    "description": "Execute a shell script (bash/sh) on the user's local machine within the current working directory. This tool can execute shell commands and scripts for system automation and management tasks. It is designed to perform tasks on the user's local environment, such as opening applications, installing packages and more. Always review the script carefully before execution to prevent unintended consequences. You MUST explicitly show the user the script that will be executed and get his confirmation before using this tool. Examples: - script='echo "Current directory:" && pwd'. - script='for i in {1..5}; do echo $i; done'. ",
    "inputSchema": {
      "properties": {
        "script": {
          "description": "Shell script to execute on the user's local machine",
          "type": "string"
        },
        "timeout": {
          "default": 300,
          "description": "Maximum execution time in seconds (default: 300, max: 600)",
          "type": "integer"
        }
      },
      "required": [
        "script"
      ],
      "type": "object"
    },
    "name": "execute_shell_script"
  },
  {
    "description": "Build a tree-sitter based structural map of source code files. This tool analyzes code structure to identify classes, functions, and methods. Only analyzes files within the allowed directory. Useful for code analysis and understanding project structure. Example: Enter '.' to analyze all source files in current directory, or 'src' to analyze all files in the src directory.",
    "inputSchema": {
      "properties": {
        "path": {
          "description": "Root directory to analyze",
          "type": "string"
        }
      },
      "required": [
        "path"
      ],
      "type": "object"
    },
    "name": "tree_sitter_map"
  },
  {
    "description": "Initialize a new Git repository. Creates a new Git repository in the specified directory. If the directory doesn't exist, it will be created. Directory must be within the allowed directory.",
    "inputSchema": {
      "properties": {
        "initial_branch": {
          "default": "main",
          "description": "Name of the initial branch (defaults to 'main')",
          "type": "string"
        },
        "path": {
          "description": "Path where to initialize the repository",
          "type": "string"
        }
      },
      "required": [
        "path"
      ],
      "type": "object"
    },
    "name": "git_init"
  },
  {
    "description": "Shows the working tree status of a git repository. Returns information about staged, unstaged, and untracked files. Repository must be within the allowed directory.",
    "inputSchema": {
      "properties": {
        "repo_path": {
          "description": "Path to git repository",
          "type": "string"
        }
      },
      "required": [
        "repo_path"
      ],
      "type": "object"
    },
    "name": "git_status"
  },
  {
    "description": "Shows changes in working directory not yet staged for commit. Returns a unified diff format of all unstaged changes. Repository must be within the allowed directory.",
    "inputSchema": {
      "properties": {
        "repo_path": {
          "description": "Path to git repository",
          "type": "string"
        }
      },
      "required": [
        "repo_path"
      ],
      "type": "object"
    },
    "name": "git_diff_unstaged"
  },
  {
    "description": "Shows changes staged for commit. Returns a unified diff format of all staged changes. Repository must be within the allowed directory.",
    "inputSchema": {
      "properties": {
        "repo_path": {
          "description": "Path to git repository",
          "type": "string"
        }
      },
      "required": [
        "repo_path"
      ],
      "type": "object"
    },
    "name": "git_diff_staged"
  },
  {
    "description": "Shows differences between branches or commits. Returns a unified diff format comparing current state with target. Repository must be within the allowed directory.",
    "inputSchema": {
      "properties": {
        "repo_path": {
          "description": "Path to git repository",
          "type": "string"
        },
        "target": {
          "description": "Target branch or commit to compare with",
          "type": "string"
        }
      },
      "required": [
        "repo_path",
        "target"
      ],
      "type": "object"
    },
    "name": "git_diff"
  },
  {
    "description": "Records changes to the repository. Commits all staged changes with the provided message. Repository must be within the allowed directory.",
    "inputSchema": {
      "properties": {
        "message": {
          "description": "Commit message",
          "type": "string"
        },
        "repo_path": {
          "description": "Path to git repository",
          "type": "string"
        }
      },
      "required": [
        "repo_path",
        "message"
      ],
      "type": "object"
    },
    "name": "git_commit"
  },
  {
    "description": "Adds file contents to the staging area. Stages specified files for the next commit. Repository must be within the allowed directory.",
    "inputSchema": {
      "properties": {
        "files": {
          "description": "List of file paths to stage",
          "items": {
            "type": "string"
          },
          "type": "array"
        },
        "repo_path": {
          "description": "Path to git repository",
          "type": "string"
        }
      },
      "required": [
        "repo_path",
        "files"
      ],
      "type": "object"
    },
    "name": "git_add"
  },
  {
    "description": "Unstages all staged changes. Removes all files from the staging area. Repository must be within the allowed directory.",
    "inputSchema": {
      "properties": {
        "repo_path": {
          "description": "Path to git repository",
          "type": "string"
        }
      },
      "required": [
        "repo_path"
      ],
      "type": "object"
    },
    "name": "git_reset"
  },
  {
    "description": "Shows the commit logs. Returns information about recent commits including hash, author, date, and message. Repository must be within the allowed directory.",
    "inputSchema": {
      "properties": {
        "max_count": {
          "default": 10,
          "description": "Maximum number of commits to show",
          "type": "integer"
        },
        "repo_path": {
          "description": "Path to git repository",
          "type": "string"
        }
      },
      "required": [
        "repo_path"
      ],
      "type": "object"
    },
    "name": "git_log"
  },
  {
    "description": "Creates a new branch. Creates a new branch from the specified base branch or current HEAD. Repository must be within the allowed directory.",
    "inputSchema": {
      "properties": {
        "base_branch": {
          "default": {
            "path": "uv.lock",
            "type": "blob"
          },
          "description": "Starting point for the new branch (optional)",
          "type": "string"
        },
        "branch_name": {
          "description": "Name of the new branch",
          "type": "string"
        },
        "repo_path": {
          "description": "Path to git repository",
          "type": "string"
        }
      },
      "required": [
        "repo_path",
        "branch_name"
      ],
      "type": "object"
    },
    "name": "git_create_branch"
  },
  {
    "description": "Switches branches. Checks out the specified branch. Repository must be within the allowed directory.",
    "inputSchema": {
      "properties": {
        "branch_name": {
          "description": "Name of branch to checkout",
          "type": "string"
        },
        "repo_path": {
          "description": "Path to git repository",
          "type": "string"
        }
      },
      "required": [
        "repo_path",
        "branch_name"
      ],
      "type": "object"
    },
    "name": "git_checkout"
  },
  {
    "description": "Shows the contents of a commit. Returns detailed information about a specific commit including the changes it introduced. Repository must be within the allowed directory.",
    "inputSchema": {
      "properties": {
        "repo_path": {
          "description": "Path to git repository",
          "type": "string"
        },
        "revision": {
          "description": "The revision (commit hash, branch name, tag) to show",
          "type": "string"
        }
      },
      "required": [
        "repo_path",
        "revision"
      ],
      "type": "object"
    },
    "name": "git_show"
  },
  {
    "description": "Get detailed system information including OS, CPU, memory, disk, and network details (such as WiFi network name). This tool provides comprehensive information about the system environment. Also returns the current working directory (allowed directory) of the AiDD MCP server. Useful for system analysis, debugging, environment verification, and workspace management.",
    "inputSchema": {
      "properties": {},
      "required": [],
      "type": "object"
    },
    "name": "get_system_info"
  }
]