time-complexity
/time-complexity
Estimate Big-O time complexity of code via static analysis (tree-sitter MCP). Use when: complexity, big-o, performance, hotspot, time complexity, analyze complexity.
- Author
- andreibesleaga ↗
- Repository
- gabbe ↗
- Licence
- CC-BY-4.0
- Last repository change
- 24.10.2026
Assessment and security
- Files in this package
- 2
- Scripts
- 0
- HTML comments
- 0
- URLs in SKILL.md
- 1
No signals detected. Repository changed on 24.10.2026, without references to retired models or APIs.
CC-BY-4.0, otwarta.
What it does and when to use it
Estimate Big-O time complexity of code via static analysis (tree-sitter MCP). Use when: complexity, big-o, performance, hotspot, time complexity, analyze complexity.
Original author description
Estimate Big-O time complexity of code via static analysis (tree-sitter MCP). Use when: complexity, big-o, performance, hotspot, time complexity, analyze complexity.
How it works
- Goal
- Prerequisites
- Supported Languages
- Capabilities
- Steps
- Deliverables
- Usage Examples
- Security & Guardrails
SKILL.md preview
--- name: time-complexity description: "Estimate Big-O time complexity of code via static analysis (tree-sitter MCP). Use when: complexity, big-o, performance, hotspot, time complexity, analyze complexity." license: CC-BY-SA-4.0 metadata: source: "agents/skills/coding/time-complexity.skill.md" tags: "coding, performance, analysis" core: "false" context_cost: "medium" --- # Time Complexity Skill ## Goal Estimate Big-O time complexity of functions, files, directories, or entire GitHub repositories using the **time-complexity-mcp** server — a static-analysis engine powered by tree-sitter. No code execution; code is parsed into ASTs and inspected. ## Prerequisites - **MCP Server**: `time-complexity` must be configured in your MCP config (see `templates/core/MCP_CONFIG_TEMPLATE.json`). - **Runtime**: Node.js 18+ on the host machine. - **Optional**: `git` in PATH (required only for `analyze_github_repo`). ## Supported Languages JavaScript (`.js`, `.mjs`, `.cjs`, `.jsx`), TypeScript (`.ts`, `.tsx`), Python (`.py`), Java (`.java`), Go (`.go`), PHP (`.php`), Dart (`.dart`), Kotlin (`.kt`, `.kts`). ## Capabilities ### 1. MCP Tools Available | Tool | Purpose | |---|---| | `analyze_file` | Analyze all functions in a single source file | | `analyze_function` | Analyze a specific named function in a file | | `analyze_directory` | Scan an entire directory for complexity hotspots | | `analyze_github_repo` | Clone and analyze a public GitHub repo (requires `git`) | | `get_supported_languages` | List all file extensions the server can parse | ### 2. What It Detects - **Loop nesting** — `for`, `while`, `do-while` with depth tracking. Constant-bound loops (e.g., `for i in range(10)`) recognized as O(1). - **Recursion** — Linear recursion (O(n)) vs branching recursion like Fibonacci (O(2^n)). - **Known stdlib methods** — `.sort()` as O(n log n), `.filter()`/`.map()` as O(n), `.push()`/`.pop()` as O(1). Each language has its own patterns. - **Combined complexity** — An O(n) method inside an O(n) loop correctly reports O(n²). ### 3. Output Format Results include per-function complexity with: - **Function name and line range** - **Big-O classification** (O(1), O(n), O(n log n), O(n²), O(n³), O(2^n)) - **Reasoning** (loop counts, nesting depth, recursion type) - **Line-level annotations** (which line contributes which complexity) ## Steps 1. **Scope the analysis** - Single function → `analyze_function` - Entire file → `analyze_file` - Directory / codebase → `analyze_directory` - External repo → `analyze_github_repo` 2. **Interpret results** - Focus on functions with O(n²) or worse — these are performance hotspots. - Check line annotations to understand *where* complexity accumulates. - Verify constant-bound loops are correctly recognized as O(1). 3. **Act on findings** - Use `refactor.skill` to restructure high-complexity functions. - Use `performant-*.skill` for language-specific optimizations. - Document findings in `TIME_COMPLEXITY_REPORT_TEMPLATE.md`. 4. **Integrate into workflow** - Run before code reviews (`code-review.skill`) to flag regression. - Run on PR diffs to catch new O(n²)+ code. - Run on full codebase periodically to track complexity trends. ## Deliverables - `TIME_COMPLEXITY_REPORT_TEMPLATE.md`: Structured complexity analysis with hotspots and recommendations. ## Usage Examples ### Analyze a single file ``` > Analyze the complexity of src/utils/sort.ts ``` ### Analyze a specific function ``` > What's the complexity of the fibonacci function in recursion.py? ``` ### Scan an entire codebase for hotspots ``` > Scan src/ for complexity hotspots ``` ### Analyze a GitHub repository ``` > Analyze the complexity of facebook/react ``` ### Focus on a subdirectory of a remote repo ``` > Analyze https://github.com/expressjs/express, focus on the lib/ directory ``` ## Security & Guardrails ### 1. Skill Security (Time Complexity) - **Static Analysis Only**: Code is parsed into ASTs and inspected — never evaluated, executed, or imported. No risk of running malicious code. - **Read-Only File Access**: Source files are read for parsing. Nothing is written, modified, or deleted. - **Scope Limiting**: When analyzing directories, be aware of repo size. For very large codebases, scope to specific subdirectories. ### 2. System Integration Security - **Network Access (opt-in)**: The `analyze_github_repo` tool invokes `git clone` to fetch public GitHub repos. All other tools run locally with no network access. Clone URLs are restricted to HTTPS GitHub URLs only. - **No Secrets Exposure**: The tool does not process environment variables, config files, or secrets — only source code syntax. ### 3. LLM & Agent Guardrails - **Over-reliance on Static Analysis**: Big-O from static analysis is an *estimate*. It cannot account for runtime data distributions, caching effects, or algorithm-specific constants. Always note: "Static estimate — verify with runtime profiling for critical paths." - **False Precision**: The tool may report O(n) for a function that is effectively O(1) due to bounded inputs in practice. Do not blindly optimize functions flagged as complex without considering real-world usage context. - **Hallucinated Remediation**: When suggesting fixes for high-complexity functions, the agent must provide concrete, tested alternatives — not theoretical rewrites that may introduce bugs.
Files in this package (2)
- SKILL.md 5 KB
- TIME_COMPLEXITY_REPORT_TEMPLATE.md 2 KB
Versions
The database has no other skills named time-complexity.
Database snapshot: 13.11.2026 · package version a29d131bc9e0 (SHA-256 digest of the entire package)
Downloads in the last 30 days: 0 · ranking
Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.
Similar skills
- 100analyze-complexity
Use when reviewing or choosing code on a hot path or over user data — estimate Big-O and amortized cost, and decide when O(n²) is a bug versus a style point. - 100code-complexity-analysis
Analyzes source code to assess performance using algorithmic complexity (time and space) plus a machine-aware cost model (memory hierarchy, branches, ILP, SIMD, parallelism). Identifies bottlenecks and recommends algorithmic, data-structure, and constant-factor optimizations.… - 100dsa-time-space-complexity-big-o-analysis
Use this skill when rigorously analyzing algorithm asymptotic runtime, call stack memory, and auxiliary space for technical interviews. - 100complexity-analyzer
Analyzes cyclomatic and cognitive complexity, identifies overly complex functions. Use when assessing code complexity or identifying functions that need simplification. - 100algorithmic-complexity-review
Algorithmic complexity (Big-O) review — finding nested loops, N+1 queries, exponential recursion, quadratic string builds, and other accidental complexity blowups. Covers Python, JavaScript/TypeScript, Java, Go, and similar languages. Use whenever writing, reviewing, or… - 96complexity-management
Use when the complexity gate fails or a function approaches a limit.