Code Context Finder

Code Context Finder

Overview

Find and surface relevant context while coding by combining knowledge graph search with code relationship analysis. Uses smart detection to identify when additional context would be helpful, then retrieves:

• Knowledge graph entities: Prior decisions, project context, related concepts
• Code relationships: Dependencies, imports, function calls, class hierarchies

When to Use (Smart Detection)

This skill activates automatically when detecting:

For detection triggers reference, load references/detection_triggers.md.

Core Workflow

1. Detect Context Need

Identify triggers that suggest context would help:

Signals to watch:
- New/unfamiliar file opened
- Error messages mentioning unknown components
- Questions about "why" or "how" something works
- Changes to shared/core modules
- Architectural or design discussions

2. Search Knowledge Graph

Use MCP memory tools to find relevant entities:

# Search for related context
mcp__memory__search_nodes(query="<topic>")

# Open specific entities if known
mcp__memory__open_nodes(names=["entity1", "entity2"])

# View relationships
mcp__memory__read_graph()

Search strategies:

• Module/file names → project context
• Error types → past issues, solutions
• Feature names → prior decisions, rationale
• People names → ownership, expertise

3. Analyze Code Relationships

Find code-level context:

# Find what imports this module
grep -r "from module import" --include="*.py"
grep -r "import module" --include="*.py"

# Find function callers
grep -r "function_name(" --include="*.py"

# Find class usages
grep -r "ClassName" --include="*.py"

# Find test coverage
find . -name "*test*.py" -exec grep -l "module_name" {} \;

For common search patterns, load references/search_patterns.md.

4. Synthesize Context

Present findings concisely:

## Context Found

**Knowledge Graph:**
- [Entity]: Relevant observation
- [Decision]: Prior architectural choice

**Code Relationships:**
- Imported by: file1.py, file2.py
- Depends on: module_a, module_b
- Tests: test_module.py (5 tests)

**Suggested Actions:**
- Review [entity] before modifying
- Consider impact on [dependent files]

Quick Reference

Knowledge Graph Queries

Code Relationship Queries

Integration with Coding Workflow

Before Making Changes

1. Check knowledge graph for context on module/feature 2. Find all files that import/depend on target 3. Locate relevant tests 4. Review prior decisions if architectural

After Making Changes

1. Update knowledge graph if significant decision made 2. Note new patterns or learnings 3. Add observations to existing entities

When Debugging

1. Search knowledge graph for similar errors 2. Find all code paths to affected component 3. Check for related issues/decisions 4. Document solution if novel

Resources

references/

• detection_triggers.md - Detailed trigger patterns for smart detection
• search_patterns.md - Common search patterns for code relationships

scripts/

• find_code_relationships.py - Analyze imports, dependencies, and call graphs

Detection Triggers Reference

Detailed patterns for smart context detection while coding.

File-Based Triggers

New/Unfamiliar Files

Signals:

• First time opening a file in session
• File in unfamiliar directory/module
• File with complex imports or dependencies

Context to retrieve:

• Knowledge graph: module purpose, related decisions
• Code: imports, dependents, tests

Core/Shared Modules

Signals:

• File in core/, shared/, common/, utils/ directories
• File imported by 5+ other files
• File with __init__.py exports

Context to retrieve:

• All importers (impact analysis)
• Related tests
• Prior changes/decisions

Configuration Files

Signals:

• .env, .yaml, .json, .toml config files
• settings.py, config.py
• CI/CD files (.github/, Dockerfile)

Context to retrieve:

• Knowledge graph: deployment notes, environment specifics
• Related infrastructure decisions

Action-Based Triggers

Making Changes

Signals:

• Edit tool invoked on file
• Multiple files being modified
• Refactoring patterns detected (rename, move, extract)

Context to retrieve:

• Dependent files
• Test coverage
• Prior decisions on module

Debugging

Signals:

• Error messages in conversation
• Stack traces
• "why", "broken", "failing" in user message

Context to retrieve:

• Knowledge graph: similar errors, past issues
• Error handling patterns in codebase
• Related components

Architectural Discussion

Signals:

• Keywords: "should we", "design", "architecture", "pattern"
• Mentions of trade-offs or alternatives
• New feature planning

Context to retrieve:

• Knowledge graph: ADRs, design decisions
• Similar implementations
• Established patterns

Keyword Triggers

High-Priority Keywords

Module/Feature Keywords

When user mentions specific modules or features:

1. Search knowledge graph for entity 2. Find related files in codebase 3. Locate tests for that module

Context Freshness

Always Fetch Fresh

• Dependent file lists (code changes frequently)
• Test file locations
• Import relationships

Cache-Friendly

• Knowledge graph entities (update less frequently)
• Architecture decisions (stable)
• Project conventions

Integration Points

IDE Events (if available)

• File opened → check familiarity
• File saved → check for architectural changes
• Error diagnostics → search for similar issues

Conversation Patterns

• Question about unfamiliar code → fetch context
• Request to modify shared code → impact analysis
• Debugging session → search past issues

Search Patterns Reference

Common patterns for finding code relationships and context.

Python Projects

Import Analysis

# Find all files importing a module
grep -r "from module_name import" --include="*.py"
grep -r "import module_name" --include="*.py"

# Find relative imports
grep -r "from \. import" --include="*.py"
grep -r "from \.module import" --include="*.py"

# Find wildcard imports (code smell)
grep -r "from .* import \*" --include="*.py"

Function/Class Usage

# Find function calls
grep -rn "function_name(" --include="*.py"

# Find class instantiations
grep -rn "ClassName(" --include="*.py"

# Find class inheritance
grep -rn "class.*\(.*ClassName" --include="*.py"

# Find decorator usage
grep -rn "@decorator_name" --include="*.py"

Test Discovery

# Find test files for a module
find . -name "test_*.py" -o -name "*_test.py" | xargs grep -l "module_name"

# Find pytest markers
grep -rn "@pytest.mark" --include="*.py"

# Find test classes
grep -rn "class Test" --include="*.py"

TypeScript/JavaScript Projects

Import Analysis

# ES6 imports
grep -r "import.*from ['\"].*module" --include="*.ts" --include="*.tsx"

# Require statements
grep -r "require(['\"].*module" --include="*.js" --include="*.ts"

# Dynamic imports
grep -r "import(['\"]" --include="*.ts" --include="*.tsx"

Component Usage (React)

# Find component usage
grep -rn "<ComponentName" --include="*.tsx" --include="*.jsx"

# Find hook usage
grep -rn "use[A-Z][a-zA-Z]*(" --include="*.ts" --include="*.tsx"

# Find context usage
grep -rn "useContext(" --include="*.tsx"

Test Discovery

# Find test files
find . -name "*.test.ts" -o -name "*.spec.ts"

# Find test blocks
grep -rn "describe\|it\|test(" --include="*.test.ts"

Cross-Language Patterns

Configuration References

# Find env var usage
grep -rn "process\.env\|os\.environ\|getenv"

# Find config file reads
grep -rn "\.json\|\.yaml\|\.toml\|\.env" --include="*.py" --include="*.ts"

API Endpoints

# Find route definitions
grep -rn "@app\.route\|@router\.\|app\.get\|app\.post"

# Find API calls
grep -rn "fetch(\|axios\.\|requests\."

Database Queries

# Find SQL queries
grep -rn "SELECT\|INSERT\|UPDATE\|DELETE" --include="*.py" --include="*.ts"

# Find ORM usage
grep -rn "\.query\|\.filter\|\.find\|\.create"

Knowledge Graph Search Patterns

By Entity Type

# Find all projects
search_nodes("project")

# Find all decisions
search_nodes("decision")

# Find all concepts
search_nodes("concept")

# Find all tools
search_nodes("tool")

By Context

# Find by feature name
search_nodes("authentication")
search_nodes("payment")

# Find by technology
search_nodes("postgres")
search_nodes("redis")

# Find by person
search_nodes("joe")
search_nodes("team")

Relationship Queries

# View full graph structure
read_graph()

# Open specific related entities
open_nodes(["entity1", "entity2"])

Output Formatting

Dependency Report

## Dependencies for `module_name`

**Imports (what this module uses):**
- `dependency1` - used for X
- `dependency2` - used for Y

**Imported by (what uses this module):**
- `consumer1.py:15` - function call
- `consumer2.py:42` - class instantiation

**Tests:**
- `test_module.py` - 12 tests
- `integration/test_flow.py` - 3 tests

Impact Analysis Report

## Impact Analysis: Changing `function_name`

**Direct callers (will break if signature changes):**
- `file1.py:23`
- `file2.py:45`

**Indirect impact (uses callers):**
- `file3.py` imports `file1`
- `file4.py` imports `file2`

**Test coverage:**
- Direct: `test_function.py` (5 tests)
- Integration: `test_flow.py` (2 tests)

**Knowledge graph context:**
- Related decision: "Use X pattern for Y"
- Prior issue: "Fixed similar bug in Z"