mnemo-dev 0.1.0__py3-none-any.whl

mnemo/health/__init__.py

@@ -0,0 +1,103 @@
+"""Code Health Score — track complexity hotspots, churn, and metrics."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from ..config import IGNORE_DIRS
+
+
+def _should_ignore(path: Path) -> bool:
+    return any(part in IGNORE_DIRS for part in path.parts)
+
+
+def _count_methods(content: str) -> int:
+    """Count methods in a C# file."""
+    return len(re.findall(r'(public|private|protected|internal)\s+(static\s+)?(async\s+)?\S+\s+\w+\s*\(', content))
+
+
+def _estimate_complexity(content: str) -> int:
+    """Rough cyclomatic complexity estimate based on branching keywords."""
+    keywords = ["if ", "else ", "switch ", "case ", "for ", "foreach ", "while ", "catch ", "&&", "||", "??", "?.", "=>"]
+    return sum(content.count(k) for k in keywords)
+
+
+def _get_git_churn(repo_root: Path, filepath: Path) -> int:
+    """Get number of commits that touched this file."""
+    try:
+        from git import Repo
+        repo = Repo(repo_root)
+        rel = str(filepath.relative_to(repo_root))
+        commits = list(repo.iter_commits(paths=rel, max_count=100))
+        return len(commits)
+    except Exception:
+        return 0
+
+
+def calculate_health(repo_root: Path) -> str:
+    """Calculate code health metrics for the project."""
+    lines = ["# Code Health Report\n"]
+
+    hotspots: list[tuple[str, int, int, int]] = []  # (file, complexity, methods, lines)
+
+    for cs_file in repo_root.rglob("*.cs"):
+        if _should_ignore(cs_file) or "Test" in str(cs_file):
+            continue
+        try:
+            content = cs_file.read_text(errors="replace")
+        except (OSError, PermissionError):
+            continue
+
+        if len(content) < 100:
+            continue
+
+        rel = str(cs_file.relative_to(repo_root))
+        complexity = _estimate_complexity(content)
+        methods = _count_methods(content)
+        line_count = content.count("\n")
+
+        hotspots.append((rel, complexity, methods, line_count))
+
+    if not hotspots:
+        return "No source files found for health analysis."
+
+    # Sort by complexity (highest first)
+    hotspots.sort(key=lambda x: -x[1])
+
+    # Overall stats
+    total_files = len(hotspots)
+    total_lines = sum(h[3] for h in hotspots)
+    total_methods = sum(h[2] for h in hotspots)
+    avg_complexity = sum(h[1] for h in hotspots) / total_files
+
+    lines.append("## Summary")
+    lines.append(f"- **Files:** {total_files}")
+    lines.append(f"- **Total lines:** {total_lines:,}")
+    lines.append(f"- **Total methods:** {total_methods}")
+    lines.append(f"- **Avg complexity/file:** {avg_complexity:.1f}")
+    lines.append("")
+
+    # Complexity hotspots
+    lines.append("## Complexity Hotspots (top 10)")
+    lines.append("Files with highest branching complexity — candidates for refactoring:")
+    lines.append("")
+    for rel, complexity, methods, line_count in hotspots[:10]:
+        lines.append(f"- **{rel}** — complexity: {complexity}, methods: {methods}, lines: {line_count}")
+    lines.append("")
+
+    # Large files
+    large = sorted(hotspots, key=lambda x: -x[3])[:10]
+    lines.append("## Largest Files (top 10)")
+    for rel, complexity, methods, line_count in large:
+        lines.append(f"- **{rel}** — {line_count} lines, {methods} methods")
+    lines.append("")
+
+    # Files with many methods (god classes)
+    many_methods = sorted(hotspots, key=lambda x: -x[2])[:5]
+    lines.append("## Potential God Classes (most methods)")
+    for rel, complexity, methods, line_count in many_methods:
+        if methods > 10:
+            lines.append(f"- **{rel}** — {methods} methods")
+
+    return "\n".join(lines)

mnemo/incidents/__init__.py

@@ -0,0 +1,90 @@
+"""Incident memory - store production incidents, root cause, fix, and prevention."""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+
+from ..storage import Collections, get_storage
+
+
+def _load_incidents(repo_root: Path) -> list[dict]:
+    data = get_storage(repo_root).read_collection(Collections.INCIDENTS)
+    return data if isinstance(data, list) else []
+
+
+def _save_incidents(repo_root: Path, incidents: list[dict]) -> None:
+    get_storage(repo_root).write_collection(Collections.INCIDENTS, incidents)
+
+
+def add_incident(
+    repo_root: Path,
+    title: str,
+    what_happened: str,
+    root_cause: str,
+    fix: str,
+    prevention: str = "",
+    severity: str = "medium",
+    services: list[str] | None = None,
+) -> dict:
+    """Store a production incident."""
+    incidents = _load_incidents(repo_root)
+    entry = {
+        "id": len(incidents) + 1,
+        "timestamp": time.time(),
+        "title": title,
+        "what_happened": what_happened,
+        "root_cause": root_cause,
+        "fix": fix,
+        "prevention": prevention,
+        "severity": severity,
+        "services": services or [],
+    }
+    incidents.append(entry)
+    _save_incidents(repo_root, incidents)
+    return entry
+
+
+def search_incidents(repo_root: Path, query: str) -> str:
+    """Search incident history."""
+    incidents = _load_incidents(repo_root)
+    query_lower = query.lower()
+
+    matches = [
+        incident
+        for incident in incidents
+        if query_lower in incident.get("title", "").lower()
+        or query_lower in incident.get("root_cause", "").lower()
+        or query_lower in incident.get("what_happened", "").lower()
+        or any(query_lower in service.lower() for service in incident.get("services", []))
+    ]
+
+    if not matches:
+        return f"No incidents matching '{query}'."
+
+    lines = [f"# Incidents matching '{query}'\n"]
+    for incident in matches:
+        severity = f"[{incident['severity']}]" if incident.get("severity") else ""
+        lines.append(f"## {incident['title']} {severity}")
+        lines.append(f"**What happened:** {incident['what_happened']}")
+        lines.append(f"**Root cause:** {incident['root_cause']}")
+        lines.append(f"**Fix:** {incident['fix']}")
+        if incident.get("prevention"):
+            lines.append(f"**Prevention:** {incident['prevention']}")
+        if incident.get("services"):
+            lines.append(f"**Services affected:** {', '.join(incident['services'])}")
+        lines.append("")
+    return "\n".join(lines)
+
+
+def format_incidents(repo_root: Path) -> str:
+    """Format all incidents as markdown."""
+    incidents = _load_incidents(repo_root)
+    if not incidents:
+        return "No incidents recorded."
+
+    lines = ["# Incident History\n"]
+    for incident in incidents:
+        severity = f"[{incident['severity']}]" if incident.get("severity") else ""
+        lines.append(f"- {severity} **{incident['title']}** - {incident['root_cause'][:80]}")
+    return "\n".join(lines)

mnemo/init.py

@@ -0,0 +1,167 @@
+"""Initialize .mnemo in a repository and configure MCP clients."""
+
+from pathlib import Path
+
+from .clients import (
+    CLIENTS,
+    DEFAULT_CLIENT,
+    ClientTarget,
+    context_path,
+    resolve_clients,
+    setup_mcp_config,
+)
+from .config import mnemo_path
+from .memory import save_context
+from .repo_map import save_repo_map
+
+
+MNEMO_RULE_HEADER = """\
+You have access to Mnemo - a persistent memory system for this project.
+All project context, decisions, and chat history is below. Use it to answer questions without re-reading files.
+
+AT THE START OF EVERY CHAT:
+- Call `mnemo_recall` to get the latest context. The embedded context below may be stale.
+
+ANSWERING QUESTIONS:
+- If the recalled memory already contains the answer, USE IT DIRECTLY. Do not re-read files or re-run lookups for information already in memory.
+- Only call `mnemo_lookup` or read files when memory does not have enough detail to answer.
+
+SAVING MEMORY:
+- Call `mnemo_remember` AFTER any of these happen in the conversation:
+  - You made a code change that affects behavior (theme change, config change, new feature, refactor)
+  - A bug was found and fixed
+  - A design or architecture decision was made
+  - The user stated a preference or convention
+  - A TODO or follow-up was identified
+  - You learned something non-obvious about the codebase
+- Call `mnemo_remember` when the context window is getting long to summarize progress so far.
+- Call `mnemo_remember` when the user explicitly asks to remember something.
+- Do NOT save trivial things like "read a file" or "answered a question with no new insight".
+- When in doubt, SAVE. It is better to remember too much than to forget something useful.
+- RULE: If you called `mnemo_lookup`, `mnemo_similar`, or `mnemo_who_touched` AND produced a summary or analysis from the results, you MUST call `mnemo_remember` with a concise summary before ending your response.
+
+AVAILABLE TOOLS:
+- `mnemo_lookup` - get method-level details for a file or folder
+- `mnemo_similar` - find similar implementations to follow as patterns
+- `mnemo_intelligence` - architecture graph, patterns, dependencies
+- `mnemo_discover_apis` - discover all API endpoints
+- `mnemo_search_api` - search for a specific endpoint
+- `mnemo_knowledge` - search team knowledge base
+- `mnemo_decide` - record a decision
+- `mnemo_context` - save project metadata
+- `mnemo_map` - refresh code map after changes
+- `mnemo_cross_search` - search across ALL linked repos (use when code might live in a sibling service)
+- `mnemo_cross_impact` - cross-repo impact analysis (what breaks in other repos if you change something here)
+- `mnemo_links` - show linked repos
+
+CROSS-REPO AWARENESS:
+- This repo has linked sibling repos. Use `mnemo_links` to see them.
+- ALWAYS call `mnemo_cross_search` BEFORE using grep or reading files when:
+  - The user asks about code that does not exist in this repo
+  - The user mentions a service, project, or module name that is not a folder in this repo
+  - `mnemo_lookup` or `mnemo_similar` returned no results
+- If the user asks "what breaks if I change X", use `mnemo_cross_impact` for full cross-repo analysis.
+- NEVER fall back to grep for code in other repos. Use `mnemo_cross_search` instead.
+
+---
+
+"""
+
+
+def _build_rule_with_context(repo_root: Path) -> str:
+    """Build a client context file with embedded Mnemo context."""
+    from .memory import recall
+
+    context = recall(repo_root)
+    return MNEMO_RULE_HEADER + context if context else MNEMO_RULE_HEADER
+
+
+def _install_context_file(repo_root: Path, target: ClientTarget) -> Path | None:
+    """Install or refresh the repo-local context file for a client."""
+    path = context_path(repo_root, target)
+    if path is None:
+        return None
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(_build_rule_with_context(repo_root), encoding="utf-8")
+    return path
+
+
+def refresh_context_files(repo_root: Path) -> None:
+    """Refresh all known Mnemo client context files that already exist."""
+    for target in CLIENTS.values():
+        path = context_path(repo_root, target)
+        if path and path.exists():
+            path.write_text(_build_rule_with_context(repo_root), encoding="utf-8")
+
+
+def _ensure_gitignore(repo_root: Path) -> None:
+    """Ensure local Mnemo data is ignored by git."""
+    gitignore = repo_root / ".gitignore"
+    if gitignore.exists():
+        content = gitignore.read_text(encoding="utf-8")
+        if ".mnemo" not in content:
+            gitignore.write_text(content.rstrip() + "\n.mnemo/\n", encoding="utf-8")
+    else:
+        gitignore.write_text(".mnemo/\n", encoding="utf-8")
+
+
+def init(repo_root: Path, client: str = DEFAULT_CLIENT) -> str:
+    """Create .mnemo/, generate repo map, install context files, and configure MCP."""
+    import os
+    os.environ["MNEMO_AUTO_INSTALL"] = "1"
+
+    targets = resolve_clients(client)
+    base = mnemo_path(repo_root)
+    base.mkdir(exist_ok=True)
+
+    save_repo_map(repo_root)
+
+    from .knowledge import init_knowledge
+
+    init_knowledge(repo_root)
+
+    from .intelligence import detect_patterns
+
+    patterns = detect_patterns(repo_root)
+    context_data = {
+        "repo_root": str(repo_root),
+        "initialized": True,
+    }
+    if patterns:
+        context_data["patterns"] = patterns
+    save_context(repo_root, context_data)
+
+    _ensure_gitignore(repo_root)
+
+    context_results: list[tuple[ClientTarget, Path | None]] = []
+    config_results: list[tuple[ClientTarget, bool]] = []
+    for target in targets:
+        context_results.append((target, _install_context_file(repo_root, target)))
+        config_results.append((target, setup_mcp_config(target)))
+
+    lines = [
+        "Mnemo initialized",
+        f"- .mnemo/ created at {base}",
+        "- Repo map generated",
+        "- Knowledge base directory ready",
+    ]
+
+    for target, path in context_results:
+        if path:
+            rel = path.relative_to(repo_root)
+            lines.append(f"- {target.display_name} {target.context_label} installed at {rel}")
+
+    for target, changed in config_results:
+        if target.mcp_config_path:
+            state = "configured" if changed else "already configured"
+            lines.append(f"- {target.display_name} MCP {state} at {target.mcp_config_path}")
+
+    if client == DEFAULT_CLIENT:
+        lines.append("")
+        lines.append("Amazon Q will now recall project memory at the start of every new chat.")
+    else:
+        client_names = ", ".join(target.display_name for target in targets)
+        lines.append("")
+        lines.append(f"{client_names} will now have access to Mnemo project memory.")
+
+    return "\n".join(lines)

mnemo/intelligence/__init__.py

@@ -0,0 +1,323 @@
+"""Code Intelligence — architecture graph, dependencies, patterns, ownership."""
+
+from __future__ import annotations
+
+import json
+import re
+from pathlib import Path
+from typing import Any
+
+from ..config import IGNORE_DIRS, mnemo_path
+from ..retrieval import semantic_query
+from ..sprint import get_current_task
+
+
+def _should_ignore(path: Path) -> bool:
+    return any(part in IGNORE_DIRS for part in path.parts)
+
+
+# --- Architecture Graph (service-to-service calls) ---
+
+def detect_service_calls(repo_root: Path) -> dict[str, list[str]]:
+    """Detect HTTP client calls between services by scanning for HttpClient, base URLs, etc."""
+    graph: dict[str, set[str]] = {}
+
+    for cs_file in repo_root.rglob("*.cs"):
+        if _should_ignore(cs_file):
+            continue
+        try:
+            content = cs_file.read_text(errors="replace")
+        except (OSError, PermissionError):
+            continue
+
+        # Identify which service this file belongs to
+        parts = cs_file.relative_to(repo_root).parts
+        service = parts[0] if len(parts) > 1 else "root"
+        if service not in graph:
+            graph[service] = set()
+
+        # Detect outbound HTTP calls
+        urls = re.findall(r'["\']https?://[^"\']+["\']', content)
+
+        for url in urls:
+            # Try to identify target service from URL
+            for known_svc in ["eligibility", "isauth", "providersearch", "servicereview", "auditlog", "mockdb"]:
+                if known_svc in url.lower():
+                    graph[service].add(known_svc)
+
+    return {k: sorted(v) for k, v in graph.items() if v}
+
+
+# --- Dependency Map ---
+
+def detect_dependencies(repo_root: Path) -> dict[str, list[str]]:
+    """Parse .csproj, package.json, requirements.txt for dependencies."""
+    deps: dict[str, list[str]] = {}
+
+    # .csproj files (NuGet)
+    for csproj in repo_root.rglob("*.csproj"):
+        if _should_ignore(csproj):
+            continue
+        try:
+            content = csproj.read_text(errors="replace")
+        except (OSError, PermissionError):
+            continue
+        packages = re.findall(r'<PackageReference\s+Include="([^"]+)"(?:\s+Version="([^"]*)")?', content)
+        if packages:
+            name = csproj.stem
+            deps[name] = [f"{pkg} {ver}".strip() for pkg, ver in packages]
+
+    # package.json
+    for pkg_json in repo_root.rglob("package.json"):
+        if _should_ignore(pkg_json):
+            continue
+        try:
+            data = json.loads(pkg_json.read_text())
+        except (OSError, json.JSONDecodeError):
+            continue
+        all_deps = {}
+        all_deps.update(data.get("dependencies", {}))
+        all_deps.update(data.get("devDependencies", {}))
+        if all_deps:
+            name = data.get("name", pkg_json.parent.name)
+            deps[name] = [f"{k} {v}" for k, v in all_deps.items()]
+
+    return deps
+
+
+# --- Pattern Detection ---
+
+def detect_patterns(repo_root: Path) -> list[str]:
+    """Detect common code patterns and conventions."""
+    patterns: list[str] = []
+    
+    # Check for common .NET patterns
+    controllers = list(repo_root.rglob("*Controller.cs"))
+    if controllers:
+        # Check what they inherit from
+        for c in controllers[:3]:
+            try:
+                content = c.read_text(errors="replace")
+                if "ControllerBase" in content:
+                    patterns.append("Controllers inherit from ControllerBase (API controllers, no views)")
+                    break
+                elif "Controller" in content:
+                    patterns.append("Controllers inherit from Controller (MVC with views)")
+                    break
+            except (OSError, PermissionError):
+                continue
+
+    # Check for repository pattern
+    repos = list(repo_root.rglob("*Repository.cs"))
+    interfaces = list(repo_root.rglob("I*Repository.cs"))
+    if repos and interfaces:
+        patterns.append(f"Repository pattern with interfaces ({len(interfaces)} interfaces, {len(repos)} implementations)")
+
+    # Check for handler/strategy pattern
+    handlers = list(repo_root.rglob("*Handler.cs"))
+    if len(handlers) > 2:
+        patterns.append(f"Strategy/Handler pattern ({len(handlers)} handlers found)")
+
+    # Check for DI registration
+    for f in repo_root.rglob("Program.cs"):
+        if _should_ignore(f):
+            continue
+        try:
+            content = f.read_text(errors="replace")
+            if "AddScoped" in content or "AddTransient" in content or "AddSingleton" in content:
+                patterns.append("Dependency injection via built-in .NET DI container")
+                break
+        except (OSError, PermissionError):
+            continue
+
+    # Check for test patterns
+    test_files = list(repo_root.rglob("*Tests.cs"))
+    if test_files:
+        try:
+            sample = test_files[0].read_text(errors="replace")
+            if "xUnit" in sample or "[Fact]" in sample:
+                patterns.append("Testing with xUnit ([Fact], [Theory])")
+            elif "[Test]" in sample:
+                patterns.append("Testing with NUnit")
+            if "Moq" in sample or "Mock<" in sample:
+                patterns.append("Mocking with Moq")
+            if "FluentAssertions" in sample:
+                patterns.append("Assertions with FluentAssertions")
+        except (OSError, PermissionError):
+            pass
+
+    # Check for CosmosDB
+    cosmos_files = [f for f in repo_root.rglob("*.cs") if not _should_ignore(f)]
+    for f in cosmos_files[:50]:
+        try:
+            if "CosmosClient" in f.read_text(errors="replace"):
+                patterns.append("Data layer: Azure CosmosDB")
+                break
+        except (OSError, PermissionError):
+            continue
+
+    return patterns
+
+
+def classify_architecture(repo_root: Path) -> list[dict[str, Any]]:
+    """Classify high-level architecture styles with evidence."""
+    findings: list[dict[str, Any]] = []
+    paths = [p for p in repo_root.rglob("*") if not _should_ignore(p)]
+    names = [str(p).lower() for p in paths]
+    text_blob = " ".join(names)
+
+    checks = [
+        ("Clean Architecture", ["domain", "application", "infrastructure", "presentation"]),
+        ("CQRS", ["command", "query", "handler"]),
+        ("Hexagonal", ["ports", "adapters"]),
+        ("Event-Driven", ["event", "consumer", "producer"]),
+        ("Microservices", ["docker-compose", "helm", "service", "gateway"]),
+    ]
+    for arch, signals in checks:
+        matched = [signal for signal in signals if signal in text_blob]
+        if matched:
+            findings.append(
+                {
+                    "name": arch,
+                    "confidence": round(len(matched) / len(signals), 2),
+                    "evidence": matched,
+                }
+            )
+    return sorted(findings, key=lambda item: item["confidence"], reverse=True)
+
+
+# --- Similar Implementations ---
+
+def find_similar(repo_root: Path, query: str) -> list[dict[str, str]]:
+    """Find files with similar naming patterns to help implement new features."""
+    query_lower = query.lower()
+    semantic_hits = semantic_query(repo_root, "code", query, limit=20)
+    if semantic_hits:
+        results = []
+        for hit in semantic_hits:
+            meta = hit.get("metadata", {})
+            results.append(
+                {
+                    "file": str(meta.get("path", "")),
+                    "class": str(meta.get("symbol", "")),
+                    "content": hit.get("content", "")[:300],
+                }
+            )
+        return results
+
+    similar: list[dict[str, str]] = []
+
+    # Find files matching the pattern
+    for cs_file in repo_root.rglob("*.cs"):
+        if _should_ignore(cs_file):
+            continue
+        name = cs_file.stem.lower()
+        # Match by suffix pattern (e.g. "Handler" finds all *Handler.cs)
+        if query_lower in name:
+            rel = str(cs_file.relative_to(repo_root))
+            try:
+                content = cs_file.read_text(errors="replace")
+                # Get class declaration line
+                match = re.search(r'(public\s+class\s+\w+[^{]*)', content)
+                sig = match.group(1).strip() if match else ""
+                similar.append({"file": rel, "class": sig})
+            except (OSError, PermissionError):
+                similar.append({"file": rel, "class": ""})
+
+    return similar[:20]
+
+
+def context_for_active_task(repo_root: Path, query: str = "") -> str:
+    """Retrieve semantic context using the active task as a relevance hint."""
+    active_task_markdown = get_current_task(repo_root)
+    if active_task_markdown.startswith("No active task"):
+        return active_task_markdown
+
+    search_query = query.strip() or active_task_markdown
+    hits = semantic_query(repo_root, "code", search_query, limit=10)
+    if not hits:
+        return "No semantic context found for the current task."
+
+    lines = ["# Context for Active Task", "", "## Active Task", active_task_markdown, "", "## Relevant Code"]
+    for hit in hits:
+        meta = hit.get("metadata", {})
+        lines.append(f"- `{meta.get('path', '')}` :: `{meta.get('symbol', '')}`")
+    return "\n".join(lines)
+
+
+# --- Ownership (git blame stats) ---
+
+def detect_ownership(repo_root: Path) -> dict[str, str]:
+    """Detect code ownership from CODEOWNERS or git stats."""
+    owners: dict[str, str] = {}
+
+    # Check CODEOWNERS
+    for codeowners_path in [
+        repo_root / "CODEOWNERS",
+        repo_root / ".github" / "CODEOWNERS",
+        repo_root / "docs" / "CODEOWNERS",
+    ]:
+        if codeowners_path.exists():
+            try:
+                for line in codeowners_path.read_text().splitlines():
+                    line = line.strip()
+                    if line and not line.startswith("#"):
+                        parts = line.split()
+                        if len(parts) >= 2:
+                            owners[parts[0]] = " ".join(parts[1:])
+            except (OSError, PermissionError):
+                pass
+            break
+
+    return owners
+
+
+# --- Main intelligence report ---
+
+def generate_intelligence(repo_root: Path) -> str:
+    """Generate a full code intelligence report as markdown."""
+    lines = ["# Code Intelligence\n"]
+
+    # Patterns
+    patterns = detect_patterns(repo_root)
+    if patterns:
+        lines.append("## Patterns & Conventions")
+        for p in patterns:
+            lines.append(f"- {p}")
+        lines.append("")
+
+    # Architecture
+    graph = detect_service_calls(repo_root)
+    if graph:
+        lines.append("## Service Architecture")
+        for svc, targets in sorted(graph.items()):
+            lines.append(f"- **{svc}** → {', '.join(targets)}")
+        lines.append("")
+
+    # Dependencies
+    deps = detect_dependencies(repo_root)
+    if deps:
+        lines.append("## Dependencies")
+        for project, pkgs in sorted(deps.items()):
+            lines.append(f"**{project}:** {', '.join(pkgs[:10])}")
+            if len(pkgs) > 10:
+                lines.append(f"  ... and {len(pkgs) - 10} more")
+        lines.append("")
+
+    # Ownership
+    owners = detect_ownership(repo_root)
+    if owners:
+        lines.append("## Code Ownership")
+        for path, owner in owners.items():
+            lines.append(f"- `{path}` → {owner}")
+        lines.append("")
+
+    architectures = classify_architecture(repo_root)
+    if architectures:
+        lines.append("## Architecture Classification")
+        for arch in architectures:
+            evidence = ", ".join(arch["evidence"])
+            lines.append(f"- **{arch['name']}** (confidence {arch['confidence']}) — evidence: {evidence}")
+        lines.append("")
+
+    return "\n".join(lines)