22 Tools for Surgical Code Operations

What it does: Surgically extracts a specific function, class, or method from a file with exact source code and line numbers. Optionally resolves and includes dependencies (imports, parent classes) so the extracted code is self-contained and visible.

When agents use it: To get current implementation before making changes. Agents extract → modify → use update_symbol to apply. Works like copying code but with automatic context inclusion.

Languages: Python, JavaScript, TypeScript, Java, JSX, TSX

What it does: Precisely replaces a function, class, or method in a source file with new code. Preserves all surrounding code exactly, validates Python/JavaScript syntax before writing, and creates automatic .bak backups. Zero risk of mangling nearby code.

When agents use it: After modifying extracted code. Extract → edit locally → update_symbol applies changes. Syntax validation prevents broken deployments.

Use case: "Update the validate_email function to use RFC 5322 pattern" → extract_code → modify → update_symbol

What it does: Renames a function, class, or method with surgical precision. Automatically updates all references across the codebase (imports, calls, type hints) using AST-based analysis to avoid string-match errors.

When agents use it: Refactoring tasks: "Rename calc_total to calculate_total with all callers updated," enforce naming conventions, or make code more semantic.

Tier differences: Community renames in single file; Pro/Enterprise add cross-file reference updates and automatic import fixing.

What it does: Advanced taint tracking analysis that traces untrusted data (user input, environment variables, network calls) through your code to identify how it reaches dangerous operations (SQL queries, system commands, file writes). Maps complete attack paths with evidence. Detects SQL injection, XSS, command injection, path traversal, SSRF, hardcoded secrets, with confidence scoring.

When agents use it: Before deployment for security audit, or when user asks "Is this code secure?". Returns taint flow visualization: User input → sanitize? → SQL execute = vulnerability or safe.

Example: User input → f-string → SQL execute = CRITICAL vulnerability detected with remediation advice.

What it does: Polyglot sink detection across multiple languages. Finds dangerous operations (SQL execute, eval, system calls, file operations, DOM manipulation) in Python (os.system, sqlite3.execute), JavaScript (innerHTML, fetch), TypeScript, Java (Runtime.exec) with confidence scoring for each detection.

When agents use it: Quick surface-level security audit without full taint analysis. Answer: "Show me all potentially dangerous operations in this file."

Languages: Python (os.system, eval), JavaScript (innerHTML, eval), TypeScript, Java (Runtime.exec)

What it does: Extends single-file security analysis to multi-file attack chains. Traces tainted data flowing across module boundaries: routes.py (accepts user input) → services.py (processes data) → db.py (executes SQL). Detects vulnerabilities that local analysis misses. Generates Mermaid visualizations showing complete taint flow.

When agents use it: Full-project security audits. Catches cross-module vulnerabilities where input validation happens in one file but is bypassed in another.

Pro/Enterprise limits: Tracks across up to 100 files (Community: basic cross-file). Includes Mermaid flow diagrams showing taint path.

What it does: Scans requirements.txt, package.json, pyproject.toml, go.mod against the OSV (Open Source Vulnerabilities) database. Returns CVE IDs, CVSS severity scores, affected version ranges, and direct links to security advisories. Works for Python (PyPI), JavaScript (npm), Go, Rust, Java ecosystems.

When agents use it: Supply chain security: "Are my dependencies safe?" Returns actionable patch versions and remediation steps.

Ecosystems: Python (PyPI), JavaScript (npm), Go, Rust

What it does: Detects type system vulnerabilities at API boundaries. A TypeScript frontend declares {age: number, isAdmin: boolean} but backend receives raw JSON without validation. Attacker sends {age: 30, isAdmin: "yes"} (truthy string) and becomes admin. Identifies these full-stack type confusion vulnerabilities.

When agents use it: Full-stack projects with TypeScript frontend + Python/Node backend. Verifies backend properly validates and type-checks all API inputs.

Example vuln: Frontend: isAdmin: boolean → Backend: if data.get('isAdmin') → Attacker sends isAdmin="yes" (truthy string) = admin access granted

What it does: Builds a complete call graph: every function and which other functions it calls. Detects entry points (main (), CLI handlers, API routes), identifies circular dependencies, shows execution depth and breadth. Outputs Mermaid diagrams showing the entire call chain from entry to leaf functions. Includes confidence scoring (100% certain vs. dynamic dispatch).

When agents use it: Understand execution paths (user request → which functions run?), find dead code, trace taint from input source to output sink, or plan refactoring impact zones.

Pro/Enterprise limits: 50 depth, 500 nodes (Community: 3 depth, 50 nodes). Path queries, k-hop traversal, confidence scoring available at all tiers with different limits.

What it does: Generates a high-level architecture map of your entire codebase: package structure, exposed functions/classes, entry points, complexity hotspots (cyclomatic complexity > 10), import graph visualization, circular dependencies, size metrics. Returns Mermaid-compatible diagrams and JSON for analysis.

When agents use it: Onboarding to new codebase ("What does this project do?"), identifying code to refactor (high complexity), finding test entry points, or planning modularization.

Use case: Onboarding to new codebase, finding complexity hotspots (functions with cyclomatic complexity > 10).

What it does: Extracts a focused subgraph from the full call graph. Choose a center node (e.g., process_payment function) and specify depth (2 hops), then get all functions → calling that function, → called by that function, or both. Prevents graph explosion on large codebases by limiting scope.

When agents use it: Impact analysis ("What does delete_user call?"), focused refactoring ("Which functions touch this module?"), or security analysis ("What calls execute_sql?").

Directions: outgoing (callees), incoming (callers), both (full neighborhood)

What it does: Recursively resolves all dependencies a function/class needs from other files (imports, parent classes, used utilities). Returns combined source code with all dependencies inlined, a dependency graph, circular dependency detection, and Mermaid visualization of the dependency tree. Includes confidence decay scoring (direct deps = high confidence, transitive deps = lower).

When agents use it: Get full context for a function (all imports resolved and visible), detect circular imports, plan module extraction ("Can we move this function to a new file?"), or understand hidden dependencies.

Output: Dependency graph, combined code (all deps in one string), confidence decay scoring, Mermaid diagram.

What it does: Uses the Z3 theorem prover to explore all possible execution paths through a function. Sends symbolic values (not concrete numbers) through if/else branches and computes path constraints. Discovers edge cases and crash conditions: "If quantity < 0 then ValueError," "If total == 0 then ZeroDivisionError," etc. Returns all paths with concrete example inputs.

When agents use it: Answer "What edge cases am I missing?" or find hard-to-reach code paths. Generates vulnerability-triggering inputs and crash proofs.

Example: Function with 5 if/else branches → Tool explores all 5 paths and generates example inputs for each.

What it does: Leverages symbolic execution to automatically generate comprehensive unit tests. Explores all function branches and generates test cases for each path: happy path, error conditions (ValueError, ZeroDivisionError, TypeError), edge cases (empty inputs, negative numbers, None values). Outputs ready-to-run pytest, unittest, or hypothesis tests with 100% code path coverage.

When agents use it: User says "Write tests for this function" or for TDD workflows. Ensures every code branch is tested, including error handling.

Output: Complete test file with test cases for all branches, error cases (ValueError, ZeroDivisionError), and edge cases.

What it does: Simulates applying a code change and verifies behavior preservation through comparative symbolic execution. Passes original and refactored code to Z3, explores all paths in both, and confirms they produce identical results for all inputs. Returns is_safe (boolean), differences (if any), and path comparison analysis.

When agents use it: Before update_symbol applies changes. Critical safety check: "This refactor preserves 100% of behavior" or "Warning: This changes behavior when quantity == 0"

Output: is_safe (boolean), differences (if any), path_comparison (original vs new paths), recommendation.

What it does: Validates file paths before all operations: confirms files exist, are readable/writable, fall within project boundaries (no path traversal escape), and detects suspicious symlinks pointing outside the project. Essential security layer for sandboxed deployments.

When agents use it: Every agent operation on files is guarded by path validation first. Prevents attacks, enforces sandbox boundaries, and confirms file accessibility before expensive parsing.

Checks: File exists, is readable/writable, within project boundaries, not a symlink outside project.

What it does: Cryptographic policy verification: generates SHA-256 hashes of governance configuration files (limits.toml, security-policy.yaml, .code-scalpel config) and verifies against a trusted manifest. Detects if policies have been tampered with or downgraded.

When agents use it: Compliance audits in Enterprise environments. Answer: "Have our security/governance policies been modified?" with cryptographic proof.

Pro/Enterprise limits: Advanced cryptographic verification and remote manifest support available in higher tiers.

What it does: Audits code against multi-standard compliance frameworks: OWASP Top 10 (hardcoded secrets, eval usage), SOC 2 (audit logging, access controls), ISO 27001 (data handling), HIPAA (PII handling), PCI-DSS. Also enforces org-specific style guides. Returns violations with severity (CRITICAL/HIGH/MEDIUM/LOW) and remediation guidance.

When agents use it: Pre-commit checks, CI/CD gates, compliance reporting. Answer: "Does this code violate our security/compliance standards?"

Enterprise limits: Adds custom OPA (Open Policy Agent) rules and compliance reporting for organization-specific policies.