OpenWriterControle/.opencode/command/analyze-patterns.md

id	name	description	type	category	version
analyze-patterns	analyze-patterns	Analyze codebase for patterns and similar implementations	command	analysis	1.0.0

Command: analyze-patterns

Description

Analyze codebase for recurring patterns, similar implementations, and refactoring opportunities. Replaces codebase-pattern-analyst subagent functionality with a command-based interface.

Usage

/analyze-patterns [--pattern=<pattern>] [--language=<lang>] [--depth=<level>] [--output=<format>]

Parameters

Parameter	Type	Required	Description
--pattern	string	No	Pattern name or regex to search for (e.g., "singleton", "factory", "error-handling")
--language	string	No	Filter by language: js, ts, py, go, rust, java, etc.
--depth	string	No	Search depth: shallow (current dir) | medium (src/) | deep (entire repo)
--output	string	No	Output format: text (default) | json | markdown

Behavior

Pattern Search

• Searches codebase for pattern matches using regex + semantic analysis
• Identifies similar implementations across files
• Groups results by pattern type + similarity score
• Suggests refactoring opportunities

Analysis Output

• Pattern occurrences with file locations + line numbers
• Similarity metrics (how similar are implementations?)
• Refactoring suggestions (consolidate, extract, standardize)
• Code quality insights (duplication, inconsistency)

Result Format

Pattern Analysis Report
=======================

Pattern: [pattern_name]
Occurrences: [count]
Files: [file_list]

Implementations:
  1. [file:line] - [description] (similarity: X%)
  2. [file:line] - [description] (similarity: Y%)
  ...

Refactoring Suggestions:
  - [suggestion 1]
  - [suggestion 2]
  ...

Quality Insights:
  - [insight 1]
  - [insight 2]
  ...

Examples

Find all error handling patterns

/analyze-patterns --pattern="error-handling" --language=ts

Analyze factory patterns across codebase

/analyze-patterns --pattern="factory" --depth=deep --output=json

Find similar API endpoint implementations

/analyze-patterns --pattern="api-endpoint" --language=js --output=markdown

Search for singleton patterns

/analyze-patterns --pattern="singleton" --depth=medium

Implementation

Delegation

• Delegates to: opencoder (primary) or openimplementer (fallback)
• Uses context search capabilities for pattern matching
• Returns structured pattern analysis results

Context Requirements

• Codebase structure + file organization
• Language-specific patterns + conventions
• Project-specific naming conventions
• Existing refactoring guidelines

Processing Steps

1. Parse command parameters
2. Validate pattern syntax (regex or predefined)
3. Search codebase using glob + grep tools
4. Analyze semantic similarity of matches
5. Group results by pattern + similarity
6. Generate refactoring suggestions
7. Format output per requested format
8. Return analysis report

Predefined Patterns

JavaScript/TypeScript

• singleton - Singleton pattern implementations
• factory - Factory pattern implementations
• observer - Observer/event pattern implementations
• error-handling - Error handling patterns
• async-patterns - Promise/async-await patterns
• api-endpoint - API endpoint definitions
• middleware - Middleware implementations

Python

• decorator - Decorator pattern implementations
• context-manager - Context manager patterns
• error-handling - Exception handling patterns
• async-patterns - Async/await patterns
• class-patterns - Class design patterns

Go

• interface-patterns - Interface implementations
• error-handling - Error handling patterns
• goroutine-patterns - Goroutine patterns
• middleware - Middleware implementations

Custom Patterns

Users can provide custom regex patterns for domain-specific analysis.

Output Formats

Text (Default)

Human-readable report with clear sections and formatting

JSON

Structured data for programmatic processing:

{
  "pattern": "error-handling",
  "occurrences": 12,
  "files": ["file1.ts", "file2.ts"],
  "implementations": [
    {
      "file": "file1.ts",
      "line": 42,
      "description": "try-catch block",
      "similarity": 0.95
    }
  ],
  "suggestions": ["Consolidate error handling", "Extract to utility"]
}

Markdown

Formatted for documentation + sharing:

# Pattern Analysis: error-handling

**Occurrences**: 12  
**Files**: 3  
**Similarity Range**: 85-98%

## Implementations
...

Integration

Registry Entry

{
  "id": "analyze-patterns",
  "name": "analyze-patterns",
  "type": "command",
  "category": "analysis",
  "description": "Analyze codebase for patterns and similar implementations",
  "delegates_to": ["opencoder", "openimplementer"],
  "parameters": ["pattern", "language", "depth", "output"]
}

Profile Assignment

• Developer Profile: ✅ Included
• Full Profile: ✅ Included
• Advanced Profile: ✅ Included
• Business Profile: ❌ Not included

Notes

• Replaces codebase-pattern-analyst subagent functionality
• Command-based interface is more flexible + discoverable
• Supports both predefined + custom patterns
• Results can be exported for documentation
• Integrates with refactoring workflows

---

Validation Checklist

✅ Command structure defined
✅ Parameters documented
✅ Behavior specified
✅ Examples provided
✅ Implementation details included
✅ Output formats defined
✅ Integration ready
✅ Ready for registry integration

Status: Ready for deployment