Skip to main content
Glama

execute_codebase_workflow

Idempotent

Orchestrate multi-step codebase audits, context generation, security scans, dependency mapping, and self-healing through one action parameter for a unified report.

Instructions

Autonomous all-in-one T-Zero master tool that executes any codebase workflow in a single command, distinguishing from individual specialized tools by autonomously orchestrating multi-step analysis, context generation, security scans, dependency mapping, and self-healing in an integrated pipeline.

Parameters:

  • action (str, optional, default='auto'): Workflow operation: 'auto' (runs comprehensive all-in-one audit & context pipeline), 'context' (builds AST context tree), 'audit' (code quality & smells), 'security' (Zero-Leak secret scan), 'blueprint' (Mermaid system architecture), 'dependencies' (import & module topology), 'impact' (blast radius of modified symbols), 'search' (hybrid BM25 semantic code search), 'prune' (in-memory AST snippet pruning), 'heal' (AST self-healing diagnosis & patching), 'memory' (query/manage memory store), 'swarm' (multi-agent consensus & task dispatch), or 'design' (UI/UX design blueprint).

  • target (str, optional, default='.'): Target repository root path, file path, diff string, or raw code snippet.

  • query (str, optional, default=''): Search term, focus symbol name, or goal prompt depending on action.

  • options (str, optional, default=''): Optional JSON string specifying extra configuration parameters (e.g. reduction_mode, max_tokens, depth).

Behavior:

  • Orchestrated execution: When action='auto', performs a complete end-to-end audit (security, architecture, token savings, dependencies) and delivers a unified executive summary.

  • Deterministic: Dispatches to specialized underlying T-Zero engines.

  • 100% Offline: Executes entirely on local AST without sending code to unverified cloud APIs.

  • Auth & Rate Limits: Zero credentials required; completes in <500ms.

  • Error Handling: Gracefully falls back and reports clean diagnostic messages for missing paths or invalid JSON options.

Usage Guidelines:

  • When to use: Use whenever you want an instant complete overview of a codebase, or want to perform any T-Zero operation through a single unified entrypoint without choosing between individual tools.

  • When NOT to use: Do not use if you specifically need an isolated low-level API call without any contextual wrapper.

Returns: Comprehensive Markdown report tailored to the requested action or full autonomous pipeline.

Input Schema

NameRequiredDescriptionDefault
queryNoSearch query, focus symbol name, or task goal prompt.
actionNoWorkflow operation: 'auto' (comprehensive all-in-one pipeline), 'context', 'audit', 'security', 'blueprint', 'dependencies', 'impact', 'search', 'prune', 'heal', 'memory', 'swarm', 'design'.auto
targetNoTarget repository path, file path, diff string, or code snippet (default: '.')..
optionsNoOptional JSON string of additional configuration parameters.

Output Schema

NameRequiredDescriptionDefault
resultYes

Schema Changelog

Changes observed during successful MCP inspections.

  1. Addedv7.3.4

TDQS

A4.3/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond annotations, it discloses deterministic dispatch, fully offline local-AST execution, zero credentials, sub-500ms completion, graceful fallback, and a unified executive summary for action='auto'. It does not fully detail the side effects of mutation-adjacent actions like 'heal' patching or 'memory' management.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded and organized into Parameters, Behavior, Usage Guidelines, and Returns sections. It is lengthy and includes some promotional phrasing and duplication of the action list, but the size is mostly justified by the 13-action dispatcher complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the broad dispatcher complexity and the existing output schema, the description covers action semantics, target/query/options usage, behavioral constraints, and error handling well. It leaves some per-action side-effect details implicit, especially for patching or memory mutation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is already 100%, but the description adds useful semantics: action-specific meanings, how target varies by use case, how query depends on action, and example option keys such as reduction_mode, max_tokens, and depth. Much of this overlaps the schema, so it is helpful rather than fully additive.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description states a specific verb and resource: executing codebase workflows via a unified dispatcher. It explicitly distinguishes itself from the many specialized sibling tools by acting as an autonomous orchestration layer across context, audit, security, dependencies, and healing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It includes explicit 'When to use' and 'When NOT to use' sections, directing agents toward a unified entrypoint for complete overviews and away from isolated low-level API calls. It could be stronger if it named specific sibling tools to prefer for isolated operations.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.