An AI-first code analysis and safe refactoring platform with a Python SDK and JSON API. Designed for AI agents with a zero-index architecture for 100x speed and unbreakable safety.
Repo Vaibhav-api-code/code-intelligence-toolkit, read from GitHub 1 min ago. Vaibhav-api-code has not joined Take My Repo.
Vaibhav-api-code/code-intelligence-toolkit is a public repo on GitHub by Vaibhav-api-code. An AI-first code analysis and safe refactoring platform with a Python SDK and JSON API. Designed for AI agents with a zero-index architecture for 100x speed and unbreakable safety. It declares the MPL-2.0 license on GitHub. It is written mainly in Python, has 2 stars and last changed on 2025-07-29. Nobody has reviewed it on Take My Repo yet, which says nothing about its quality. Read from GitHub on 2026-11-21.
In the maintainer's words. Shown from GitHub; Take My Repo does not keep a copy.
๐ค AI-First Code Analysis Platform with Intelligent Reasoning
The most comprehensive suite of AI-optimized development tools, featuring structured JSON APIs, intelligent reasoning capabilities, and enterprise-grade safety. Built for AI agents, with 100+ tools providing lightning-fast analysis (10-100x faster than traditional tools) and unbreakable safety guarantees - preventing disasters like Replit's AI database wipe while enabling unprecedented development velocity.
โ
Phase 1: Unified JSON API - Production-ready programmatic access
โ
Phase 2: AI Reasoning System - Intelligent analysis with risk assessment
โ
Phase 3: Python SDK - High-level interfaces for seamless integration
The rise of AI coding assistants has introduced a new paradigm, but it comes with critical trade-offs that impact safety, performance, and cost.
The Problem (The "Before"):
rm -rf / or unsafe git commands, leading to catastrophic data loss, as seen in the recent Replit AI disaster.The Solution (The "After" with Our Toolkit):
While many excellent tools exist for individual tasks, our platform is unique in its ability to prevent the specific, high-stakes failure modes of modern, AI-assisted development.
| Domain | The Risk (Common & Real-World Failures) | Our Solution (Code Intelligence Toolkit) |
|---|---|---|
| AI & System Integrity | โข The Replit Incident: AI agents with direct shell access wiping production databases. โข The 2017 GitLab Outage: Engineers under pressure running rm -rf on the wrong server. |
An AI-First Safety Platform with system-level command interception and a Safe File Manager that makes destructive operations reversible. |
| Code Refactoring & Data Loss | โข Losing your entire editor undo history after a bad AI edit. โข Losing committed work to a mistaken git reset --hard or push --force. |
A Multi-Level Undo System that operates independently from the editor's buffer, and a SafeGIT wrapper that automatically creates backups before any destructive Git operation. |
| Static Analysis & Deployment | โข The Knight Capital Glitch ($440M loss from a silent breaking change). โข Alert fatigue from tools producing up to 50% false positives. |
Our AI Reasoning System and semantic_diff_v3.py analyze what code actually does, flagging breaking changes and providing insights with confidence scoring to eliminate noise. |
Recent incidents demonstrate the critical need for AI-safe development tools:
rm -rf / destroying entire development environmentsOur Solution: The only toolkit that provides unbreakable AI safety infrastructure - dangerous operations are intercepted at the system level, making disasters impossible while preserving full AI automation capabilities and enhancing any AI assistant you already use.
| Tool Category | Market Leaders | Annual Cost | Our Toolkit |
|---|---|---|---|
| Static Analysis | CodeAnt.ai ($120-240/year), SonarQube Enterprise ($8,000+) | $120-8000+ | $0 |
| Refactoring Tools | IntelliJ Ultimate ($169/year), IDE + plugins | $169+ | $0 |
| Documentation Tools | Confluence ($5-6/user/mo), GitBook ($8-12/user/mo) | $60-144/year | $0 |
| Safety & Recovery | Enterprise backup solutions ($100s-1000s/year) | $100-1000+ | $0 |
| AI Safety Infrastructure | Custom solutions, enterprise security tools | $1000-5000+ | $0 |
| Development Infrastructure | Complete platform with all capabilities above | TOTAL: $1,500-15,000+/year | $0 |
Note: Keep your existing AI assistant (Claude Code, Cursor, Copilot, etc.) - our toolkit enhances their capabilities with safety and intelligence.
If you're using AI coding assistants โ Add unbreakable safety protection without changing your workflow
If you're frustrated with slow IDEs โ Give your AI assistant 40x faster refactoring tools to use
If you're drowning in false positives โ Provide your AI with reasoning systems that explain what actually matters
If you're tired of tool subscription costs โ Get enterprise-grade infrastructure for free
If you need comprehensive AI-safe development โ Get analysis, intelligence, and safety designed for AI automation
In summary, our toolkit is the missing infrastructure layer that makes AI-driven development safe, intelligent, and cost-effective. It integrates Analysis, Intelligence, and Safety into a single platform designed to enhance any AI assistant - at zero cost with unbreakable safety guarantees.
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ Users & AI Agents โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ โ
โผ โผ
โโโโโโโโโโโโโโโโโโโ โโโโโโโโโโโโโโโโโโโ
โ Python SDK โ โ Unified JSON APIโ
โ High-Level โ โ Programmatic โ
โ Interface โ โ Access โ
โโโโโโโโโโโฌโโโโโโโโ โโโโโโโโโโโฌโโโโโโโโ
โ โ
โโโโโโโโโโโฌโโโโโโโโโโ
โผ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ Intelligence Layer โ
โ โข AI Reasoning Engine โ
โ โข Risk Assessment โ
โ โข Security Analysis โ
โ โข Quality Metrics โ
โโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโ
โผ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ Core Tool Suite โ
โ โข AST Analysis (100% accurate)โ
โ โข Data Flow Tracking โ
โ โข Safe File Operations โ
โ โข Git Safety Wrapper โ
โ โข Semantic Search โ
โโโโโโโโโโโโโโโฌโโโโโโโโโโโโโโโโ
โผ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
โ Your Codebase โ
โ Always Current State โ
โ No Persistent Index โ
โโโโโโโโโโโโโโโโโโโโโโโโโโโโโโโ
The Perfect Trilogy: Analysis + Intelligence + Safety = Complete Code Understanding
# Traditional AI coding can be dangerous ai_agent.execute("rm -rf important_files") # ๐ฅ Disaster! # With Code Intelligence Toolkit - Two Approaches: # 1. CLI Approach (Perfect for Claude Code, GitHub Copilot) import subprocess result = subprocess.run([ "./run_any_python_tool.sh", "safe_file_manager.py", "trash", "old_files" # Safe, reversible operation ], capture_output=True, text=True) # 2. API Approach (For custom AI integrations) from code_intelligence.api.client import CodeIntelligenceAPI api = CodeIntelligenceAPI() result = api.execute({ "tool": "safe_file_manager", "params": {"command": "trash", "files": ["old_files"]}, "options": {"non_interactive": True} })
Important for AI Developers: While we provide both CLI and API interfaces, AI coding assistants like Claude Code work best with the CLI due to their subprocess execution model. Both interfaces provide identical functionality - the CLI is just more direct for sandbox environments!
# Single endpoint for all 100+ tools echo '{"tool": "data_flow_tracker_v2", "params": {"--var": "user_input", "--file": "app.py"}, "options": {"include_reasoning": true}}' | ./api.py
{
"ai_reasoning": {
"logical_steps": ["Analyzed variable flow", "Detected security risk"],
"risk_assessment": {
"overall_risk": "high",
"confidence": 0.92,
"security_implications": ["SQL injection possible"]
},
"recommendations": ["Add input validation", "Use parameterized queries"]
}
}from code_intelligence import CodeIntelligence ci = CodeIntelligence('/path/to/project') result = ci.analyze_impact('app.py', 'user_input', include_reasoning=True) print(f"Risk: {result.reasoning['risk_assessment']['overall_risk']}")
1. Non-Interactive Mode - All tools support automation
# Environment variables for CI/CD and AI agents export SAFEGIT_NONINTERACTIVE=1 export SAFE_FILE_MANAGER_ASSUME_YES=1 # Or use command flags ./run_any_python_tool.sh doc_generator_enhanced.py --class MyClass --file code.py --yes --non-interactive
2. Structured Output - Parse results programmatically
# AI agent analyzing code result = subprocess.run([ "./run_any_python_tool.sh", "data_flow_tracker_v2.py", "--var", "user_input", "--file", "app.py", "--json" # Structured output for AI parsing ], capture_output=True, text=True) analysis = json.loads(result.stdout)
3. SafeGIT Integration - Prevent AI disasters
# AI agents CANNOT bypass safety # This is automatically intercepted and requires confirmation subprocess.run(["git", "reset", "--hard"]) # โ Blocked! # Safe alternative subprocess.run([ "./run_any_python_tool.sh", "safegit.py", "--force-yes", # Explicit override for automation "reset", "--hard" ])
git clone https://github.com/Vaibhav-api-code/code-intelligence-toolkit.git cd code-intelligence-toolkit # Set up for AI/automation echo "export CODE_INTEL_NONINTERACTIVE=1" >> ~/.bashrc echo "export SAFEGIT_ASSUME_YES=1" >> ~/.bashrc
class SafeAICodingAgent: def __init__(self, toolkit_path): self.toolkit = toolkit_path def analyze_code(self, file_path): """Safe code analysis with structured output""" cmd = [ f"{self.toolkit}/run_any_python_tool.sh", "doc_generator_enhanced.py", "--file", file_path, "--format", "json", "--non-interactive" ] result = subprocess.run(cmd, capture_output=True, text=True) return json.loads(result.stdout) def refactor_safely(self, old_name, new_name, file_path): """Safe refactoring with automatic backups""" cmd = [ f"{self.toolkit}/run_any_python_tool.sh", "replace_text_ast_v3.py", "--file", file_path, old_name, new_name, "--yes" # Non-interactive mode ] return subprocess.run(cmd, capture_output=True, text=True)
The toolkit leverages ripgrep's extensive file type definitions, supporting 600+ file types out of the box. Run rg --type-list to see all supported types.
Problem: How to prevent AI coding assistants from making dangerous mistakes like file deletion or unsafe Git operations. Solution: A production-ready Python SDK and JSON API with unbreakable safety guarantees, allowing AI agents to perform analysis and refactoring without risk.
Problem: Legacy codebases are hard to understand, document, and maintain
Solution: Quickly analyze complex data flows, understand system dependencies, and automatically generate documentation to facilitate knowledge sharing.
Problem: Code changes introduce vulnerabilities and are hard to audit
Solution: Use data flow tracking and semantic diff tools to audit changes, identify potential vulnerabilities, and enforce security best practices.
Problem: IDEs are slow for large codebases, refactoring is risky, search is limited
Solution: Get a toolkit that is 10-100x faster than your IDE for search and refactoring, with the peace of mind that every operation is safe and reversible.
Perfect for quick tasks, shell scripts, and AI coding assistants like Claude Code:
# Get started in 30 seconds git clone https://github.com/Vaibhav-api-code/code-intelligence-toolkit.git cd code-intelligence-toolkit chmod +x run_any_python_tool.sh # Find TODOs in your code ./run_any_python_tool.sh find_text_v7.py "TODO" --scope src/ --json # Generate documentation ./run_any_python_tool.sh doc_generator_enhanced.py MyClass --style technical # Safe refactoring ./run_any_python_tool.sh unified_refactor_v2.py rename oldMethod newMethod --file app.py # Auto-detects backend # Analyze dependencies ./run_any_python_tool.sh dependency_analyzer.py MyClass --export-all
Ideal for automation, integrations, and building AI-powered tools:
# Method 2a: Direct API usage (for Python integrations) from code_intelligence.api.client import CodeIntelligenceAPI api = CodeIntelligenceAPI() # Single operation result = api.execute({ "tool": "find_text_v7", "params": {"pattern": "TODO", "--scope": "src/"}, "options": {"cache": True, "include_reasoning": True} }) # Batch operations results = api.batch_execute([ {"tool": "find_text_v7", "params": {"TODO": True}}, {"tool": "replace_text_v9", "params": {"TODO": True, "DONE": True}} ])
# Method 2b: API via command line (for shell scripts/CI/CD) # Single request echo '{"tool": "find_text_v7", "params": {"TODO": true, "--json": true}}' | python3 api.py # Interactive mode python3 api.py > {"tool": "doc_generator_enhanced", "params": {"MyClass": true}} # Start API server python3 api.py --server --port 8080 # Then use curl/wget/any HTTP client curl -X POST http://localhost:8080/analyze \ -H "Content-Type: application/json" \ -d '{"tool": "semantic_diff_v3", "params": {"file1": "v1.py", "file2": "v2.py"}}'
Use CLI when:
Use API when:
Note: The
run_any_python_tool.shwrapper handles environment setup and ensures all tools run with the correct shared configuration.
What you get immediately:
For those using AI coding assistants or requiring enterprise-grade protection:
# Block direct access to dangerous commands # See "Achieving Maximum Safety" section below for full setup
Additional protection:
The AI coding revolution has a safety problem. Recent incidents like Replit's AI wiping production databases show what happens when AI agents have unrestricted access to powerful commands.
This toolkit is the solution - providing AI agents with:
# Protects against common disasters: ./run_any_python_tool.sh safegit.py reset --hard # โ Creates backup first ./run_any_python_tool.sh safegit.py clean -fdx # โ Shows preview ./run_any_python_tool.sh safegit.py push --force # โ Converts to --force-with-lease
# Every operation is reversible: ./run_any_python_tool.sh safe_file_manager.py move important.doc backup/ ./run_any_python_tool.sh safe_file_manager.py trash old_files/ # To trash, not gone ./run_any_python_tool.sh safe_file_manager.py undo --interactive # Recover anything
# Track how data flows through your code:
./run_any_python_tool.sh data_flow_tracker_v2.py --var user_input --file app.py
./run_any_python_tool.sh data_flow_tracker_v2.py --var result --direction backwardThe Code Intelligence Toolkit provides 100+ command-line tools for developers who value their data. Every tool is designed with safety first, productivity second.
Our toolkit deliberately avoids persistent indexing - this is a cornerstone feature, not a limitation:
This "faster, safer, and more accurate" philosophy ensures that the toolkit provides reliable, current analysis without the complexity and resource overhead of maintaining persistent state.
Transform your toolkit into an AI-first platform with structured APIs, intelligent reasoning, and seamless integration.
Production-ready programmatic access to all 100+ tools
# Interactive mode ./api.py > {"tool": "find_text_v7", "params": {"TODO": true, "--limit": 5}} # Pipe mode echo '{"tool": "data_flow_tracker_v2", "params": {"--var": "user_input", "--file": "app.py"}}' | ./api.py # Demo mode ./api.py --demo
Key Features:
Intelligent analysis with structured reasoning output
Enhanced tools with AI-powered insights:
./run_any_python_tool.sh data_flow_tracker_v2.py --var user_input --file app.py --output-reasoning-json
{
"ai_reasoning": {
"risk_assessment": {
"overall_risk": "high",
"confidence": 0.92,
"security_implications": ["SQL injection possible"]
},
"recommendations": [
"Add input validation before database operations",
"Use parameterized queries to prevent SQL injection"
]
}
}./run_any_python_tool.sh doc_generator_enhanced.py --file MyClass.java --output-reasoning-json
./run_any_python_tool.sh semantic_diff_v3.py file1.py file2.py --output-reasoning-json
High-level interfaces for seamless integration
# Install the SDK pip install -e . # High-level interface for AI agents from code_intelligence import CodeIntelligence ci = CodeIntelligence('/path/to/project') # Analyze impact with AI reasoning result = ci.analyze_impact('app.py', 'user_input', include_reasoning=True) print(f"Risk: {result.reasoning['risk_assessment']['overall_risk']}") # Generate documentation with quality assessment docs = ci.generate_documentation('MyClass.java', style='api-docs') print(f"Quality: {docs.reasoning['quality_assessment']['clarity_score']:.1%}") # Safe refactoring with language-aware backend selection and impact analysis refactor = ci.refactor_safely('oldName', 'newName', scope='project') # Auto-detects Java/Python per file print(f"Modified {refactor.files_modified} files using {len(refactor.backends_used)} different backends")
SDK Packages:
analysis/: DataFlowAnalyzer, ImpactAssessor, ASTNavigator, SemanticDiffAnalyzerdocumentation/: DocumentationGenerator, StyleFormatterrefactoring/: SafeRefactorer, ASTRefactorersafety/: GitSafety, FileSafetyapi/: CodeIntelligenceAPI client# AI agent searching massive codebase efficiently import time start = time.time() result = subprocess.run([ "./run_any_python_tool.sh", "find_text_v7.py", "security_issue", "--json" ], capture_output=True, text=True) print(f"Searched 1M+ lines in {time.time() - start:.1f}s") # 0.8s vs grep's 45s! # Edit 15,000 line file AI IDE tools # โ Timeout/crash/truncate replace_text_v9.py "old" "new" big.py # โ 0.3 seconds + backup + undo # Rename variable across 500 files Manual IDE refactoring # 2-3 minutes + verification replace_text_ast_v3.py oldVar newVar # 3 seconds + automatic backup # Extract all methods from large file Manual copy/paste # 10+ minutes find_text_v7.py --extract-method-alllines # 0.2 seconds
| Task | Traditional Method | Our Tools | Speedup |
|---|---|---|---|
| Search 1M lines | grep -r: 45s |
find_text_v7.py: 0.8s |
56x faster |
| Edit 15k line file | AI IDE: crash/timeout | replace_text_v9.py: 0.3s |
โ Works |
| Find symbol usage | IDE indexing: 30s+ | navigate_ast.py: 0.1s |
300x faster |
| Rename across project | IDE refactor: 2-3 min | replace_text_ast_v3.py: 3s |
40x faster |
| Extract all methods | Manual: 10+ min | find_text_v7.py: 0.2s |
3000x faster |
| Safe file move | mv + manual backup |
safe_file_manager.py: instant |
โ Reversible |
| Git reset recovery | Often impossible | safegit.py: automatic |
โ Always safe |
Our toolkit includes over 100 tools for every stage of development, from lightning-fast search and safe refactoring to deep data flow analysis and automated documentation. The entire suite is accessible via our Unified JSON API and Python SDK.
Core Capabilities:
โก๏ธ See the Complete Feature List and Tool Reference โ
Built for safety at every level:
SafeGIT-style undo capabilities for all text operations:
# Every operation is tracked automatically ./run_any_python_tool.sh replace_text_v9.py "old" "new" file.py # Output: [Undo ID: 1753732740927_91513] Use 'text_undo.py undo --operation 1753732740927_91513' to undo. # View operation history ./run_any_python_tool.sh text_undo.py history ./run_any_python_tool.sh text_undo.py history --file specific.py # Undo last operation ./run_any_python_tool.sh text_undo.py undo --last --yes # Undo specific operation ./run_any_python_tool.sh text_undo.py undo --operation 1753732740927_91513 --yes # Clean old operations ./run_any_python_tool.sh text_undo.py clean --older-than 30d
Tools with integrated undo support:
replace_text_v9.py - All text replacements trackedreplace_text_ast_v3.py - AST-based refactoring with undounified_refactor_v2.py - Universal refactoring with historyrefactor_rename_v2.py - Batch operations with rollbacksafe_file_manager.py - File operations with recoveryReleased: July 28, 2025 - This major release completes the migration of all critical tools to use unified interactive utilities, eliminating EOF errors in CI/CD environments while introducing revolutionary tool version updates.
All Python tools now use a shared module for handling interactive prompts:
replace_text_v9.py, replace_text_ast_v3.py, unified_refactor_v2.py# Before (EOF crash in CI): echo "" | python text_undo.py undo --last # EOFError: EOF when reading a line # After (helpful error with solutions): echo "" | python text_undo.py undo --last # โ ERROR: Interactive confirmation required but running in non-interactive mode. # Use --yes flag to skip confirmation # Or set TEXT_UNDO_ASSUME_YES=1 environment variable # Or set 'assume_yes = true' in .pytoolsrc [text_undo] section
Migrated Tools:
text_undo.py - Multi-level undo with interactive selectionsafe_file_manager.py - Enterprise file operationssafegit.py - Git safety wrapper with risk-based confirmationsreplace_text_v9.py - Text replacement with multi-level undoreplace_text_ast_v3.py - AST refactoring with scope awarenessComplete rewrite with breakthrough intelligence capabilities:
# Revolutionary intelligence in action
./run_any_python_tool.sh data_flow_tracker_v2.py --var total --show-impact --explain --output-html --file calc.pyTwo complementary tools that transform code analysis into professional documentation:
# AI agent generating documentation after writing code import subprocess import json def generate_docs(class_name, file_path): """AI-safe documentation generation with structured output""" result = subprocess.run([ "./run_any_python_tool.sh", "doc_generator_enhanced.py", "--class", class_name, "--file", file_path, "--format", "json", "--non-interactive" ], capture_output=True, text=True) return json.loads(result.stdout) # Example: AI agent documents the code it just created docs = generate_docs("UserManager", "auth.py") print(f"Generated {len(docs['methods'])} method documentations")
archive/ structureCurrent Active Tools:
data_flow_tracker_v2.py (with intelligence layer) โ NEW MAJOR FEATUREdoc_generator.py (automated documentation) โ NEW MAJOR FEATUREdoc_generator_enhanced.py (with full AST integration) โ ENHANCED VERSIONfind_text_v7.py (with multiline search) โ Latestreplace_text_v9.py (with escape sequences + multi-level undo) โ Latestreplace_text_ast_v3.py (enhanced AST refactoring + multi-level undo) โ Latest# ๐ Generate API documentation with enhanced AST integration ./run_any_python_tool.sh doc_generator_enhanced.py --function calculatePrice --file pricing.py --style api-docs # ๐ Create interactive HTML documentation with 6 analysis tabs ./run_any_python_tool.sh doc_generator_enhanced.py --class MyClass --file MyClass.java --style api-docs --format interactive # ๐ฅ Create user-friendly guides for classes ./run_any_python_tool.sh doc_generator_enhanced.py --class UserManager --file auth.py --style user-guide --depth deep # ๐ฌ Generate architecture documentation with call graphs ./run_any_python_tool.sh doc_generator_enhanced.py --module --file database.py --style architecture --format html # โก Quick reference cards ./run_any_python_tool.sh doc_generator_enhanced.py --function process_data --file data.py --style quick-ref --format docstring # ๐ Tutorial-style documentation ./run_any_python_tool.sh doc_generator_enhanced.py --class APIClient --file client.py --style tutorial --depth medium
# ๐ง Natural Language Explanations - Understand analysis instantly ./run_any_python_tool.sh data_flow_tracker_v2.py --var config --show-impact --explain --file app.py # ๐ Interactive HTML Visualization - Explore dependencies visually ./run_any_python_tool.sh data_flow_tracker_v2.py --var total --show-calculation-path --output-html --file calc.py # ๐ฏ Combined Intelligence - Best of both worlds ./run_any_python_tool.sh data_flow_tracker_v2.py --var data --track-state --explain --output-html --file process.py # โก All V2 analysis modes support intelligence layer ./run_any_python_tool.sh data_flow_tracker_v2.py --var x --direction backward --explain --file module.py
Shows where data escapes scope with risk assessment and actionable recommendations:
Extracts the minimal "critical path" showing exactly how values are calculated:
Monitors how variable types and states evolve through code execution:
--explain)Converts technical analysis into intuitive explanations:
--output-html)Self-contained professional reports with zero external dependencies:
doc_generator.py & doc_generator_enhanced.py)Transform code analysis into professional documentation:
doc_generator.py): Data flow intelligence integrationdoc_generator_enhanced.py): Full AST tool integration with 5 analysis enginesThe Perfect Trilogy: Analysis + Visualization + Documentation = Complete Code Understanding
--line optional for --comments-only and --strings-only modes in AST toolReleased: July 28, 2025 - This major release completes the migration of all critical tools to use unified interactive utilities, eliminating EOF errors in CI/CD environments.
All Python tools now use a shared module for handling interactive prompts:
.pytoolsrc settings for project defaults# Before (EOF crash): echo "" | python text_undo.py undo --last # EOFError: EOF when reading a line # After (helpful message): echo "" | python text_undo.py undo --last # ERROR: Interactive confirmation required but running in non-interactive mode. # Use --yes flag to skip confirmation # Or set TEXT_UNDO_ASSUME_YES=1 environment variable # Or set 'assume_yes = true' in .pytoolsrc [text_undo] section
Tools now check for settings in this order:
--yes, --non-interactive (highest priority){TOOL}_ASSUME_YES=1[tool_name] section[defaults] sectionThe toolkit includes pre-configured profiles for different environments:
.pytoolsrc.ci - CI/CD automation with auto-confirm and non-interactive mode.pytoolsrc.automation - Local automation with balanced safety and speed.pytoolsrc.safe - Maximum safety with dry-run and interactive confirmations# Use different configuration profiles export PYTOOLSRC=.pytoolsrc.ci # For CI/CD export PYTOOLSRC=.pytoolsrc.automation # For local automation export PYTOOLSRC=.pytoolsrc.safe # For production/critical work
rg)The toolkit uses a modular dependency system:
Core Dependencies (Required for basic functionality):
javalang>=0.13.0 - Java AST parsing supportOptional Dependencies (For enhanced features):
markdown>=3.3.0 - Enhanced HTML conversion in doc_generator.py (falls back to built-in converter if not installed)jinja2>=3.0.0 - Template engine for clean separation of HTML presentation from logic (falls back to built-in templates if not installed)rope>=1.0.0 - Advanced Python refactoring capabilitiesnumpy, pandas, scikit-learn - Advanced semantic diff featuresastroid>=2.0.0 - Enhanced Python AST analysisrequirements-optional.txt for complete listgit clone https://github.com/[your-username]/code-intelligence-toolkit.git
cd code-intelligence-toolkit# Core dependencies only (minimal installation) pip install -r requirements-core.txt # Or install everything including optional features pip install -r requirements.txt # Installs both core and optional
./setup_config.sh # Interactive configuration# Try a dangerous operation (it will be blocked)
./run_any_python_tool.sh safegit.py reset --hard HEAD~1class AICodeReviewer: def __init__(self, toolkit_path): self.toolkit = toolkit_path def find_security_issues(self, project_path): """AI agent scanning for security vulnerabilities""" cmd = [ f"{self.toolkit}/run_any_python_tool.sh", "find_text_v7.py", "password|secret|api_key", "--scope", project_path, "--extract-method", # Get full context "--json" ] result = subprocess.run(cmd, capture_output=True, text=True) findings = json.loads(result.stdout) # AI analyzes each finding for finding in findings: if self.is_security_risk(finding['code']): self.flag_for_review(finding)
class AIRefactoringAgent: def rename_across_codebase(self, old_name, new_name, file_pattern="*.py"): """Safe, AST-aware renaming across entire project""" # First, find all occurrences search_cmd = [ f"{self.toolkit}/run_any_python_tool.sh", "find_text_v7.py", old_name, "--json", "--scope", "src/" ] occurrences = self.run_command(search_cmd) # Then safely rename with AST understanding for file in occurrences['files']: rename_cmd = [ f"{self.toolkit}/run_any_python_tool.sh", "replace_text_ast_v3.py", "--file", file, old_name, new_name, "--yes" # Non-interactive ] result = self.run_command(rename_cmd) print(f"Renamed in {file}: {result['changes_made']} occurrences")
class AIDocumentationAgent: def document_new_code(self, file_path): """AI agent auto-documents code it just created""" # Generate comprehensive documentation doc_cmd = [ f"{self.toolkit}/run_any_python_tool.sh", "doc_generator_enhanced.py", "--file", file_path, "--style", "api-docs", "--format", "interactive", "--output", f"{file_path}.html", "--non-interactive" ] self.run_command(doc_cmd) # Also generate user guide guide_cmd = doc_cmd.copy() guide_cmd[guide_cmd.index("api-docs")] = "user-guide" guide_cmd[-2] = f"{file_path}_guide.html" self.run_command(guide_cmd) return f"Documentation generated: {file_path}.html"
class AIGitManager: def safe_commit(self, ai_generated_message): """AI safely commits code with auto-generated messages""" # Stage changes safely stage_cmd = [ f"{self.toolkit}/run_any_python_tool.sh", "safegit.py", "add", "-u", "--yes" ] self.run_command(stage_cmd) # Generate enhanced commit message analyze_cmd
Vaibhav-api-code/code-intelligence-toolkit is a public repo on GitHub by Vaibhav-api-code. An AI-first code analysis and safe refactoring platform with a Python SDK and JSON API. Designed for AI agents with a zero-index architecture for 100x speed and unbreakable safety.
It declares the MPL-2.0 license on GitHub.
Its maker has not tagged a system, so it is unknown here. Its README says what it needs.
Open "Take it" on its page: Take My Repo writes an install plan for your machine and hands it to your AI agent (Claude Code, Codex or Cursor), which asks you before each step. Take My Repo has not tested it on any machine.
Its last change on GitHub was on 2025-07-29. Take My Repo does not judge from that whether it is maintained.
Nobody has reviewed it on Take My Repo yet, which says nothing about its quality.
Independent Auditing of AI Agents. Run by human or the agent itself, to answer the most crucial question in the AI Agent Economy. Is the agent doing what is supposed to do? With iFixAi you can have this answer in less than 120 seconds.
An advanced, unified platform for code quality, architectural metrics, and Agile analytics. Features Python AST parsing, Java static analysis (code smells), and interactive project health dashboards built with Streamlit.

Shannon is an AI pentester for web applications and APIs. It analyzes your source code, identifies attack vectors, and executes real exploits to prove vulnerabilities before they reach production.

The agent harness performance optimization system. Skills, instincts, memory, security, and research-first development for Claude Code, Codex, Opencode, Cursor and beyond.
Reverse engineer anything with agents, from app behavior down to native binaries.
This page is also available as structured data, with the same sources and dates.
/api/v1/resources/gh/Vaibhav-api-code/code-intelligence-toolkitTake My Repo has not tested this on your machine. Requirements come from the project's own documentation.