# Map Codebases and Dependencies

Large repositories are hard to understand quickly. This skill maps structure, imports, entry points, and module boundaries for focused analysis.

## Install

```bash
npx skillstore add dowwie/codebase-mapping
```

## Metadata

- Status: approved
- Slug: dowwie-codebase-mapping
- Skillstore revision: r1
- Version status: missing
- Tree hash: 8994d9eb3b86e5d1c4fc98bfb097a6fb73423acec3a00b4a01c956cf48ce0118
- Author: Dowwie
- GitHub username: Dowwie
- License: MIT
- Repository: https://github.com/Dowwie/agent\_framework\_study/tree/main/.claude/skills/codebase-mapping
- Ref: 0519034dad657fb1f7706e0550e962beeda73fdf
- Supported tools: Claude, Codex, Claude Code
- Audit status: complete
- Agent install advisory: allowed
- Manual install advisory: allowed
- Artifact signature: available
- Audit attestation: unavailable
- Human verification: not\_verified
- Risk factors: filesystem, external\_commands
- Quality score: 72
- Public page: https://skillstore.pages.dev/skills/dowwie-codebase-mapping
- Manifest: https://skillstore.pages.dev/api/skills/dowwie-codebase-mapping/manifest

## Capabilities

- Generates a filtered repository file tree that excludes common build and cache directories.
- Parses Python imports with the standard AST parser.
- Extracts JavaScript and TypeScript imports with pattern matching.
- Builds a dependency graph with files, internal links, and external packages.
- Identifies common Python and Node entry points.
- Lists key files for types, execution, tools, agents, and configuration.

## Use Cases

- Onboard to an unfamiliar repository: Create a quick structure map before reading many files manually.
- Prepare an architecture review: Identify entry points, module boundaries, and key files before deeper design analysis.
- Scope an AI-assisted refactor: Give Claude, Codex, or Claude Code a compact map before planning changes.

## Prompt Templates

### Map a repository

```
Use codebase-mapping on this repository. Summarize the file tree, dependency graph, entry points, and key files in plain language.
```

### Find entry points

```
Run the codebase mapping workflow and focus on likely startup files, command-line entry points, and framework entry files.
```

### Explain module boundaries

```
Map this repository and describe the main modules, their responsibilities, and important internal dependencies.
```

### Plan a refactor from the map

```
Use the generated codebase map to identify risky dependency clusters, stable module boundaries, and files to inspect before refactoring.
```

## Limitations

- Dependency parsing is limited to Python, JavaScript, TypeScript, JSX, and TSX files.
- Dynamic imports and unusual module loading patterns may be missed.
- The script does not validate package versions or dependency health.
- Generated output may include a local repository path unless the script is changed.

## Best Practices

- Run the mapper on a clean local checkout so generated structure matches the current code.
- Review excluded directories before using it on monorepos with custom build folders.
- Use the generated map as a starting point, then inspect important files manually.

## Anti Patterns

- Do not treat the dependency graph as complete when the project uses dynamic imports.
- Do not share generated reports without checking for local paths or sensitive module names.
- Do not use the map as a substitute for tests, runtime tracing, or design review.

## Security Audit

- Audited at: 2026-07-09T11:42:47.974\+00:00
- Summary: The static external-command findings are Markdown fences or inline literals, not Ruby backtick execution. The environment-file finding is an exclusion rule that avoids hidden files and only permits .env.example. A low-severity privacy issue remains because generated output includes the absolute local repository path.

## Stats

- Views: 196
- Downloads: 11
- Favorites: 1
- Popularity score: 0