Release dec 2025 (#15)

* Resolves issue #13 - Switched model to bge-small-en-v1.5 - Added lazy re-embedding - Added model version tracking per vector - Added conversion of vectors to the new model * Add lfs support to the workflow. * Implements importance scoring with decay + voting #6 * Resolves issue #5 by marking observations as superseeded and scheduled for deletion * Implement pattern detection #7 * Improve injections and observations accuracy - Session start: Recent observations for project context (recency-based) - User prompt: Semantically relevant observations (similarity-based with threshold) * Added two stage retrieval with bi and cross encoder #8 * Implement query expansion and reformulation #9 * Knowledge graph and relationships ( resolves #4 ) - File Overlap Detection: Detects relationships when observations modify/read the same files - Concept Overlap Detection: Detects relationships based on shared semantic concepts - Type Progression Detection: Infers relationships from natural observation type progressions (e.g., discovery → bugfix = "fixes") - Temporal Proximity Detection: Detects relationships between observations in the same session within 5 minutes - Narrative Mention Detection: Detects explicit relationship language in narratives (e.g., "fixes", "depends on", "supersedes") * Add visualisation of the relations to the dashboard. * fixup! Add visualisation of the relations to the dashboard. * Update documentation with new settings and screenshots.
2026-10-12 04:55:18 +00:00 · 2025-12-19 17:57:11 +00:00
parent 48957a6c81
commit f79782a008
69 changed files with 43967 additions and 194 deletions
@@ -0,0 +1,438 @@
+// Package pattern provides pattern detection and recognition functionality.
+package pattern
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"github.com/lukaszraczylo/claude-mnemonic/internal/db/sqlite"
+	"github.com/lukaszraczylo/claude-mnemonic/pkg/models"
+	"github.com/rs/zerolog/log"
+)
+
+// DetectorConfig contains configuration for the pattern detector.
+type DetectorConfig struct {
+	// MinMatchScore is the minimum similarity score to consider a match (0.0-1.0).
+	MinMatchScore float64
+	// MinFrequencyForPattern is the minimum occurrences before creating a pattern.
+	MinFrequencyForPattern int
+	// AnalysisInterval is how often to run background pattern analysis.
+	AnalysisInterval time.Duration
+	// MaxPatternsToTrack is the maximum number of active patterns.
+	MaxPatternsToTrack int
+}
+
+// DefaultConfig returns the default detector configuration.
+func DefaultConfig() DetectorConfig {
+	return DetectorConfig{
+		MinMatchScore:          0.3, // 30% similarity threshold
+		MinFrequencyForPattern: 2,   // At least 2 occurrences to form a pattern
+		AnalysisInterval:       5 * time.Minute,
+		MaxPatternsToTrack:     1000,
+	}
+}
+
+// PatternSyncFunc is a callback for syncing patterns to vector store.
+type PatternSyncFunc func(pattern *models.Pattern)
+
+// Detector detects and tracks recurring patterns across observations.
+type Detector struct {
+	config           DetectorConfig
+	patternStore     *sqlite.PatternStore
+	observationStore *sqlite.ObservationStore
+
+	// Vector sync callback
+	syncFunc PatternSyncFunc
+
+	// Candidate tracking (patterns not yet confirmed)
+	candidates   map[string]*candidatePattern
+	candidatesMu sync.RWMutex
+
+	// Background analysis
+	ctx    context.Context
+	cancel context.CancelFunc
+	wg     sync.WaitGroup
+}
+
+// SetSyncFunc sets the callback for syncing patterns to vector store.
+func (d *Detector) SetSyncFunc(fn PatternSyncFunc) {
+	d.syncFunc = fn
+}
+
+// candidatePattern tracks a potential pattern before it reaches frequency threshold.
+type candidatePattern struct {
+	signature      []string
+	observationIDs []int64
+	projects       []string
+	patternType    models.PatternType
+	title          string
+	lastSeenEpoch  int64
+}
+
+// NewDetector creates a new pattern detector.
+func NewDetector(patternStore *sqlite.PatternStore, observationStore *sqlite.ObservationStore, config DetectorConfig) *Detector {
+	ctx, cancel := context.WithCancel(context.Background())
+	return &Detector{
+		config:           config,
+		patternStore:     patternStore,
+		observationStore: observationStore,
+		candidates:       make(map[string]*candidatePattern),
+		ctx:              ctx,
+		cancel:           cancel,
+	}
+}
+
+// Start begins background pattern analysis.
+func (d *Detector) Start() {
+	d.wg.Add(1)
+	go d.backgroundAnalysis()
+	log.Info().Dur("interval", d.config.AnalysisInterval).Msg("Pattern detector started")
+}
+
+// Stop stops background pattern analysis.
+func (d *Detector) Stop() {
+	d.cancel()
+	d.wg.Wait()
+	log.Info().Msg("Pattern detector stopped")
+}
+
+// backgroundAnalysis runs periodic pattern analysis.
+func (d *Detector) backgroundAnalysis() {
+	defer d.wg.Done()
+
+	ticker := time.NewTicker(d.config.AnalysisInterval)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-d.ctx.Done():
+			return
+		case <-ticker.C:
+			if err := d.AnalyzeRecentObservations(d.ctx); err != nil {
+				log.Warn().Err(err).Msg("Background pattern analysis failed")
+			}
+		}
+	}
+}
+
+// AnalyzeObservation processes a new observation for pattern detection.
+// This is called synchronously when a new observation is stored.
+func (d *Detector) AnalyzeObservation(ctx context.Context, obs *models.Observation) (*DetectionResult, error) {
+	result := &DetectionResult{}
+
+	// Extract signature from observation
+	signature := models.ExtractSignature(
+		obs.Concepts,
+		obs.Title.String,
+		obs.Narrative.String,
+	)
+	if len(signature) == 0 {
+		return result, nil // Nothing to detect
+	}
+
+	// Check against existing patterns
+	matches, err := d.patternStore.FindMatchingPatterns(ctx, signature, d.config.MinMatchScore)
+	if err != nil {
+		return nil, err
+	}
+
+	if len(matches) > 0 {
+		// Found existing pattern match
+		bestMatch := matches[0]
+		for _, m := range matches[1:] {
+			if models.CalculateMatchScore(signature, m.Signature) > models.CalculateMatchScore(signature, bestMatch.Signature) {
+				bestMatch = m
+			}
+		}
+
+		// Update the pattern with new occurrence
+		if err := d.patternStore.IncrementPatternFrequency(ctx, bestMatch.ID, obs.Project, obs.ID); err != nil {
+			log.Warn().Err(err).Int64("pattern_id", bestMatch.ID).Msg("Failed to update pattern frequency")
+		}
+
+		result.MatchedPattern = bestMatch
+		result.MatchScore = models.CalculateMatchScore(signature, bestMatch.Signature)
+		result.IsNewPattern = false
+
+		log.Debug().
+			Int64("pattern_id", bestMatch.ID).
+			Str("pattern_name", bestMatch.Name).
+			Float64("score", result.MatchScore).
+			Msg("Observation matched existing pattern")
+
+		return result, nil
+	}
+
+	// No existing pattern match - check candidates
+	candidateKey := generateCandidateKey(signature)
+	d.candidatesMu.Lock()
+	defer d.candidatesMu.Unlock()
+
+	if candidate, exists := d.candidates[candidateKey]; exists {
+		// Update existing candidate
+		candidate.observationIDs = append(candidate.observationIDs, obs.ID)
+
+		// Add project if not already present
+		found := false
+		for _, p := range candidate.projects {
+			if p == obs.Project {
+				found = true
+				break
+			}
+		}
+		if !found {
+			candidate.projects = append(candidate.projects, obs.Project)
+		}
+		candidate.lastSeenEpoch = time.Now().UnixMilli()
+
+		// Check if candidate should be promoted to pattern
+		if len(candidate.observationIDs) >= d.config.MinFrequencyForPattern {
+			pattern, err := d.promoteCandidate(ctx, candidateKey, candidate)
+			if err != nil {
+				log.Warn().Err(err).Msg("Failed to promote candidate to pattern")
+			} else {
+				result.MatchedPattern = pattern
+				result.IsNewPattern = true
+				log.Info().
+					Str("pattern_name", pattern.Name).
+					Int("frequency", pattern.Frequency).
+					Msg("New pattern detected and stored")
+			}
+		}
+	} else {
+		// Create new candidate
+		patternType := models.DetectPatternType(obs.Concepts, obs.Title.String, obs.Narrative.String)
+		d.candidates[candidateKey] = &candidatePattern{
+			signature:      signature,
+			observationIDs: []int64{obs.ID},
+			projects:       []string{obs.Project},
+			patternType:    patternType,
+			title:          obs.Title.String,
+			lastSeenEpoch:  time.Now().UnixMilli(),
+		}
+		log.Debug().
+			Str("candidate_key", candidateKey).
+			Strs("signature", signature).
+			Msg("New pattern candidate created")
+	}
+
+	return result, nil
+}
+
+// promoteCandidate converts a candidate to a stored pattern.
+func (d *Detector) promoteCandidate(ctx context.Context, key string, candidate *candidatePattern) (*models.Pattern, error) {
+	// Generate pattern name from signature
+	name := generatePatternName(candidate.patternType, candidate.signature, candidate.title)
+
+	// Create base pattern using NewPattern with first observation
+	firstProject := ""
+	if len(candidate.projects) > 0 {
+		firstProject = candidate.projects[0]
+	}
+	var firstObsID int64
+	if len(candidate.observationIDs) > 0 {
+		firstObsID = candidate.observationIDs[0]
+	}
+	pattern := models.NewPattern(
+		name,
+		candidate.patternType,
+		"Automatically detected pattern from recurring observations",
+		candidate.signature,
+		firstProject,
+		firstObsID,
+	)
+
+	// Add remaining projects and observations
+	for i := 1; i < len(candidate.projects); i++ {
+		pattern.Projects = append(pattern.Projects, candidate.projects[i])
+	}
+	for i := 1; i < len(candidate.observationIDs); i++ {
+		pattern.ObservationIDs = append(pattern.ObservationIDs, candidate.observationIDs[i])
+	}
+	pattern.Frequency = len(candidate.observationIDs)
+
+	id, err := d.patternStore.StorePattern(ctx, pattern)
+	if err != nil {
+		return nil, err
+	}
+	pattern.ID = id
+
+	// Sync to vector store if callback is set
+	if d.syncFunc != nil {
+		d.syncFunc(pattern)
+	}
+
+	// Remove from candidates
+	delete(d.candidates, key)
+
+	return pattern, nil
+}
+
+// AnalyzeRecentObservations analyzes recent observations for pattern detection.
+// This is used for background batch analysis.
+func (d *Detector) AnalyzeRecentObservations(ctx context.Context) error {
+	// Get observations from the last 24 hours that haven't been analyzed
+	observations, err := d.observationStore.GetRecentObservations(ctx, "", 100)
+	if err != nil {
+		return err
+	}
+
+	analyzed := 0
+	patternsFound := 0
+	for _, obs := range observations {
+		result, err := d.AnalyzeObservation(ctx, obs)
+		if err != nil {
+			log.Warn().Err(err).Int64("obs_id", obs.ID).Msg("Failed to analyze observation")
+			continue
+		}
+		analyzed++
+		if result.MatchedPattern != nil {
+			patternsFound++
+		}
+	}
+
+	if analyzed > 0 {
+		log.Info().
+			Int("analyzed", analyzed).
+			Int("patterns_found", patternsFound).
+			Msg("Background pattern analysis completed")
+	}
+
+	// Clean up old candidates (older than 7 days)
+	d.cleanupOldCandidates()
+
+	return nil
+}
+
+// cleanupOldCandidates removes candidates that haven't been seen recently.
+func (d *Detector) cleanupOldCandidates() {
+	d.candidatesMu.Lock()
+	defer d.candidatesMu.Unlock()
+
+	threshold := time.Now().Add(-7 * 24 * time.Hour).UnixMilli()
+	for key, candidate := range d.candidates {
+		if candidate.lastSeenEpoch < threshold {
+			delete(d.candidates, key)
+		}
+	}
+}
+
+// GetPatternInsight returns a formatted insight string for a pattern.
+func (d *Detector) GetPatternInsight(ctx context.Context, patternID int64) (string, error) {
+	pattern, err := d.patternStore.GetPatternByID(ctx, patternID)
+	if err != nil {
+		return "", err
+	}
+
+	return formatPatternInsight(pattern), nil
+}
+
+// DetectionResult contains the result of pattern detection.
+type DetectionResult struct {
+	MatchedPattern *models.Pattern
+	MatchScore     float64
+	IsNewPattern   bool
+}
+
+// generateCandidateKey creates a unique key for a signature.
+func generateCandidateKey(signature []string) string {
+	if len(signature) == 0 {
+		return ""
+	}
+	key := ""
+	for _, s := range signature {
+		key += s + "|"
+	}
+	return key
+}
+
+// generatePatternName creates a human-readable name for a pattern.
+func generatePatternName(patternType models.PatternType, signature []string, title string) string {
+	// Use title if available and meaningful
+	if title != "" && len(title) < 60 {
+		return title
+	}
+
+	// Otherwise generate from type and signature
+	prefix := ""
+	switch patternType {
+	case models.PatternTypeBug:
+		prefix = "Bug Pattern: "
+	case models.PatternTypeRefactor:
+		prefix = "Refactor Pattern: "
+	case models.PatternTypeArchitecture:
+		prefix = "Architecture Pattern: "
+	case models.PatternTypeAntiPattern:
+		prefix = "Anti-Pattern: "
+	case models.PatternTypeBestPractice:
+		prefix = "Best Practice: "
+	}
+
+	// Use first few signature elements
+	if len(signature) > 0 {
+		name := prefix
+		for i, s := range signature {
+			if i >= 3 {
+				break
+			}
+			if i > 0 {
+				name += ", "
+			}
+			name += s
+		}
+		return name
+	}
+
+	return prefix + "Unnamed"
+}
+
+// formatPatternInsight creates a human-readable insight from a pattern.
+func formatPatternInsight(pattern *models.Pattern) string {
+	insight := "I've encountered this pattern " +
+		itoa(pattern.Frequency) + " times"
+
+	if len(pattern.Projects) > 1 {
+		insight += " across " + itoa(len(pattern.Projects)) + " projects"
+	}
+
+	insight += ". "
+
+	if pattern.Recommendation.Valid && pattern.Recommendation.String != "" {
+		insight += "What works: " + pattern.Recommendation.String
+	} else {
+		switch pattern.Type {
+		case models.PatternTypeBug:
+			insight += "This appears to be a recurring bug pattern."
+		case models.PatternTypeAntiPattern:
+			insight += "This is an identified anti-pattern to avoid."
+		case models.PatternTypeBestPractice:
+			insight += "This is a validated best practice."
+		default:
+			insight += "This is a recognized pattern in the codebase."
+		}
+	}
+
+	return insight
+}
+
+// itoa converts int to string without importing strconv.
+func itoa(n int) string {
+	if n == 0 {
+		return "0"
+	}
+	negative := false
+	if n < 0 {
+		negative = true
+		n = -n
+	}
+	var digits []byte
+	for n > 0 {
+		digits = append([]byte{byte('0' + n%10)}, digits...)
+		n /= 10
+	}
+	if negative {
+		digits = append([]byte{'-'}, digits...)
+	}
+	return string(digits)
+}
@@ -0,0 +1,450 @@
+package pattern
+
+import (
+	"context"
+	"database/sql"
+	"os"
+	"testing"
+	"time"
+
+	"github.com/lukaszraczylo/claude-mnemonic/internal/db/sqlite"
+	"github.com/lukaszraczylo/claude-mnemonic/pkg/models"
+)
+
+func TestNewDetector(t *testing.T) {
+	store := setupTestStore(t)
+	defer store.Close()
+
+	patternStore := sqlite.NewPatternStore(store)
+	observationStore := sqlite.NewObservationStore(store)
+	config := DefaultConfig()
+
+	detector := NewDetector(patternStore, observationStore, config)
+	if detector == nil {
+		t.Fatal("Expected non-nil detector")
+	}
+
+	if detector.config.MinMatchScore != config.MinMatchScore {
+		t.Errorf("Expected MinMatchScore %f, got %f",
+			config.MinMatchScore, detector.config.MinMatchScore)
+	}
+}
+
+func TestDetector_StartStop(t *testing.T) {
+	store := setupTestStore(t)
+	defer store.Close()
+
+	patternStore := sqlite.NewPatternStore(store)
+	observationStore := sqlite.NewObservationStore(store)
+	config := DefaultConfig()
+	config.AnalysisInterval = 100 * time.Millisecond // Short interval for testing
+
+	detector := NewDetector(patternStore, observationStore, config)
+
+	// Start
+	detector.Start()
+
+	// Wait a bit to ensure background goroutine is running
+	time.Sleep(50 * time.Millisecond)
+
+	// Stop
+	detector.Stop()
+
+	// Verify we can stop without hanging
+	// (if this test hangs, the Stop logic is broken)
+}
+
+func TestDetector_AnalyzeObservation_NewCandidate(t *testing.T) {
+	store := setupTestStore(t)
+	defer store.Close()
+
+	patternStore := sqlite.NewPatternStore(store)
+	observationStore := sqlite.NewObservationStore(store)
+	config := DefaultConfig()
+	config.MinFrequencyForPattern = 2
+
+	detector := NewDetector(patternStore, observationStore, config)
+	ctx := context.Background()
+
+	// Create an observation
+	obs := createTestObservation(1, "nil-handling", []string{"nil", "error-handling"})
+
+	// Analyze first observation
+	result, err := detector.AnalyzeObservation(ctx, obs)
+	if err != nil {
+		t.Fatalf("AnalyzeObservation() error = %v", err)
+	}
+
+	// First observation should create a candidate, not a pattern
+	if result.MatchedPattern != nil {
+		t.Errorf("Expected no pattern match for first observation")
+	}
+	if result.IsNewPattern {
+		t.Errorf("Expected IsNewPattern to be false for first observation")
+	}
+}
+
+func TestDetector_AnalyzeObservation_PromoteToPattern(t *testing.T) {
+	store := setupTestStore(t)
+	defer store.Close()
+
+	patternStore := sqlite.NewPatternStore(store)
+	observationStore := sqlite.NewObservationStore(store)
+	config := DefaultConfig()
+	config.MinFrequencyForPattern = 2
+
+	detector := NewDetector(patternStore, observationStore, config)
+	ctx := context.Background()
+
+	// Create two similar observations
+	obs1 := createTestObservation(1, "Nil pointer handling", []string{"nil", "error-handling"})
+	obs2 := createTestObservation(2, "Nil pointer handling", []string{"nil", "error-handling"})
+
+	// Analyze first observation
+	_, err := detector.AnalyzeObservation(ctx, obs1)
+	if err != nil {
+		t.Fatalf("AnalyzeObservation(obs1) error = %v", err)
+	}
+
+	// Analyze second observation - should promote to pattern
+	result, err := detector.AnalyzeObservation(ctx, obs2)
+	if err != nil {
+		t.Fatalf("AnalyzeObservation(obs2) error = %v", err)
+	}
+
+	if result.MatchedPattern == nil {
+		t.Fatal("Expected pattern to be created after second occurrence")
+	}
+	if !result.IsNewPattern {
+		t.Errorf("Expected IsNewPattern to be true for newly promoted pattern")
+	}
+	if result.MatchedPattern.Frequency != 2 {
+		t.Errorf("Expected frequency 2, got %d", result.MatchedPattern.Frequency)
+	}
+}
+
+func TestDetector_AnalyzeObservation_MatchExisting(t *testing.T) {
+	store := setupTestStore(t)
+	defer store.Close()
+
+	patternStore := sqlite.NewPatternStore(store)
+	observationStore := sqlite.NewObservationStore(store)
+	config := DefaultConfig()
+
+	detector := NewDetector(patternStore, observationStore, config)
+	ctx := context.Background()
+
+	// Create an existing pattern
+	pattern := &models.Pattern{
+		Name:           "Existing Pattern",
+		Type:           models.PatternTypeBug,
+		Signature:      []string{"nil", "error-handling", "pointer"},
+		Frequency:      5,
+		Projects:       []string{"proj1"},
+		ObservationIDs: []int64{1, 2, 3, 4, 5},
+		Status:         models.PatternStatusActive,
+		Confidence:     0.7,
+		LastSeenAt:     time.Now().Format(time.RFC3339),
+		LastSeenEpoch:  time.Now().UnixMilli(),
+		CreatedAt:      time.Now().Format(time.RFC3339),
+		CreatedAtEpoch: time.Now().UnixMilli(),
+	}
+	patternStore.StorePattern(ctx, pattern)
+
+	// Create observation with similar signature
+	obs := createTestObservation(10, "Nil check", []string{"nil", "error-handling"})
+
+	// Analyze - should match existing pattern
+	result, err := detector.AnalyzeObservation(ctx, obs)
+	if err != nil {
+		t.Fatalf("AnalyzeObservation() error = %v", err)
+	}
+
+	if result.MatchedPattern == nil {
+		t.Fatal("Expected to match existing pattern")
+	}
+	if result.IsNewPattern {
+		t.Errorf("Expected IsNewPattern to be false for existing pattern")
+	}
+	if result.MatchScore < 0.3 {
+		t.Errorf("Expected match score >= 0.3, got %f", result.MatchScore)
+	}
+}
+
+func TestDetector_AnalyzeObservation_NoMatch(t *testing.T) {
+	store := setupTestStore(t)
+	defer store.Close()
+
+	patternStore := sqlite.NewPatternStore(store)
+	observationStore := sqlite.NewObservationStore(store)
+	config := DefaultConfig()
+	config.MinMatchScore = 0.5 // Higher threshold
+
+	detector := NewDetector(patternStore, observationStore, config)
+	ctx := context.Background()
+
+	// Create an existing pattern with specific signature
+	pattern := &models.Pattern{
+		Name:           "Specific Pattern",
+		Type:           models.PatternTypeBug,
+		Signature:      []string{"database", "connection", "pool"},
+		Frequency:      3,
+		Projects:       []string{"proj1"},
+		ObservationIDs: []int64{1, 2, 3},
+		Status:         models.PatternStatusActive,
+		Confidence:     0.6,
+		LastSeenAt:     time.Now().Format(time.RFC3339),
+		LastSeenEpoch:  time.Now().UnixMilli(),
+		CreatedAt:      time.Now().Format(time.RFC3339),
+		CreatedAtEpoch: time.Now().UnixMilli(),
+	}
+	patternStore.StorePattern(ctx, pattern)
+
+	// Create observation with completely different signature
+	obs := createTestObservation(10, "UI Component", []string{"frontend", "react", "component"})
+
+	// Analyze - should not match
+	result, err := detector.AnalyzeObservation(ctx, obs)
+	if err != nil {
+		t.Fatalf("AnalyzeObservation() error = %v", err)
+	}
+
+	if result.MatchedPattern != nil {
+		t.Errorf("Expected no match for unrelated observation")
+	}
+}
+
+func TestDetector_CandidateCleanup(t *testing.T) {
+	store := setupTestStore(t)
+	defer store.Close()
+
+	patternStore := sqlite.NewPatternStore(store)
+	observationStore := sqlite.NewObservationStore(store)
+	config := DefaultConfig()
+	config.MinFrequencyForPattern = 3 // Higher threshold
+
+	detector := NewDetector(patternStore, observationStore, config)
+
+	// Add an old candidate manually
+	oldKey := "old|candidate|"
+	detector.candidates[oldKey] = &candidatePattern{
+		signature:      []string{"old", "candidate"},
+		observationIDs: []int64{1},
+		projects:       []string{"proj1"},
+		patternType:    models.PatternTypeBug,
+		title:          "Old Candidate",
+		lastSeenEpoch:  time.Now().Add(-8 * 24 * time.Hour).UnixMilli(), // 8 days ago
+	}
+
+	// Add a recent candidate
+	recentKey := "recent|candidate|"
+	detector.candidates[recentKey] = &candidatePattern{
+		signature:      []string{"recent", "candidate"},
+		observationIDs: []int64{2},
+		projects:       []string{"proj1"},
+		patternType:    models.PatternTypeBug,
+		title:          "Recent Candidate",
+		lastSeenEpoch:  time.Now().UnixMilli(),
+	}
+
+	// Run cleanup
+	detector.cleanupOldCandidates()
+
+	// Old candidate should be removed
+	if _, exists := detector.candidates[oldKey]; exists {
+		t.Errorf("Expected old candidate to be cleaned up")
+	}
+
+	// Recent candidate should remain
+	if _, exists := detector.candidates[recentKey]; !exists {
+		t.Errorf("Expected recent candidate to remain")
+	}
+}
+
+func TestDetector_GetPatternInsight(t *testing.T) {
+	store := setupTestStore(t)
+	defer store.Close()
+
+	patternStore := sqlite.NewPatternStore(store)
+	observationStore := sqlite.NewObservationStore(store)
+	config := DefaultConfig()
+
+	detector := NewDetector(patternStore, observationStore, config)
+	ctx := context.Background()
+
+	// Create pattern with recommendation
+	pattern := &models.Pattern{
+		Name:           "Insight Test Pattern",
+		Type:           models.PatternTypeBestPractice,
+		Signature:      []string{"test"},
+		Recommendation: sql.NullString{String: "Always write tests first", Valid: true},
+		Frequency:      12,
+		Projects:       []string{"proj1", "proj2", "proj3"},
+		ObservationIDs: []int64{1},
+		Status:         models.PatternStatusActive,
+		Confidence:     0.8,
+		LastSeenAt:     time.Now().Format(time.RFC3339),
+		LastSeenEpoch:  time.Now().UnixMilli(),
+		CreatedAt:      time.Now().Format(time.RFC3339),
+		CreatedAtEpoch: time.Now().UnixMilli(),
+	}
+	id, _ := patternStore.StorePattern(ctx, pattern)
+
+	// Get insight
+	insight, err := detector.GetPatternInsight(ctx, id)
+	if err != nil {
+		t.Fatalf("GetPatternInsight() error = %v", err)
+	}
+
+	// Verify insight contains expected elements
+	if insight == "" {
+		t.Error("Expected non-empty insight")
+	}
+	if !containsString(insight, "12 times") {
+		t.Errorf("Expected insight to contain frequency, got: %s", insight)
+	}
+	if !containsString(insight, "3 projects") {
+		t.Errorf("Expected insight to contain project count, got: %s", insight)
+	}
+	if !containsString(insight, "Always write tests first") {
+		t.Errorf("Expected insight to contain recommendation, got: %s", insight)
+	}
+}
+
+func TestDefaultConfig(t *testing.T) {
+	config := DefaultConfig()
+
+	if config.MinMatchScore <= 0 || config.MinMatchScore > 1 {
+		t.Errorf("Invalid MinMatchScore: %f", config.MinMatchScore)
+	}
+	if config.MinFrequencyForPattern < 1 {
+		t.Errorf("Invalid MinFrequencyForPattern: %d", config.MinFrequencyForPattern)
+	}
+	if config.AnalysisInterval <= 0 {
+		t.Errorf("Invalid AnalysisInterval: %v", config.AnalysisInterval)
+	}
+	if config.MaxPatternsToTrack <= 0 {
+		t.Errorf("Invalid MaxPatternsToTrack: %d", config.MaxPatternsToTrack)
+	}
+}
+
+func TestGeneratePatternName(t *testing.T) {
+	tests := []struct {
+		patternType models.PatternType
+		signature   []string
+		title       string
+		wantPrefix  string
+	}{
+		{models.PatternTypeBug, []string{"nil", "error"}, "", "Bug Pattern:"},
+		{models.PatternTypeRefactor, []string{"extract"}, "", "Refactor Pattern:"},
+		{models.PatternTypeArchitecture, []string{"service"}, "", "Architecture Pattern:"},
+		{models.PatternTypeAntiPattern, []string{"god-class"}, "", "Anti-Pattern:"},
+		{models.PatternTypeBestPractice, []string{"testing"}, "", "Best Practice:"},
+		{models.PatternTypeBug, []string{}, "Short Title", "Short Title"}, // Use title directly
+	}
+
+	for _, tt := range tests {
+		name := generatePatternName(tt.patternType, tt.signature, tt.title)
+		if !hasPrefix(name, tt.wantPrefix) {
+			t.Errorf("generatePatternName(%v, %v, %q) = %q, want prefix %q",
+				tt.patternType, tt.signature, tt.title, name, tt.wantPrefix)
+		}
+	}
+}
+
+func TestFormatPatternInsight(t *testing.T) {
+	// Pattern without recommendation
+	pattern1 := &models.Pattern{
+		Type:      models.PatternTypeBug,
+		Frequency: 5,
+		Projects:  []string{"proj1"},
+	}
+	insight1 := formatPatternInsight(pattern1)
+	if !containsString(insight1, "5 times") {
+		t.Errorf("Expected insight to contain frequency")
+	}
+	if !containsString(insight1, "recurring bug pattern") {
+		t.Errorf("Expected bug pattern description")
+	}
+
+	// Pattern with recommendation
+	pattern2 := &models.Pattern{
+		Type:           models.PatternTypeBestPractice,
+		Frequency:      10,
+		Projects:       []string{"proj1", "proj2"},
+		Recommendation: sql.NullString{String: "Do this", Valid: true},
+	}
+	insight2 := formatPatternInsight(pattern2)
+	if !containsString(insight2, "10 times") {
+		t.Errorf("Expected insight to contain frequency")
+	}
+	if !containsString(insight2, "2 projects") {
+		t.Errorf("Expected insight to contain project count")
+	}
+	if !containsString(insight2, "Do this") {
+		t.Errorf("Expected insight to contain recommendation")
+	}
+}
+
+// Helper functions
+
+func setupTestStore(t *testing.T) *sqlite.Store {
+	t.Helper()
+
+	// Create temp database file
+	tmpFile, err := os.CreateTemp("", "pattern_test_*.db")
+	if err != nil {
+		t.Fatalf("Failed to create temp file: %v", err)
+	}
+	tmpFile.Close()
+
+	t.Cleanup(func() {
+		os.Remove(tmpFile.Name())
+	})
+
+	store, err := sqlite.NewStore(sqlite.StoreConfig{
+		Path:     tmpFile.Name(),
+		MaxConns: 1,
+		WALMode:  true,
+	})
+	if err != nil {
+		// Check if this is an FTS5 related error
+		if containsString(err.Error(), "fts5") || containsString(err.Error(), "no such module") {
+			t.Skip("FTS5 not available in this SQLite build")
+		}
+		t.Fatalf("Failed to create store: %v", err)
+	}
+
+	return store
+}
+
+func createTestObservation(id int64, title string, concepts []string) *models.Observation {
+	return &models.Observation{
+		ID:             id,
+		SDKSessionID:   "test-session",
+		Project:        "test-project",
+		Scope:          models.ScopeProject,
+		Type:           models.ObsTypeBugfix,
+		Title:          sql.NullString{String: title, Valid: true},
+		Narrative:      sql.NullString{String: "Test narrative", Valid: true},
+		Concepts:       concepts,
+		CreatedAt:      time.Now().Format(time.RFC3339),
+		CreatedAtEpoch: time.Now().UnixMilli(),
+	}
+}
+
+func containsString(s, substr string) bool {
+	for i := 0; i <= len(s)-len(substr); i++ {
+		if s[i:i+len(substr)] == substr {
+			return true
+		}
+	}
+	return false
+}
+
+func hasPrefix(s, prefix string) bool {
+	if len(s) < len(prefix) {
+		return false
+	}
+	return s[:len(prefix)] == prefix
+}