undefined

undefined

undefined

undefined

Session: Debugging circular import issue in Neo4j module
Duration: 45 minutes
Resolution: Moved shared types to separate file

Extracted Learning:
- Category: errors
- Keywords: [import, circular, neo4j, type]
- Summary: Circular imports in Neo4j types cause ImportError
- Insight: When Neo4jNode imports from connection.py which imports
  Node types, move types to separate types.py module
- Example: types.py with dataclasses, connection.py imports from types.py

Session Start Prompt: "Fix the import error in the memory module"

Matched Learnings:
1. errors/err-001: "Circular imports cause 'module not found' errors" (85% match)
2. debugging/dbg-003: "Use `python -c` to isolate import issues" (60% match)

Injected Context:

undefined

User: Show me what I've learned about testing

Claude (using this skill):
1. Reads .claude/data/learnings/workflows.yaml
2. Filters learnings with keywords containing "test"
3. Displays formatted list with summaries and examples

def calculate_relevance(task_keywords: set, learning_keywords: set) -> float:
    """Calculate relevance score between 0 and 1."""
    if not task_keywords or not learning_keywords:
        return 0.0

    # Count overlapping keywords
    overlap = task_keywords & learning_keywords

    # Score: overlap / min(task, learning) to not penalize short queries
    return len(overlap) / min(len(task_keywords), len(learning_keywords))

.claude/
  data/
    learnings/
      errors.yaml        # Error patterns and solutions
      workflows.yaml     # Workflow insights
      tools.yaml         # Tool usage patterns
      architecture.yaml  # Design decisions
      debugging.yaml     # Debugging strategies
      _stats.yaml        # Usage statistics (auto-generated)

import yaml
from pathlib import Path

def safe_load_learnings(filepath: Path) -> dict:
    """Load learnings with graceful error handling."""
    try:
        content = filepath.read_text()
        data = yaml.safe_load(content)
        if not isinstance(data, dict) or "learnings" not in data:
            print(f"Warning: Invalid structure in {filepath}, using empty learnings")
            return {"category": filepath.stem, "learnings": []}
        return data
    except yaml.YAMLError as e:
        print(f"Warning: YAML error in {filepath}: {e}")
        # Create backup before recovery
        backup = filepath.with_suffix(".yaml.bak")
        filepath.rename(backup)
        print(f"Backed up corrupted file to {backup}")
        return {"category": filepath.stem, "learnings": []}
    except Exception as e:
        print(f"Warning: Could not read {filepath}: {e}")
        return {"category": filepath.stem, "learnings": []}

def ensure_learnings_directory():
    """Create learnings directory and empty files if missing."""
    learnings_dir = Path(".claude/data/learnings")
    learnings_dir.mkdir(parents=True, exist_ok=True)

    categories = ["errors", "workflows", "tools", "architecture", "debugging"]
    for cat in categories:
        filepath = learnings_dir / f"{cat}.yaml"
        if not filepath.exists():
            filepath.write_text(f"category: {cat}\nlearnings: []\n")

undefined

# Only extract if session was substantive (not just a quick question)
if len(transcript) < 1000:
    return

# Use Claude to extract insights (simplified example)
extraction_prompt = f"""
Analyze this session transcript and extract any reusable learnings.

Categories:
- errors: Error patterns and solutions
- workflows: Process improvements
- tools: Tool usage insights
- architecture: Design decisions
- debugging: Debug strategies

For each learning, provide:
- category (one of the above)
- keywords (3-5 searchable terms)
- summary (one sentence)
- insight (detailed explanation)
- example (code if applicable)
- confidence (0.5-1.0)

Transcript:
{transcript[:5000]}  # Truncate for token limits
"""

# ... call Claude to extract ...
# ... parse response and add to appropriate YAML files ...

# Extract learnings (non-blocking)
try:
    import asyncio
    asyncio.create_task(
        extract_session_learnings(
            session_data.get("transcript", ""),
            session_data.get("session_id", "")
        )
    )
except Exception as e:
    print(f"Learning extraction failed (non-blocking): {e}")

undefined

undefined

learnings_dir = Path(".claude/data/learnings")
if not learnings_dir.exists():
    return ""

# Extract keywords from prompt
prompt_lower = initial_prompt.lower()
task_keywords = set()
for word in prompt_lower.split():
    if len(word) > 3:  # Skip short words
        task_keywords.add(word.strip(".,!?"))

# Find matching learnings
matches = []
for yaml_file in learnings_dir.glob("*.yaml"):
    if yaml_file.name.startswith("_"):
        continue  # Skip _stats.yaml

    try:
        data = yaml.safe_load(yaml_file.read_text())
        for learning in data.get("learnings", []):
            learning_keywords = set(k.lower() for k in learning.get("keywords", []))
            overlap = task_keywords & learning_keywords
            if overlap:
                score = len(overlap) * learning.get("confidence", 0.5)
                matches.append((score, learning))
    except Exception:
        continue

# Return top 3 matches
matches.sort(key=lambda x: x[0], reverse=True)
if not matches:
    return ""

context = "## Past Learnings Relevant to This Task\n\n"
for score, learning in matches[:3]:
    context += f"### {learning.get('summary', 'Insight')}\n"
    context += f"{learning.get('insight', '')}\n\n"

return context

# Inject relevant learnings
try:
    learning_context = inject_relevant_learnings(initial_prompt)
    if learning_context:
        session_data["injected_context"] = learning_context
except Exception as e:
    print(f"Learning injection failed (non-blocking): {e}")

return session_data

undefined