Enables scanning TODO comments in C++ source files.
Enables scanning TODO comments in CSS source files.
Enables scanning TODO comments in JavaScript source files.
Enables scanning TODO comments in Kotlin source files.
Enables scanning TODO comments in Less source files.
Enables scanning TODO comments in Lua source files.
Enables scanning TODO comments in Perl source files.
Enables scanning TODO comments in PHP source files.
Enables scanning TODO comments in Python source files.
Enables scanning TODO comments in Ruby source files.
Enables scanning TODO comments in Rust source files.
Enables scanning TODO comments in Shell script files.
Enables scanning TODO comments in Swift source files.
Enables scanning TODO comments in TOML configuration files.
Enables scanning TODO comments in TypeScript source files.
Enables scanning TODO comments in YAML configuration files.
Enables scanning TODO comments in Zsh shell script files.
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mcp-code-todo show me all high priority TODOs"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
A Model Context Protocol (MCP) server that scans codebases for TODO comments and exposes them as structured data to LLMs. This enables AI assistants to inspect outstanding work, propose fixes, prioritize tasks, and generate patches.
Multi-language support: Detects TODOs in 30+ programming languages (JavaScript, TypeScript, Python, Go, Rust, Java, etc.)
Metadata parsing: Supports structured TODOs with owners, priorities, and estimates
Flexible scanning: Include/exclude patterns, custom root directories
Context-aware: Provides surrounding code lines for each TODO
Caching: In-memory caching for performance
Read-only: Safe filesystem access with security boundaries
Related MCP server: MatterAI MCP Server
Add to your MCP client configuration:
{
"mcpServers": {
"code-todo": {
"args": [
"-y",
"mcp-code-todo@latest"
],
"command": "npx"
}
}
}You can optionally specify the workspace root directory via the --workspace-root argument:
{
"mcpServers": {
"code-todo": {
"args": [
"-y",
"mcp-code-todo@latest",
"--workspace-root",
"/path/to/your/project"
],
"command": "npx"
}
}
}This is useful when the workspace cannot be auto-detected from environment variables.
todo://listReturns all TODOs in the project with metadata.
{
"todos": [
{
"id": "abc123",
"text": "Implement error handling",
"filePath": "src/utils.ts",
"line": 42,
"language": "typescript",
"meta": {
"owner": "ash",
"priority": "high",
"estimate": "2h"
}
}
],
"meta": {
"scannedAt": "2024-01-17T22:00:00.000Z",
"fileCount": 15
}
}todo://file/{path}Returns TODOs for a specific file.
scan_todosScan the codebase for TODO comments.
Parameters:
root (string, optional): Root directory to scan (defaults to workspace root)
include (string[], optional): Glob patterns for files to include
exclude (string[], optional): Glob patterns for files to exclude
Example:
{
"root": "/path/to/project",
"include": ["*.ts", "*.js"],
"exclude": ["test/**", "node_modules/**"]
}explain_todoGet more context for a specific TODO item.
Parameters:
id (string): The unique ID of the TODO item
contextLines (number, optional): Number of context lines (default: 5)
Returns:
{
"todo": { "id": "abc123", "text": "...", ... },
"context": " 39: function example() {\n> 42: // TODO: Implement error handling\n 43: return data;\n 44: }"
}group_todos_by_topicGroup TODOs by various criteria.
Returns:
{
"by-file": {
"src/utils": [todo1, todo2],
"src/components": [todo3]
},
"by-priority": [high_priority_todos],
"with-owner": [assigned_todos],
"unassigned": [unassigned_todos]
}find_todos_in_appA guided workflow to discover and investigate TODOs in the current app.
Parameters:
focus (string, optional): Area to focus on, such as auth, payments, frontend, or src/components
include (string[], optional): Glob patterns to narrow the scan
exclude (string[], optional): Glob patterns to skip generated or irrelevant paths
Workflow:
Confirms workspace with get_workspace (sets it with set_workspace if needed)
Runs scan_todos across the codebase
Applies any provided focus, include, or exclude filters
Summarizes results by count, key files, owners, and priorities
Highlights the most important or risky TODOs first
Uses explain_todo for deeper inspection when needed
Optionally calls group_todos_by_topic to cluster by file, priority, or ownership
Recommends the next TODOs to tackle and why
Example usage:
{
"focus": "auth",
"include": ["src/**/*.ts"],
"exclude": ["test/**", "generated/**"]
}// TODO: Implement error handling
# TODO: Add validation
/* TODO: Refactor this function */// TODO(ash): Implement error handling
// TODO[@ash][priority=high][est=2h]: Fix performance issue
// TODO(priority=medium): Add unit testsowner: Assignee name (TODO(owner) or TODO[@owner])
priority: Priority level ([priority=low|medium|high])
estimate: Time estimate ([est=2h])
JavaScript / TypeScript / JSX / TSX
Python
Ruby
Go
Rust
Java / Kotlin
C / C++ / C#
Swift
PHP
HTML / CSS / SCSS / LESS
SQL
Lua
Perl
R
Shell scripts (Bash, Zsh)
Configuration files (YAML, TOML, INI)
And more...
The scanner automatically excludes:
node_modules, .git, .svn, .hg
dist, build, out
.next, .nuxt, coverage
__pycache__, .pytest_cache
venv, .venv, env
vendor, target, bin, obj
IDE folders (.idea, .vscode)
OS files (.DS_Store)
Maximum file size: 1MB
Binary files are automatically skipped
# Install dependencies
pnpm install
# Build the project
pnpm run build
# Run in development
node ./build/index.jsmcp-code-todo/
├── src/
│ ├── index.ts # MCP server entry point
│ ├── scanner.ts # TODO extraction and caching
│ ├── languages.ts # Language comment syntax registry
│ ├── types.ts # TypeScript interfaces
│ └── utils.ts # File system utilities
├── build/ # Compiled JavaScript
├── package.json
├── tsconfig.json
└── README.mdRead-only access: No file modification capabilities
Path validation: Root directory must be explicitly provided
Binary file filtering: Automatic skipping of binary files
Size limits: Protection against extremely large files
No network access: Local filesystem only
ISC
Fork the repository
Create a feature branch
Make your changes
Add tests if applicable
Submit a pull request
LLM calls scan_todos to get all TODOs
MCP returns structured TODO list
LLM groups TODOs by theme or file
LLM calls explain_todo for context on specific items
LLM proposes code changes (using separate write-capable MCP)
// Input file src/utils.ts
export function processData(data: any) {
// TODO(ash)[priority=high][est=1h]: Add input validation
return data.map(item => {
// TODO: Handle null values
return item.value;
});
}// Output from scan_todos
{
"todos": [
{
"id": "abc123",
"text": "Add input validation",
"filePath": "src/utils.ts",
"line": 2,
"language": "typescript",
"meta": {
"owner": "ash",
"priority": "high",
"estimate": "1h"
}
},
{
"id": "def456",
"text": "Handle null values",
"filePath": "src/utils.ts",
"line": 5,
"language": "typescript"
}
]
}Get more context for a specific TODO item, including surrounding code lines.
| Name | Required | Description | Default |
|---|---|---|---|
| id | Yes | The unique ID of the TODO item | |
| contextLines | No | Number of context lines to include above and below (default: 5) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden. It states the tool retrieves context and code lines, implying a read-only operation. However, it does not disclose behavior on missing IDs, exact return structure, or any side effects. The description is not misleading, but lacks depth expected without annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence that immediately states the action and what is included. There is no filler or redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with two well-described parameters and no output schema, the description adequately indicates the return value (context and surrounding code lines). It could specify what 'context' entails, but it is complete enough for the tool's straightforward scope.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema already documents both parameters (id and contextLines) with full descriptions. The description's mention of 'surrounding code lines' reinforces contextLines but adds no new semantic detail beyond what the schema provides, matching the baseline for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb (Get) and identifies the resource (specific TODO item) and the output (surrounding code lines). It clearly distinguishes from siblings like scan_todos, which likely lists items, by focusing on a single item's context.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly implies when to use it: when you need more context for a specific TODO item. It does not explicitly mention when not to use it or alternatives, but the distinct purpose among siblings provides sufficient guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the current workspace root directory that will be used for scanning.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It states what is returned (the workspace root) but does not disclose behavior in edge cases such as what happens if no workspace is set (e.g., returns null, throws error). The description is accurate but lacks depth.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, clear sentence that is front-loaded with the verb and resource. Every word contributes meaning with no waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
This is a low-complexity tool with no parameters and no output schema. The description explains the purpose and what it returns. It could add edge-case behavior for full completeness, but for a simple getter it is largely complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so per the rubric the baseline is 4. The description adds no parameter info, but none is needed since the schema shows zero properties.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Get' and names the resource 'current workspace root directory' and its purpose 'will be used for scanning'. This clearly distinguishes it from sibling tools like set_workspace and scan_todos.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context: it retrieves the workspace root for scanning purposes. While it doesn't explicitly mention alternatives or exclusions, the context is enough for an agent to know when to call it, especially since the only related sibling is set_workspace.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Group TODOs by various criteria including file paths, priority, and ownership.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It does not state whether the operation is read-only, what the output format is, or any side effects. The phrase 'group by various criteria' gives no insight into behavior beyond the basic function.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no fluff. It efficiently communicates the core action and examples of grouping dimensions. Perfectly concise for the information provided.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool groups TODOs, which is a complex operation, but there is no output schema and no description of the return value or grouping output structure. The description omits critical details like how criteria are applied, what the grouped result looks like, and whether it affects data. Incomplete for an agent to confidently invoke.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has zero parameters, which would normally score a baseline of 4. However, the description mentions criteria (file paths, priority, ownership) that seem to imply selectable parameters, yet none exist. This creates confusion about how grouping is configured, lowering the score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool groups TODOs and lists criteria such as file paths, priority, and ownership. This distinguishes it from siblings like scan_todos (scanning) and explain_todo (explaining). However, the tool name mentions 'topic' but the description's criteria do not explicitly include topic, creating slight ambiguity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives like scan_todos or explain_todo. The description only states what the tool does, with no context about suitable scenarios or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Scan the codebase for TODO comments. Returns all found TODOs with their locations and metadata.
| Name | Required | Description | Default |
|---|---|---|---|
| root | No | Root directory to scan (defaults to workspace root) | |
| exclude | No | Glob patterns for files to exclude (e.g., ['test/**']) | |
| include | No | Glob patterns for files to include (e.g., ['*.ts', '*.js']) |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the burden. It states that it returns all TODOs with locations and metadata, but doesn't explicitly confirm it's read-only or explain what 'metadata' includes. It adds some value but lacks depth on side effects or edge cases.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two succinct sentences, front-loaded with the action and resource. No wasted words, and the structure is immediately scannable.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description provides enough context for a simple scan tool: states the action and the output (TODOs with locations and metadata). While it lacks details on the return structure or performance implications, the overall complexity is low, and the provided info is reasonable.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, with each parameter ('root', 'exclude', 'include') well described in the input schema. The description adds no additional parameter-specific meaning, so the baseline of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Scan') and resource ('the codebase for TODO comments'), clearly distinguishing this tool from siblings like 'group_todos_by_topic' and 'explain_todo'. It unambiguously states what the tool does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The context is clear: this is the tool for scanning TODO comments, while siblings serve different purposes (workspace management, grouping, explaining). It doesn't explicitly name alternatives or exclusions, but the purpose itself strongly implies the appropriate use case.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Set the workspace root directory for scanning TODOs. Call this first if the default workspace detection doesn't work.
| Name | Required | Description | Default |
|---|---|---|---|
| root | Yes | Absolute path to the workspace root directory |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the burden of behavioral disclosure. It states the action (set) and context (for scanning TODOs), but does not explain side effects like overwriting existing settings or whether the change persists for subsequent calls.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, with the primary action front-loaded. Every word contributes, with no fluff or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple with one parameter, and the description covers purpose and usage condition. However, it omits any mention of validation, side effects, or how the set workspace affects subsequent operations, leaving some gaps for a mutation tool without annotations.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already provides full coverage with a description for the 'root' parameter. The tool description adds no additional semantic detail beyond restating that it sets the root directory, so it matches the schema baseline.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states 'Set the workspace root directory for scanning TODOs,' using a specific verb and resource. This clearly distinguishes it from sibling tools like get_workspace and scan_todos.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The second sentence provides an explicit condition: 'Call this first if the default workspace detection doesn't work.' This tells the agent when to use it, though it doesn't mention alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.2.0explain_todoget_workspacegroup_todos_by_topicscan_todosset_workspaceEach tool targets a distinct action: workspace retrieval/setting, scanning, grouping, and explaining TODOs. No two tools appear to serve the same purpose.
All tool names follow a consistent verb_noun pattern in snake_case (get_workspace, scan_todos, group_todos_by_topic, explain_todo, set_workspace). This is predictable and clear.
With 5 tools, the set is well-scoped for a TODO scanning and analysis server. Each tool covers a necessary operation without redundancy or bloat.
The surface covers workspace configuration, scanning, grouping, and context explanation—a complete workflow for TODO analysis. No obvious missing operations for the stated purpose.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Code intelligence for LLMs. Analyze, search, and retrieve code from any public git repository.
AI-powered codebase analysis — call graphs, security, dead code, complexity. 150+ tools.
Code intelligence platform for AI agents. 20 tools for architecture, security & impact analysis.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/ashhitch/mcp-code-todo'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
