Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
athola avatar

Context Map

  • 76 installs
  • 325 repo stars
  • Updated August 2, 2026
  • athola/claude-night-market

context-map is an agent skill that emits a compressed repo map so agents skip redundant file reads.

About

context-map is an agent skill that generates a compressed project context map so solo builders and their assistants avoid expensive Read and Grep discovery on every session. The SKILL.md positions it at session start, before feature work, and when exploring an unfamiliar codebase—exactly when token waste hurts most on Claude Code, Cursor, or Codex. It pre-compiles structure, multi-ecosystem dependencies, entry points, import relationships, blast-radius hot files, HTTP routes, env var usage, and middleware hints into a single map developers can skim before touching code. That turns vague “where does auth live?” questions into guided entry points and reduces the chance you refactor a highly imported module by accident. Complexity is intentionally low: no production deploy steps, just exploration hygiene. Pair it with implementation or review skills once the map highlights the files that matter.

  • Detects directory layout with file counts and languages across Python, Node, Rust, Go, and Java ecosystems
  • Builds an import graph and flags hot files imported by three or more others before you edit
  • Surfaces framework hints from dependencies plus API routes for FastAPI, Flask, Express, and Hono
  • Lists environment variable references with defaults and common middleware patterns
  • Frontmatter estimates ~300 tokens and targets fast models for session-start scans

Context Map by the numbers

  • 76 all-time installs (skills.sh)
  • Ranked #1,473 of 3,282 Productivity & Planning skills by installs in the Skillselion catalog
  • Security screen: MEDIUM risk (skills.sh audit)
  • Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/athola/claude-night-market --skill context-map

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs76
repo stars325
Security audit2 / 3 scanners passed
Last updatedAugust 2, 2026
Repositoryathola/claude-night-market

What it does

Build a one-screen structural map of an unfamiliar repo so your agent stops burning tokens on blind Read and Grep loops.

Who is it for?

Best when you're jumping into monorepos or client codebases and want a fast structural briefing before the first real edit.

Skip if: Skip if you already maintain up-to-date architecture docs and do not need automated rescans each session.

When should I use this skill?

At session start or before implementing features in an unfamiliar codebase, per SKILL.md When to Use.

What you get

You get a structural map with import graph, hot files, routes, and env references so the next implementation or review step targets the right entry points.

  • Compressed context map covering structure, dependencies, entry points, import graph, routes, and env references
  • Hot-file list highlighting high blast-radius modules

By the numbers

  • Estimated ~300 tokens in skill frontmatter for the map workflow
  • Hot files defined as those imported by 3+ other files

Files

SKILL.mdMarkdownGitHub ↗

Context Map

Generate a compressed context map for the current project. The map pre-compiles structural knowledge that AI assistants would otherwise discover through expensive Read/Grep calls, saving thousands of tokens per session.

When to Use

  • At the start of a session to understand project layout
  • Before implementing features to identify entry points
  • When exploring an unfamiliar codebase
  • To reduce token waste from Read calls
  • To identify hot files (high blast radius) before changes

What It Detects

CategoryDescription
StructureDirectory layout with file counts and languages
DependenciesMulti-ecosystem: Python, Node, Rust, Go, Java
FrameworksFramework detection from dependency analysis
Entry Pointsmain.py, index.ts, CLI scripts, etc.
Import GraphFile-to-file import relationships
Hot FilesFiles imported by 3+ others (high blast radius)
RoutesFastAPI, Flask, Express, Hono API endpoints
Env VarsEnvironment variable references with defaults
MiddlewareAuth, CORS, rate-limit, logging patterns
Models/SchemasSQLAlchemy, Django, Pydantic, Prisma definitions
Token SavingsEstimated tokens saved vs manual exploration

Procedure

1. Run the scanner on the project root:

PYTHONPATH="$(find . -path '*/conserve/scripts' -type d \
  -print -quit 2>/dev/null || \
  echo 'plugins/conserve/scripts')" \
  python3 -m context_scanner .

2. Present the output to the user as the project overview.

3. Use the context map to guide subsequent file reads. Prioritize hot files and entry points first.

Options

Output

  • --format json for structured output
  • --max-tokens N to adjust output size (default: 5000)
  • --output FILE to save to a file

Modes

  • --blast FILE to show blast radius for a specific file
  • --section NAME to output a single section

(routes, deps, env, hot-files, models, structure, middleware, frameworks)

  • --wiki-only to generate wiki articles without stdout

Opt-out

  • --no-cache to force a fresh scan
  • --no-wiki to skip wiki article generation

Wiki Articles

The scanner generates per-topic knowledge articles in .codesight/ for selective context loading:

python3 scanner.py .
# Creates .codesight/INDEX.md, auth.md, database.md, etc.

Load only what you need per session instead of the full map:

python3 scanner.py --section routes .
# ~200 tokens vs ~5,000 for the full map

Example Output

# Context Map: myproject
Files: 127

## Structure
  src                  42 files (Python)
  tests                18 files (Python)
  docs                  5 files (Markdown)

## Dependencies (Python)
Package manager: uv
  - fastapi 0.104.0
  - pydantic 2.5.0
  - sqlalchemy 2.0.0
  ...12 more

## Frameworks Detected
  - FastAPI
  - SQLAlchemy
  - Pytest

## Routes
  GET    /users          (src/routes/users.py)
  POST   /users          (src/routes/users.py)
  GET    /users/{id}     (src/routes/users.py)

## Hot Files (high blast radius)
  - src/models/base.py (12 importers)
  - src/utils/auth.py (8 importers)

## Environment Variables
  - DATABASE_URL (required)
  - SECRET_KEY (has default)

## Token Savings: ~12,600 tokens saved
  Routes: ~1,200
  Hot files: ~300
  Env vars: ~200
  File scanning: ~10,200

Exit Criteria

  • [ ] Scanner produces output covering at minimum: file count,

directory structure, detected frameworks, and hot files (imported by 3+ others); output appears in the session before any feature implementation reads begin

  • [ ] "Token Savings" line is present in the output with a numeric

estimate (e.g., ~12,600 tokens saved)

  • [ ] If --blast FILE is used, blast-radius output names the

specific file and lists its importers by count

  • [ ] Context map guides subsequent reads: hot files and entry points

are consulted before any other file read in the session

Related skills

How it compares

Token-saving exploration generator, not a deep static-analysis security audit or test runner.

FAQ

Who is context-map for?

Developers and agent users who frequently start cold sessions in unfamiliar or large repositories and need layout without a manual tour.

When should I use context-map?

Use it at Build (agent-tooling) session start, at Idea (discover) when surveying a new repo, and at Ship (review) before editing files the import graph marks as hot.

Is context-map safe to install?

Check the Security Audits panel on this Prism page; the skill scans project structure locally and you should confirm it matches your org’s rules for repository introspection.

Productivity & Planningintegrationsdocs

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.