Skip to content
Skills Library
Programming · Review & audit

openlore-analyze-codebase

/openlore-analyze-codebase

Run a full static OpenLore analysis and summarize architecture, call graph, refactoring issues, and duplicate code. Use when asked to analyze, map, or assess a codebase without LLM inference.

Repository
openlore ↗
Licence
MIT
Last repository change
25.10.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 25.10.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Run a full static OpenLore analysis and summarize architecture, call graph, refactoring issues, and duplicate code. Use when asked to analyze, map, or assess a codebase without LLM inference.

Original author description

Run a full static OpenLore analysis and summarize architecture, call graph, refactoring issues, and duplicate code. Use when asked to analyze, map, or assess a codebase without LLM inference.

How it works

  1. When to use this skill
  2. Step 1 — Confirm the project directory
  3. Step 2 — Run static analysis
  4. Step 3 — Summarize the results
  5. Step 4 — Show the call graph
  6. Step 5 — Show duplicate code report
  7. Step 6 — Suggest next steps
  8. Absolute constraints
Original SKILL.md headings · 96 lines, 559 words
SKILL.md preview
---
name: openlore-analyze-codebase
description: Run a full static OpenLore analysis and summarize architecture, call graph, refactoring issues, and duplicate code. Use when asked to analyze, map, or assess a codebase without LLM inference.
---

# openlore: Analyze Codebase

## When to use this skill

Trigger this skill whenever the user asks to **analyze a codebase** with openlore, with phrasings like:
- "analyze my project / my code"
- "give me a code quality report"
- "what are the structural issues in my codebase"
- "find duplicates in my code"
- explicit command `/openlore-analyze-codebase`

This skill is **read-only** — it modifies no files. It produces a report and suggests next steps.

---

## Step 1 — Confirm the project directory

Ask the user which project to analyze, or confirm the current workspace root.

```
Which project directory should I analyze?
Options: current workspace root | enter a different path
```

---

## Step 2 — Run static analysis

Call the openlore MCP tool `analyze_codebase` with `{"directory": "$DIRECTORY"}`.

---

## Step 3 — Summarize the results

Present a concise summary:
- Project type and detected frameworks
- File count, function count, internal call count
- Top 5 refactoring issues (function name, file, issue type, priority score)
- Detected domains

Also report stack inventory (read directly from `.openlore/analysis/` — no extra MCP call needed):
- **HTTP routes**: N routes across M files — if `route-inventory.json` exists
- **ORM tables**: N tables — if `schema-inventory.json` exists
- **Env vars**: N total, X required without default — if `env-inventory.json` exists
- **UI components**: N components — if `ui-inventory.json` exists

If none of these files exist, skip this section and suggest running `openlore analyze --force`.

---

## Step 4 — Show the call graph

Call the openlore MCP tool `get_call_graph` with `{"directory": "$DIRECTORY"}`.

Highlight:
- **Hub functions** (fanIn ≥ 8) — over-solicited functions, high coupling risk
- **Layer violations** detected (e.g. a UI layer calling the database directly)

---

## Step 5 — Show duplicate code report

Call the openlore MCP tool `get_duplicate_report` with `{"directory": "$DIRECTORY"}`.

Present a concise summary:
- Overall duplication ratio (e.g. "12% of functions are duplicated")
- Top 3 clone groups sorted by impact (instances × line count):
  - Clone type (exact / structural / near) and similarity score
  - List of instances (file + function name + line range)
- If no duplicates found, note this as a positive signal

---

## Step 6 — Suggest next steps

Based on the analysis, guide the user through the natural next actions in order:

1. Call `get_minimal_context` on the highest-priority function — returns callers, callees, body, and test coverage in one call (~300 tokens). Use instead of `get_subgraph` + `get_signatures` separately.
2. Call `get_cluster` on any function to see its full community (tightly coupled neighbors across directories).
3. Call `detect_changes` to rank recently changed functions by blast radius — spot riskiest commits before reviewing.
3. If significant duplication was found, suggest consolidating clone groups **before** refactoring
4. Suggest running `/openlore-plan-refactor` once the user has enough context to act, then `/openlore-execute-refactor` to apply the plan
5. If the project has OpenSpec specs, call `list_spec_domains` then `search_specs` to enable
   spec-first reasoning (question → requirements → linked source files). To activate `search_specs`,
   run `openlore analyze --embed` or `openlore analyze --reindex-specs`.

---

## Absolute constraints

- **No code modifications** in this workflow
- Never skip the duplication step — it determines the order of subsequent actions
- Always present call graph and duplicate report results even if numbers are low
- Next steps (Step 6) are suggestions, not automatic actions

Versions

The database has no other skills named openlore-analyze-codebase.

Identical content appears in 2 other GitHub folders. We show one copy with the highest score.

Database snapshot: 13.11.2026 · package version d9b1de505577 (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

  • 100openlore-review-changes
    Review code changes using OpenLore risk, call, coverage, and cluster evidence without editing code. Use when asked for a change review, pre-PR safety check, or merge recommendation.
  • 100openlore-execute-refactor
    Apply a confirmed .openlore/refactor-plan.md with a test gate after each change. Use when asked to execute or continue an OpenLore refactoring plan.
  • 100codebase-analyzer
    When the user wants a comprehensive technical analysis of a codebase or project. Also use when the user mentions 'analyze this codebase,' 'technical overview,' 'document this architecture,' 'what does this codebase do,' 'summarize this repo,' 'code audit,' 'architecture review,'…
  • 100project-analyze
    This skill should be used when the user asks to "analyze project structure", "explain this codebase", "show dependencies", "find high-risk files", "assess refactor impact", "understand architecture", or run ProjectMind for local codebase analysis.
  • 90analyze-codebase
    Run a multi-agent deep analysis of a codebase, producing AI-readable analysis documents in .ai/docs/ covering structure, dependencies, data flow, request flow, and APIs. Use whenever the user asks to analyze a repository, generate codebase analysis, understand an unfamiliar…
  • 95codebase-analysis
    Produce a structured codebase analysis report with architecture overview, critical files, patterns, and actionable recommendations. Use when asked to "analyze codebase", "explore codebase", "understand this codebase", "map the codebase", "give me an overview of this project",…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.