code-search

name	code-search
description	This skill should be used when the user asks to "find code", "search codebase", "locate functions", "understand architecture", "find implementations", or needs intelligent code discovery using MorphLLM's AI-powered search tools.
version	1.0.0

MorphLLM Code Search

Purpose

Discover and understand code using MorphLLM's intelligent search tools. These tools use AI and semantic search to find code by meaning, not just keywords.

When to Use This Skill

Use this skill when:

• Finding where functionality is implemented
• Understanding codebase architecture
• Locating specific functions or classes
• Discovering code patterns
• Analyzing dependencies
• Exploring unfamiliar codebases

DO NOT use for:

• File system operations (use file-operations skill)
• Editing code (use code-editing skill)
• Reading known file paths (use file-operations skill)

Core Search Tools

Tool 1: fast_context_search (AI-Powered Agent Search)

Best for: Finding code when you don't know where it is

mcp__plugin_morphllm_morphllm-mcp__fast_context_search(
    repoPath="/absolute/path/to/repository",
    query="Where is JWT token validation implemented?"
)

How it works:

• AI agent explores codebase automatically
• Uses grep, file reading, and directory analysis
• Returns precise line ranges with full context
• Fast: Finds code in seconds

Example queries:

• "Where is JWT token validation implemented?"
• "How does the authentication middleware work?"
• "Find the database connection setup"
• "Where are API endpoints defined?"
• "How does user registration work?"

Output format:

• File paths with line numbers
• Code snippets showing matches
• Context around matches
• Explanation of findings

Tool 2: codebase_search (Semantic Vector Search)

Best for: Natural language semantic code search

mcp__plugin_morphllm_morphllm-mcp__codebase_search(
    repoId="your-repo-identifier",
    query="JWT validation logic",
    limit=10,
    branch="main",
    target_directories=["src", "lib"]
)

How it works:

• Two-stage retrieval: vector search + GPU reranking
• Vector search: ~240ms
• GPU reranking: ~630ms
• Returns ranked chunks with relevance scores

Requirements:

• Code must be pushed to Morph git first
• Uses latest commit from specified branch

Example queries:

• "JWT validation"
• "How does auth work?"
• "Find database connection logic"
• "User registration flow"
• "Error handling patterns"

Output format:

• Ranked code chunks
• Relevance scores
• File paths and line numbers
• Context for each match

Tool Selection Guide

Use Case	Tool	Why
Don't know where code is	fast_context_search	AI agent explores
Know general area	codebase_search	Faster, semantic
Complex architecture	fast_context_search	Deeper analysis
Quick lookup	codebase_search	Sub-second results
No git setup	fast_context_search	Works locally
Git repo ready	codebase_search	Uses indexed code

Using fast_context_search

Natural Language Queries

Good queries (specific):

- "Where is user password hashing implemented?"
- "Find the middleware that handles authentication"
- "Where are database migrations run?"
- "How does the API rate limiting work?"

Bad queries (too vague):

- "Find code"
- "Show me the app"
- "Where is everything?"
- "All the functions"

Query Patterns

Find implementation:

"Where is [functionality] implemented?"
"How does [feature] work?"
"Find the [component] logic"

Understand architecture:

"How are [components] connected?"
"What is the flow for [operation]?"
"Where are [entities] defined?"

Locate patterns:

"Find all [pattern] usage"
"Where is [technology] configured?"
"Show [pattern] implementations"

Working with Results

Results include:

• File paths with line numbers
• Code context
• Explanation of findings
• Related code snippets

Next steps after search:

1. Review file paths and line numbers
2. Use file-operations to read full files
3. Use code-search to find related code
4. Use code-editing to make changes

Using codebase_search

Setup Requirements

Must first push code to Morph git:

# Initialize Morph repo
morph init

# Push code for indexing
git add .
git commit -m "Initial commit"
morph push

Once pushed, code is indexed for semantic search.

Search Parameters

Required:

• query: Natural language query
• repoId: Repository identifier

Optional:

• limit: Max results (default: 10)
• branch: Branch to search (default: latest)
• commitHash: Specific commit hash
• target_directories: Filter to specific dirs

Filtering by Directory

Search specific areas:

codebase_search(
    repoId="myapp",
    query="authentication logic",
    target_directories=["src/auth", "src/middleware"]
)

Search entire codebase:

codebase_search(
    repoId="myapp",
    query="authentication logic",
    target_directories=[]  # Empty = all directories
)

Interpreting Results

Relevance scores:

• High relevance: 0.8-1.0
• Medium relevance: 0.5-0.7
• Low relevance: 0.0-0.4

Focus on high-relevance results first.

Code chunks:

• Each result is a chunk of related code
• Includes file path and line numbers
• Shows context around match

Search Workflows

Workflow 1: Understanding New Codebase

1. Find entry points
   - fast_context_search: "Where is the main entry point?"

2. Understand architecture
   - fast_context_search: "How are components organized?"

3. Find key features
   - codebase_search: "authentication", "database", "api"

4. Read important files
   - Use file-operations to read found files

5. Map dependencies
   - fast_context_search: "What dependencies does [component] use?"

Workflow 2: Debugging Issue

1. Find error location
   - codebase_search: "error handling [feature]"

2. Understand context
   - fast_context_search: "How does [feature] work?"

3. Find related code
   - codebase_search: "similar patterns"

4. Read full context
   - file-operations: read_multiple_files

5. Make fix
   - code-editing: edit_file

Workflow 3: Adding Feature

1. Find similar features
   - codebase_search: "existing [similar feature]"

2. Understand patterns
   - fast_context_search: "How is [pattern] implemented?"

3. Locate integration points
   - fast_context_search: "Where should [feature] be added?"

4. Read related files
   - file-operations: read_multiple_files

5. Implement feature
   - code-editing: edit_file

Workflow 4: Refactoring

1. Find all usage
   - codebase_search: "[component] usage"

2. Understand dependencies
   - fast_context_search: "What depends on [component]?"

3. Identify patterns
   - fast_context_search: "How is [component] used?"

4. Plan changes
   - Review search results

5. Apply refactor
   - code-editing: edit_file (multiple files)

Performance Tips

fast_context_search Optimization

Narrow the scope:

# Specific: Faster
"Where is user email validation in the auth module?"

# Generic: Slower
"Find validation code"

Be precise:

# Good: Clear target
"Find JWT token generation function"

# Bad: Too broad
"Find security code"

codebase_search Optimization

Use appropriate limit:

# Quick check: limit=5
# Thorough search: limit=20
# Default: limit=10

Filter directories:

# Faster: Specific directories
target_directories=["src/auth"]

# Slower: Entire codebase
target_directories=[]

Search recent work:

# Faster: Specific branch
branch="feature-branch"

# Slower: Main branch
branch="main"

Common Patterns

Pattern: Find and Read

1. Search: fast_context_search(query="auth middleware")
2. Get file paths from results
3. Read: read_multiple_files(paths=[...])
4. Analyze complete files

Pattern: Semantic Discovery

1. Search: codebase_search(query="password hashing")
2. Review relevance scores
3. Filter high-relevance results (>0.7)
4. Read top results

Pattern: Comprehensive Analysis

1. Fast search: fast_context_search(query="how auth works")
2. Get overview and key files
3. Semantic search: codebase_search(query="authentication")
4. Find related implementations
5. Read and analyze all results

Pattern: Cross-Reference

1. Find main component: fast_context_search
2. Find usage: codebase_search with component name
3. Map dependencies
4. Understand architecture

Integration with Other Skills

With file-operations

1. Use code-search to find files
2. Use file-operations to read full content
3. Use file-operations to get file info

With code-editing

1. Use code-search to locate code
2. Use file-operations to read context
3. Use code-editing to make changes
4. Use code-search to verify changes

Error Handling

fast_context_search Errors

Repository not found:

Error: Path does not exist

Solution:
- Verify repoPath is absolute
- Check path exists
- Ensure path is correct

Query too vague:

Result: No relevant results found

Solution:
- Make query more specific
- Add context to query
- Try different phrasing

codebase_search Errors

Repository not indexed:

Error: Repository not found in Morph

Solution:
1. Initialize Morph: morph init
2. Commit code: git commit
3. Push to Morph: morph push
4. Retry search

No matches:

Result: No code chunks found

Solution:
- Broaden query
- Check branch/commit
- Verify target_directories
- Try fast_context_search instead

Best Practices

✅ DO:

• Use fast_context_search when exploring
• Use codebase_search for quick lookups
• Write specific queries
• Filter by directory when possible
• Review relevance scores
• Read full files after search
• Combine both tools

❌ DON'T:

• Use vague queries
• Search entire codebase unnecessarily
• Ignore relevance scores
• Skip reading full context
• Use only one tool
• Forget to push to Morph for codebase_search

Quick Reference

AI-powered search: fast_context_search

• Natural language queries
• AI agent explores codebase
• Works without git setup
• Returns context + line numbers

Semantic search: codebase_search

• Vector + GPU reranking
• Requires Morph git push
• Fast: 240ms + 630ms
• Returns ranked chunks

Additional Resources

Reference Files

For advanced techniques:

• references/query-patterns.md - Effective query patterns
• references/search-strategies.md - Search workflow strategies

Examples

Working examples in examples/:

• search-workflow.sh - Complete search workflow
• semantic-search.sh - Semantic search examples

Use these tools to intelligently discover code. Combine with file-operations and code-editing for complete workflows.