Add phd_research_os_v2/layer7/obsidian.py

phd_research_os_v2/layer7/obsidian.py

@@ -0,0 +1,186 @@
+"""
+Layer 7: Obsidian Export (v2)
+===============================
+Export v2 claims, graph, conflicts to Obsidian vault with full provenance.
+"""
+
+import json
+import os
+from datetime import datetime
+from pathlib import Path
+from ..core.database import get_db, from_fixed
+
+
+class ObsidianExporterV2:
+    """Export Research OS v2 data to linked Obsidian vault."""
+    
+    def __init__(self, vault_path: str = "vault", db_path: str = None):
+        self.vault_path = Path(vault_path)
+        self.db_path = db_path or os.environ.get("RESEARCH_OS_DB", "data/research_os_v2.db")
+        for d in ["Claims", "Sources", "Goals", "Conflicts", "Decisions", "Canonicals"]:
+            (self.vault_path / d).mkdir(parents=True, exist_ok=True)
+    
+    def export_all(self) -> dict:
+        conn = get_db(self.db_path)
+        stats = {}
+        
+        # Claims
+        claims = conn.execute("SELECT * FROM claims ORDER BY composite_confidence DESC").fetchall()
+        for c in claims:
+            self._export_claim(dict(c))
+        stats["claims"] = len(claims)
+        
+        # Canonical claims
+        canonicals = conn.execute("SELECT * FROM canonical_claims ORDER BY evidence_count DESC").fetchall()
+        for c in canonicals:
+            self._export_canonical(dict(c))
+        stats["canonicals"] = len(canonicals)
+        
+        # Conflicts
+        conflicts = conn.execute("SELECT * FROM conflicts").fetchall()
+        for c in conflicts:
+            self._export_conflict(dict(c))
+        stats["conflicts"] = len(conflicts)
+        
+        # Goals
+        goals = conn.execute("SELECT * FROM goals").fetchall()
+        for g in goals:
+            self._export_goal(dict(g))
+        stats["goals"] = len(goals)
+        
+        # Dashboard
+        self._export_dashboard(conn)
+        stats["dashboard"] = 1
+        
+        conn.close()
+        return stats
+    
+    def _export_claim(self, claim: dict):
+        cid = claim["claim_id"]
+        conf = from_fixed(claim.get("composite_confidence", 0))
+        ev_q = from_fixed(claim.get("evidence_quality", 0)) if claim.get("evidence_quality") else "—"
+        truth = from_fixed(claim.get("truth_likelihood", 0)) if claim.get("truth_likelihood") else "—"
+        qual_s = from_fixed(claim.get("qualifier_strength_score", 0)) if claim.get("qualifier_strength_score") else "—"
+        qualifiers = json.loads(claim.get("qualifiers", "[]")) if isinstance(claim.get("qualifiers"), str) else claim.get("qualifiers", [])
+        missing = json.loads(claim.get("missing_fields", "[]")) if isinstance(claim.get("missing_fields"), str) else claim.get("missing_fields", [])
+        
+        content = f"""---
+claim_id: {cid}
+epistemic_tag: {claim.get('epistemic_tag', '')}
+composite_confidence: {conf}
+evidence_quality: {ev_q}
+truth_likelihood: {truth}
+qualifier_strength: {qual_s}
+status: {claim.get('status', '')}
+section: {claim.get('source_section', '')}
+is_null_result: {bool(claim.get('is_null_result', 0))}
+canonical_id: {claim.get('canonical_id', '')}
+source_doi: {claim.get('source_doi', '')}
+---
+
+## {claim.get('text', '')}
+
+### Scores
+| Score | Value |
+|-------|-------|
+| Composite Confidence | {conf:.3f} |
+| Evidence Quality | {ev_q} |
+| Truth Likelihood | {truth} |
+| Qualifier Strength | {qual_s} |
+
+### Qualifiers
+{', '.join(qualifiers) if qualifiers else 'None — claim is unhedged'}
+
+### Missing Fields  
+{', '.join(missing) if missing else 'None — claim is complete'}
+
+### Source
+- **Section**: {claim.get('source_section', 'unknown')}
+- **Page**: {claim.get('source_page', '?')}
+- **Quote**: _{claim.get('source_quote', 'N/A')}_
+- **DOI**: {claim.get('source_doi', 'N/A')}
+{f'- **Canonical**: [[{claim.get("canonical_id", "")}]]' if claim.get('canonical_id') else ''}
+"""
+        (self.vault_path / "Claims" / f"{cid}.md").write_text(content)
+    
+    def _export_canonical(self, canon: dict):
+        cid = canon["canonical_id"]
+        conf = from_fixed(canon.get("composite_confidence", 0))
+        aliases = json.loads(canon.get("aliases", "[]")) if isinstance(canon.get("aliases"), str) else canon.get("aliases", [])
+        sources = json.loads(canon.get("source_dois", "[]")) if isinstance(canon.get("source_dois"), str) else canon.get("source_dois", [])
+        
+        content = f"""---
+canonical_id: {cid}
+epistemic_tag: {canon.get('epistemic_tag', '')}
+confidence: {conf}
+evidence_count: {canon.get('evidence_count', 0)}
+---
+
+## {canon.get('representative_text', '')}
+
+### Evidence ({canon.get('evidence_count', 0)} sources)
+{chr(10).join(f'- {doi}' for doi in sources) if sources else 'No sources linked'}
+
+### Linked Claims
+{chr(10).join(f'- [[{a}]]' for a in aliases) if aliases else 'No aliases'}
+"""
+        (self.vault_path / "Canonicals" / f"{cid}.md").write_text(content)
+    
+    def _export_conflict(self, conflict: dict):
+        content = f"""---
+conflict_id: {conflict['conflict_id']}
+conflict_type: {conflict.get('conflict_type', '')}
+resolution_status: {conflict.get('resolution_status', 'Unresolved')}
+hypothesis_confidence: low
+---
+
+## Conflict: [[{conflict.get('claim_a_id', '')}]] vs [[{conflict.get('claim_b_id', '')}]]
+
+**Type**: {conflict.get('conflict_type', '')}
+**Status**: {conflict.get('resolution_status', 'Unresolved')}
+
+⚠️ **Hypothesis confidence: LOW** — Requires human review
+"""
+        (self.vault_path / "Conflicts" / f"{conflict['conflict_id']}.md").write_text(content)
+    
+    def _export_goal(self, goal: dict):
+        content = f"""---
+goal_id: {goal['goal_id']}
+priority: {goal.get('priority', '')}
+status: {goal.get('status', '')}
+---
+
+## {goal.get('description', '')}
+
+**Priority**: {goal.get('priority', '')}
+**Status**: {goal.get('status', '')}
+"""
+        (self.vault_path / "Goals" / f"{goal['goal_id']}.md").write_text(content)
+    
+    def _export_dashboard(self, conn):
+        claims_count = conn.execute("SELECT COUNT(*) FROM claims").fetchone()[0]
+        canon_count = conn.execute("SELECT COUNT(*) FROM canonical_claims").fetchone()[0]
+        conflicts_count = conn.execute("SELECT COUNT(*) FROM conflicts WHERE resolution_status = 'Unresolved'").fetchone()[0]
+        goals_count = conn.execute("SELECT COUNT(*) FROM goals WHERE status = 'Active'").fetchone()[0]
+        docs_count = conn.execute("SELECT COUNT(*) FROM documents").fetchone()[0]
+        
+        now = datetime.now().strftime("%Y-%m-%d %H:%M")
+        
+        content = f"""---
+type: dashboard
+updated: {now}
+---
+
+# PhD Research OS v2.0 Dashboard
+
+*Updated: {now}*
+
+| Metric | Count |
+|--------|-------|
+| Documents Ingested | {docs_count} |
+| Total Claims | {claims_count} |
+| Canonical Claims | {canon_count} |
+| Unresolved Conflicts | {conflicts_count} |
+| Active Goals | {goals_count} |
+"""
+        (self.vault_path / "Dashboard.md").write_text(content)