ompa 0.1.0__py3-none-any.whl

ompa/__init__.py

@@ -0,0 +1,44 @@
+"""
+OMPA — Obsidian-MemPalace-Agnostic
+
+Universal AI agent memory layer.
+Combines obsidian-mind vault conventions + MemPalace palace structure + temporal knowledge graph.
+
+Works with OpenClaw, Claude Code, Codex, Gemini CLI, or any AI agent.
+
+Usage:
+    from ompa import AgnosticObsidian
+    ao = AgnosticObsidian(vault_path="./workspace")
+    result = ao.session_start()
+    hint = ao.handle_message("We decided to go with Postgres")
+    ao.post_tool("write", {"file_path": "work/active/auth.md"})
+    ao.stop()
+"""
+
+__version__ = "0.1.0"
+
+from .core import AgnosticObsidian
+from .vault import Vault, Note, VaultConfig
+from .palace import Palace
+from .knowledge_graph import KnowledgeGraph
+from .classifier import MessageClassifier, Classification, MessageType
+from .hooks import HookManager, HookContext, HookResult, Hook
+from .semantic import SemanticIndex, SearchResult
+
+__all__ = [
+    "AgnosticObsidian",
+    "Vault",
+    "Note",
+    "VaultConfig",
+    "Palace",
+    "KnowledgeGraph",
+    "MessageClassifier",
+    "Classification",
+    "MessageType",
+    "HookManager",
+    "HookContext",
+    "HookResult",
+    "Hook",
+    "SemanticIndex",
+    "SearchResult",
+]

ompa/classifier.py

@@ -0,0 +1,268 @@
+"""
+Message classification for routing and context injection.
+Classifies user messages into categories and injects routing hints.
+"""
+import re
+from enum import Enum
+from dataclasses import dataclass
+
+
+class MessageType(Enum):
+    DECISION = "decision"
+    INCIDENT = "incident"
+    WIN = "win"
+    ONE_ON_ONE = "one-on-one"
+    MEETING = "meeting"
+    PROJECT_UPDATE = "project-update"
+    PERSON_INFO = "person-info"
+    QUESTION = "question"
+    TASK = "task"
+    ARCHITECTURE = "architecture"
+    CODE = "code"
+    BRAIN_DUMP = "brain-dump"
+    WRAP_UP = "wrap-up"
+    STANDUP = "standup"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class Classification:
+    message_type: MessageType
+    confidence: float
+    routing_hints: list[str]
+    suggested_folder: str
+    suggested_action: str
+
+
+class MessageClassifier:
+    """
+    Classifies user messages and provides routing guidance.
+    Inspired by obsidian-minds classify-message.py but framework-agnostic.
+    """
+    
+    # Regex patterns for classification
+    PATTERNS = {
+        MessageType.DECISION: [
+            r"\b(decided|decision|we chose|going with|settled on|agreed to)\b",
+            r"\b(defer|postpone|push to|revisit)\b.*\b(Q\d|quarter|sprint)\b",
+            r"(?:ADR|decision record)",
+        ],
+        MessageType.INCIDENT: [
+            r"\b(incident|outage|bug|crash|failure|error|broken)\b",
+            r"\b(debug|root cause|RCA|mitigation|hotfix)\b",
+            r"(?:on-call|pagerduty|statuspage)",
+        ],
+        MessageType.WIN: [
+            r"\b(won|praised|success|achieved|shipped|launched|deployed)\b",
+            r"\b(great work|nice job|excellent|well done)\b",
+            r"\b(milestone|feature complete|released)\b",
+        ],
+        MessageType.ONE_ON_ONE: [
+            r"\b(1:1|one-on-one|1on1|check-in|sync)\b.*\b(manager|lead|peer|coworker)\b",
+            r"\b(feedback|concerns|growth|progress|career)\b",
+            r"\b(1-on-1|weekly sync|bias for action)\b",
+        ],
+        MessageType.MEETING: [
+            r"\b(meeting|briefing|session|call)\b",
+            r"\b(agenda|notes|takeaways|action items)\b",
+            r"\b(prep for|preparing for|standup|retrospective)\b",
+        ],
+        MessageType.PROJECT_UPDATE: [
+            r"\b(project|initiative|epic|feature|story|ticket)\b.*\b(update|progress|status|blocked)\b",
+            r"\b(working on|started|finished|continuing)\b",
+            r"\b(blocked on|waiting for|depends on)\b",
+        ],
+        MessageType.PERSON_INFO: [
+            r"\b(teammate|coworker|peer|manager|lead|engineer)\b.*\b(joined|moved|left|new|role)\b",
+            r"\b(people|team|person)\b.*\b(update|change|info)\b",
+            r"\b(Sarah|John|Mike|Tom|Jane)\b",  # Names as hints
+        ],
+        MessageType.QUESTION: [
+            r"\b(how do|how can|what is|what are|why does|can we|should we)\b",
+            r"\?",  # Question marks
+            r"\b(clarify|explain|help me understand)\b",
+        ],
+        MessageType.TASK: [
+            r"\b(task|todo|action item|follow-up)\b",
+            r"\b(do this|handle|take care of|responsible for)\b",
+            r"\-\s*\[[x ]\]",  # Checkbox syntax
+        ],
+        MessageType.ARCHITECTURE: [
+            r"\b(architecture|design|system design| ADR |technical design)\b",
+            r"\b(api|service|microservice|backend|frontend|infrastructure)\b.*\b(design|decide|approach)\b",
+            r"\b(migration|refactor|deprecate|legacy)\b",
+        ],
+        MessageType.CODE: [
+            r"\b(code|function|class|module|import|export)\b",
+            r"\b(python|rust|javascript|typescript|java|go)\b",
+            r"\b(bug fix|feature|PR|pull request|commit)\b",
+        ],
+        MessageType.BRAIN_DUMP: [
+            r"\b(dump|stream of consciousness|random thoughts|everything on my mind)\b",
+            r"\b(btw|also|oh and|forgot to mention)\b",
+        ],
+        MessageType.WRAP_UP: [
+            r"\b(wrap up|wrapping up|finish up|end session|done for today)\b",
+        ],
+        MessageType.STANDUP: [
+            r"\b(standup|daily|start of day|morning kickoff)\b",
+            r"\b(start session|start work|starting)\b",
+        ],
+    }
+    
+    # Routing hints per message type
+    ROUTING_HINTS = {
+        MessageType.DECISION: [
+            "This is a decision. Record it in brain/Key Decisions.md",
+            "Update relevant project notes with the decision",
+            "Add to Decision Log if formal ADR needed",
+        ],
+        MessageType.INCIDENT: [
+            "Create incident note in work/incidents/",
+            "Run /om-incident-capture for structured capture",
+            "Update brain/Gotchas.md with lessons learned",
+        ],
+        MessageType.WIN: [
+            "Add to perf/Brag Doc.md immediately",
+            "This is a win worth capturing for performance review",
+            "Update relevant competency notes with evidence",
+        ],
+        MessageType.ONE_ON_ONE: [
+            "Create or update 1:1 note in work/1-1/",
+            "Run /om-prep-1on1 if preparing for upcoming 1:1",
+        ],
+        MessageType.MEETING: [
+            "Run /om-meeting for structured meeting prep",
+            "Add to work/meetings/ inbox for later processing",
+        ],
+        MessageType.PROJECT_UPDATE: [
+            "Update work/active/ project note",
+            "Check if project status has changed",
+        ],
+        MessageType.PERSON_INFO: [
+            "Update org/people/ note for this person",
+            "Run /om-people-profiler for context",
+        ],
+        MessageType.QUESTION: [
+            "Answer directly with available context",
+            "Consider searching vault for relevant knowledge first",
+        ],
+        MessageType.TASK: [
+            "Add to task list / obsidian tasks",
+            "Track completion in relevant project note",
+        ],
+        MessageType.ARCHITECTURE: [
+            "Consider creating ADR in work/active/",
+            "Update reference/architecture docs",
+        ],
+        MessageType.CODE: [
+            "Focus on implementation details",
+            "Update relevant code documentation",
+        ],
+        MessageType.BRAIN_DUMP: [
+            "Run /om-dump for freeform capture",
+            "Route to appropriate notes automatically",
+        ],
+        MessageType.WRAP_UP: [
+            "Run /om-wrap-up for session review",
+            "Verify all notes have links",
+            "Update indexes before closing",
+        ],
+        MessageType.STANDUP: [
+            "Run /om-standup for structured morning context",
+            "Read brain/North Star.md first",
+        ],
+    }
+    
+    # Suggested folder locations
+    FOLDER_MAP = {
+        MessageType.DECISION: "work/active/",
+        MessageType.INCIDENT: "work/incidents/",
+        MessageType.WIN: "perf/brag/",
+        MessageType.ONE_ON_ONE: "work/1-1/",
+        MessageType.MEETING: "work/meetings/",
+        MessageType.PROJECT_UPDATE: "work/active/",
+        MessageType.PERSON_INFO: "org/people/",
+        MessageType.QUESTION: "thinking/",
+        MessageType.TASK: "work/active/",
+        MessageType.ARCHITECTURE: "work/active/",
+        MessageType.CODE: "reference/",
+        MessageType.BRAIN_DUMP: "thinking/",
+        MessageType.WRAP_UP: "brain/",
+        MessageType.STANDUP: "brain/",
+    }
+    
+    def classify(self, message: str) -> Classification:
+        """
+        Classify a user message and return routing guidance.
+        
+        Args:
+            message: The user message text
+            
+        Returns:
+            Classification with type, confidence, hints, and suggested actions
+        """
+        message_lower = message.lower()
+        scores = {}
+        
+        for msg_type, patterns in self.PATTERNS.items():
+            score = 0
+            for pattern in patterns:
+                if re.search(pattern, message_lower, re.IGNORECASE):
+                    score += 1
+            if score > 0:
+                scores[msg_type] = score
+        
+        if not scores:
+            return Classification(
+                message_type=MessageType.UNKNOWN,
+                confidence=0.0,
+                routing_hints=["Process as normal conversation"],
+                suggested_folder="thinking/",
+                suggested_action="Continue conversation normally"
+            )
+        
+        # Get highest scoring type
+        best_type = max(scores, key=scores.get)
+        confidence = min(scores[best_type] / 3.0, 1.0)  # Normalize to 0-1
+        
+        # For short messages, reduce confidence
+        if len(message.split()) < 5:
+            confidence *= 0.7
+        
+        return Classification(
+            message_type=best_type,
+            confidence=confidence,
+            routing_hints=self.ROUTING_HINTS.get(best_type, []),
+            suggested_folder=self.FOLDER_MAP.get(best_type, "thinking/"),
+            suggested_action=self._get_action(best_type)
+        )
+    
+    def _get_action(self, msg_type: MessageType) -> str:
+        """Get the primary action for a message type."""
+        actions = {
+            MessageType.DECISION: "Record decision and update relevant project notes",
+            MessageType.INCIDENT: "Create incident note and capture details",
+            MessageType.WIN: "Add to Brag Doc and update competency evidence",
+            MessageType.ONE_ON_ONE: "Create or update 1:1 meeting note",
+            MessageType.MEETING: "Create meeting prep or capture notes",
+            MessageType.PROJECT_UPDATE: "Update project status in work/active/",
+            MessageType.PERSON_INFO: "Update person note in org/people/",
+            MessageType.QUESTION: "Search vault and answer from context",
+            MessageType.TASK: "Add to task list",
+            MessageType.ARCHITECTURE: "Consider creating ADR",
+            MessageType.CODE: "Focus on implementation",
+            MessageType.BRAIN_DUMP: "Run /om-dump to route content",
+            MessageType.WRAP_UP: "Run /om-wrap-up session checklist",
+            MessageType.STANDUP: "Run /om-standup for morning context",
+            MessageType.UNKNOWN: "Continue conversation",
+        }
+        return actions.get(msg_type, "Continue conversation")
+    
+    def get_routing_hint(self, message: str) -> str:
+        """
+        Get a single-line routing hint for a message.
+        Suitable for injecting into context.
+        """
+        classification = self.classify(message)
+        return f"[{classification.message_type.value.upper()}] {classification.suggested_action}"

ompa/cli.py

@@ -0,0 +1,298 @@
+"""
+CLI for AgnosticObsidian.
+Run with: ao <command> or ao-mcp <command>
+"""
+import sys
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+sys.path.insert(0, str(Path(__file__).parent))
+
+try:
+    from agnostic_obsidian import AgnosticObsidian, Palace, KnowledgeGraph
+except ImportError:
+    # Development mode
+    from agnostic_obsidian import AgnosticObsidian, Palace, KnowledgeGraph
+
+app = typer.Typer(help="AgnosticObsidian — Universal AI agent memory layer")
+console = Console()
+
+
+@app.command()
+def init(
+    vault_path: Path = Path("."),
+):
+    """Initialize vault + palace structure."""
+    from agnostic_obsidian import Vault
+    vault = Vault(vault_path)
+    stats = vault.get_stats()
+    ao = AgnosticObsidian(vault_path, enable_semantic=False)
+    palace_count = ao.palace_build()
+    console.print(f"[green]Initialized at {vault_path.absolute()}[/green]")
+    console.print(f"  Notes: {stats['total_notes']}")
+    console.print(f"  Brain notes: {stats['brain_notes']}")
+    console.print(f"  Palace wings built: {palace_count}")
+
+
+@app.command()
+def status(
+    vault_path: Path = Path("."),
+):
+    """Show vault + palace + KG overview."""
+    ao = AgnosticObsidian(vault_path, enable_semantic=False)
+
+    vault_stats = ao.get_stats()
+    palace_stats = ao.palace.stats()
+    kg_stats = ao.kg.stats()
+
+    console.print("[bold]Vault[/bold]")
+    console.print(f"  Total notes: {vault_stats['total_notes']}")
+    console.print(f"  Brain notes: {vault_stats['brain_notes']}")
+    console.print(f"  Orphans: {vault_stats['orphans']}")
+
+    console.print("[bold]Palace[/bold]")
+    console.print(f"  Wings: {palace_stats['wing_count']}")
+    console.print(f"  Rooms: {palace_stats['room_count']}")
+    console.print(f"  Drawers: {palace_stats['drawer_count']}")
+    console.print(f"  Tunnels: {palace_stats['tunnel_count']}")
+
+    console.print("[bold]Knowledge Graph[/bold]")
+    console.print(f"  Entities: {kg_stats['entity_count']}")
+    console.print(f"  Triples: {kg_stats['triple_count']}")
+    console.print(f"  Current facts: {kg_stats['current_facts']}")
+
+
+@app.command()
+def session_start(
+    vault_path: Path = Path("."),
+):
+    """Run session start hook."""
+    ao = AgnosticObsidian(vault_path, enable_semantic=False)
+    result = ao.session_start()
+    console.print(result.output)
+
+
+@app.command()
+def classify(
+    message: str,
+    vault_path: Path = Path("."),
+):
+    """Classify a message."""
+    ao = AgnosticObsidian(vault_path, enable_semantic=False)
+    c = ao.classify(message)
+    console.print(f"[bold]Type:[/bold] {c.message_type.value.upper()}")
+    console.print(f"[bold]Confidence:[/bold] {c.confidence:.0%}")
+    console.print(f"[bold]Action:[/bold] {c.suggested_action}")
+    if c.routing_hints:
+        console.print("[bold]Hints:[/bold]")
+        for hint in c.routing_hints:
+            console.print(f"  - {hint}")
+
+
+@app.command()
+def search(
+    query: str,
+    vault_path: Path = Path("."),
+    limit: int = 5,
+):
+    """Search the vault semantically."""
+    ao = AgnosticObsidian(vault_path, enable_semantic=True)
+    results = ao.search(query, limit=limit)
+
+    table = Table(title=f"Search: {query}")
+    table.add_column("Score")
+    table.add_column("Type")
+    table.add_column("Path")
+    table.add_column("Excerpt")
+
+    for r in results:
+        excerpt = r.content_excerpt[:80] + "..." if len(r.content_excerpt) > 80 else r.content_excerpt
+        table.add_row(f"{r.score:.2f}", r.match_type, r.path, excerpt)
+
+    console.print(table)
+
+
+@app.command()
+def orphans(
+    vault_path: Path = Path("."),
+):
+    """Find orphan notes (no wikilinks)."""
+    ao = AgnosticObsidian(vault_path, enable_semantic=False)
+    orphan_notes = ao.find_orphans()
+    if not orphan_notes:
+        console.print("[green]No orphan notes found![/green]")
+    else:
+        console.print(f"[yellow]Found {len(orphan_notes)} orphan notes:[/yellow]")
+        for note in orphan_notes:
+            rel = note.path.relative_to(vault_path) if note.path.is_relative_to(vault_path) else note.path
+            console.print(f"  - {rel}")
+
+
+@app.command()
+def wrap_up(
+    vault_path: Path = Path("."),
+):
+    """Run wrap-up (stop) hook."""
+    ao = AgnosticObsidian(vault_path, enable_semantic=False)
+    result = ao.stop()
+    console.print(result.output)
+
+
+@app.command()
+def wings(
+    vault_path: Path = Path("."),
+):
+    """List palace wings."""
+    ao = AgnosticObsidian(vault_path, enable_semantic=False)
+    wing_list = ao.palace.list_wings()
+
+    table = Table(title="Palace Wings")
+    table.add_column("Name")
+    table.add_column("Type")
+    table.add_column("Keywords")
+
+    for w in wing_list:
+        table.add_row(w["name"], w["type"], ", ".join(w.get("keywords", [])))
+
+    console.print(table)
+
+
+@app.command()
+def rooms(
+    wing: str,
+    vault_path: Path = Path("."),
+):
+    """List rooms in a wing."""
+    ao = AgnosticObsidian(vault_path, enable_semantic=False)
+    room_list = ao.palace.list_rooms(wing)
+    if not room_list:
+        console.print(f"[yellow]No rooms found in wing '{wing}'[/yellow]")
+    else:
+        console.print(f"[bold]Rooms in {wing}:[/bold]")
+        for r in room_list:
+            drawers = ao.palace.get_drawers(wing, r)
+            console.print(f"  - {r} ({len(drawers)} drawers)")
+
+
+@app.command()
+def tunnel(
+    wing_a: str,
+    wing_b: str,
+    vault_path: Path = Path("."),
+):
+    """Find tunnels between two wings."""
+    ao = AgnosticObsidian(vault_path, enable_semantic=False)
+    tunnels = ao.palace.find_tunnels(wing_a, wing_b)
+    if not tunnels:
+        console.print(f"[yellow]No tunnels between {wing_a} and {wing_b}[/yellow]")
+    else:
+        console.print(f"[bold]Tunnels between {wing_a} and {wing_b}:[/bold]")
+        for t in tunnels:
+            console.print(f"  - {t['wing_a']}/{t['room']} <-> {t['wing_b']}/{t['room']}")
+
+
+@app.command()
+def kg_query(
+    entity: str,
+    as_of: str = None,
+    vault_path: Path = Path("."),
+):
+    """Query the knowledge graph."""
+    ao = AgnosticObsidian(vault_path, enable_semantic=False)
+    triples = ao.kg.query_entity(entity, as_of=as_of)
+
+    if not triples:
+        console.print(f"[yellow]No facts found for '{entity}'[/yellow]")
+        return
+
+    console.print(f"[bold]Facts about {entity}:[/bold]")
+    if as_of:
+        console.print(f"  (as of {as_of})")
+    for t in triples:
+        validity = f"({t.valid_from}"
+        validity += f" to {t.valid_to}" if t.valid_to else ""
+        validity += ")"
+        console.print(f"  {t.subject} --{t.predicate}--> {t.object} {validity}")
+
+
+@app.command()
+def kg_timeline(
+    entity: str,
+    vault_path: Path = Path("."),
+):
+    """Get entity timeline."""
+    ao = AgnosticObsidian(vault_path, enable_semantic=False)
+    timeline = ao.kg.timeline(entity)
+
+    if not timeline:
+        console.print(f"[yellow]No timeline for '{entity}'[/yellow]")
+        return
+
+    console.print(f"[bold]Timeline: {entity}[/bold]")
+    for event in timeline:
+        date_str = event["date"] or "(no date)"
+        console.print(f"  [{date_str}] {event['label']}")
+
+
+@app.command()
+def kg_stats(
+    vault_path: Path = Path("."),
+):
+    """Show KG statistics."""
+    ao = AgnosticObsidian(vault_path, enable_semantic=False)
+    stats = ao.kg.stats()
+    console.print("[bold]Knowledge Graph Stats[/bold]")
+    for k, v in stats.items():
+        console.print(f"  {k}: {v}")
+
+
+@app.command()
+def validate(
+    vault_path: Path = Path("."),
+):
+    """Validate all notes in the vault."""
+    ao = AgnosticObsidian(vault_path, enable_semantic=False)
+    from agnostic_obsidian import Vault
+    vault = Vault(vault_path)
+    notes = vault.list_notes()
+
+    total = 0
+    warnings_list = []
+    for note in notes:
+        result = ao.validate_write(str(note.path))
+        if result["warnings"]:
+            total += 1
+            for w in result["warnings"]:
+                rel = note.path.relative_to(vault_path) if note.path.is_relative_to(vault_path) else note.path
+                warnings_list.append(f"  {rel}: {w}")
+
+    if warnings_list:
+        console.print(f"[yellow]Found issues in {total} notes:[/yellow]")
+        for w in warnings_list[:20]:
+            console.print(w)
+        if len(warnings_list) > 20:
+            console.print(f"  ... and {len(warnings_list) - 20} more")
+    else:
+        console.print("[green]All notes valid![/green]")
+
+
+@app.command()
+def rebuild_index(
+    vault_path: Path = Path("."),
+):
+    """Rebuild the semantic search index."""
+    ao = AgnosticObsidian(vault_path, enable_semantic=True)
+    count = ao.rebuild_index()
+    console.print(f"[green]Indexed {count} files[/green]")
+
+
+def main():
+    """Main entry point."""
+    app()
+
+
+if __name__ == "__main__":
+    main()