loreconvo 0.3.0__py3-none-any.whl

hooks/scripts/auto_load.py

@@ -0,0 +1,307 @@
+"""LoreConvo SessionStart auto-load hook.
+
+Receives session metadata via stdin JSON from Claude Code's SessionStart hook.
+Queries the LoreConvo SQLite database for recent sessions matching the current
+working directory (project), then outputs a context summary to stdout.
+
+Claude Code injects stdout content into the session as system context.
+Designed to run within the hook timeout window.
+
+Scoring logic (higher = shown first):
+  +3  session has open questions (most actionable context)
+  +2  session has >= 2 decisions
+  +1  session has artifacts
+  +2  started within last 24 hours
+  +1  started within last 3 days
+  -2  no summary, no decisions, no open questions, no artifacts (noise)
+
+Sessions that score <= 0 and are not the only results are filtered out.
+Total formatted context is capped at MAX_CONTEXT_CHARS to avoid bloat.
+"""
+
+import json
+import os
+import sys
+import sqlite3
+from datetime import datetime, timedelta
+from pathlib import Path
+
+
+MAX_CONTEXT_CHARS = 4000  # Soft cap on total output length
+
+
+def get_db_path():
+    """Get database path, matching core/config.py logic."""
+    return os.environ.get("LORECONVO_DB", os.path.expanduser("~/.loreconvo/sessions.db"))
+
+
+def score_session(session, now):
+    """Compute a signal quality score for a session dict.
+
+    Higher scores = more actionable context for the incoming session.
+    """
+    score = 0
+
+    # Open questions are highest signal -- unanswered items the user may continue
+    open_q_raw = session.get("open_questions", "[]")
+    try:
+        open_questions = json.loads(open_q_raw) if isinstance(open_q_raw, str) else (open_q_raw or [])
+    except (json.JSONDecodeError, TypeError):
+        open_questions = []
+    if open_questions:
+        score += 3
+
+    # Decisions (>= 2 means a substantive work session)
+    decisions_raw = session.get("decisions", "[]")
+    try:
+        decisions = json.loads(decisions_raw) if isinstance(decisions_raw, str) else (decisions_raw or [])
+    except (json.JSONDecodeError, TypeError):
+        decisions = []
+    if len(decisions) >= 2:
+        score += 2
+    elif len(decisions) == 1:
+        score += 1
+
+    # Artifacts indicate something was produced
+    artifacts_raw = session.get("artifacts", "[]")
+    try:
+        artifacts = json.loads(artifacts_raw) if isinstance(artifacts_raw, str) else (artifacts_raw or [])
+    except (json.JSONDecodeError, TypeError):
+        artifacts = []
+    if artifacts:
+        score += 1
+
+    # Recency bonus
+    start_raw = session.get("start_date", "")
+    if start_raw:
+        try:
+            start_dt = datetime.fromisoformat(start_raw)
+            age = now - start_dt
+            if age <= timedelta(hours=24):
+                score += 2
+            elif age <= timedelta(days=3):
+                score += 1
+        except (ValueError, TypeError):
+            pass
+
+    # Noise penalty: short/empty sessions add clutter
+    summary = session.get("summary", "") or ""
+    if not summary and not decisions and not open_questions and not artifacts:
+        score -= 2
+
+    return score
+
+
+def query_recent_sessions(db_path, cwd, days_back=14, limit=10):
+    """Query LoreConvo for recent sessions, optionally filtered by project/cwd.
+
+    Fetches a wider window than the old hook (days_back=14, limit=10) so the
+    scoring pass has enough candidates to work with.  The caller then scores,
+    filters, and caps before formatting.
+
+    Returns a list of session dicts.
+    """
+    if not os.path.exists(db_path):
+        return []
+
+    conn = sqlite3.connect(db_path)
+    conn.row_factory = sqlite3.Row
+    try:
+        cutoff = (datetime.now() - timedelta(days=days_back)).isoformat()
+
+        sessions = []
+
+        if cwd:
+            cursor = conn.execute(
+                """SELECT id, title, summary, decisions, artifacts,
+                          open_questions, tags, start_date, end_date
+                   FROM sessions
+                   WHERE project LIKE ?
+                     AND start_date >= ?
+                   ORDER BY start_date DESC
+                   LIMIT ?""",
+                (f"%{cwd}%", cutoff, limit),
+            )
+            sessions = [dict(row) for row in cursor.fetchall()]
+
+        # Fall back to most recent across all projects if no project matches
+        if not sessions:
+            cursor = conn.execute(
+                """SELECT id, title, summary, decisions, artifacts,
+                          open_questions, tags, start_date, end_date
+                   FROM sessions
+                   ORDER BY start_date DESC
+                   LIMIT ?""",
+                (limit,),
+            )
+            sessions = [dict(row) for row in cursor.fetchall()]
+
+        return sessions
+
+    except Exception as e:
+        sys.stderr.write(f"LoreConvo auto-load query error: {e}\n")
+        return []
+    finally:
+        conn.close()
+
+
+def select_sessions(sessions, max_count=5):
+    """Score, filter, and rank sessions. Returns up to max_count best ones."""
+    if not sessions:
+        return []
+
+    now = datetime.now()
+    scored = [(score_session(s, now), s) for s in sessions]
+
+    # Sort by score desc, then recency desc for ties
+    scored.sort(key=lambda x: (x[0], x[1].get("start_date", "")), reverse=True)
+
+    # Filter out noise sessions as long as we still have enough good ones
+    good = [(sc, s) for sc, s in scored if sc > 0]
+    if not good:
+        # All sessions scored <= 0 -- keep top few rather than returning nothing
+        good = scored[:max_count]
+
+    return [s for _, s in good[:max_count]]
+
+
+def format_context(sessions, cwd):
+    """Format session data into a concise context block for Claude.
+
+    Output is plain text that Claude Code injects into the session.
+    Includes open_questions (missing from old version) as they are highest-signal.
+    Enforces MAX_CONTEXT_CHARS soft cap to prevent system prompt bloat.
+    """
+    if not sessions:
+        return ""
+
+    lines = []
+    lines.append("# LoreConvo: Recent Session Context")
+    lines.append("")
+
+    if cwd:
+        project_name = os.path.basename(cwd) if cwd else "unknown"
+        lines.append(f"Recent sessions for project: {project_name}")
+    else:
+        lines.append("Recent sessions (no project filter):")
+    lines.append("")
+
+    total_chars = sum(len(l) for l in lines)
+
+    for i, session in enumerate(sessions, 1):
+        block = []
+        title = session.get("title") or "Untitled"
+        start = session.get("start_date", "")
+
+        date_str = ""
+        if start:
+            try:
+                dt = datetime.fromisoformat(start)
+                date_str = dt.strftime("%b %d, %Y %I:%M %p")
+            except (ValueError, TypeError):
+                date_str = start[:19] if start else ""
+
+        block.append(f"## Session {i}: {title}")
+        if date_str:
+            block.append(f"Date: {date_str}")
+
+        # Summary (truncated)
+        summary = session.get("summary") or ""
+        if summary:
+            truncated = summary[:400]
+            if len(summary) > 400:
+                truncated += "..."
+            block.append(f"Summary: {truncated}")
+
+        # Open questions -- highest signal, always include when present
+        open_q_raw = session.get("open_questions", "[]")
+        try:
+            open_questions = json.loads(open_q_raw) if isinstance(open_q_raw, str) else (open_q_raw or [])
+        except (json.JSONDecodeError, TypeError):
+            open_questions = []
+        if open_questions:
+            block.append("Open questions:")
+            for q in open_questions[:4]:
+                block.append(f"  ? {q}")
+
+        # Decisions
+        decisions_raw = session.get("decisions", "[]")
+        try:
+            decisions = json.loads(decisions_raw) if isinstance(decisions_raw, str) else (decisions_raw or [])
+        except (json.JSONDecodeError, TypeError):
+            decisions = []
+        if decisions:
+            block.append("Key decisions:")
+            for d in decisions[:4]:
+                block.append(f"  - {d}")
+
+        # Artifacts
+        artifacts_raw = session.get("artifacts", "[]")
+        try:
+            artifacts = json.loads(artifacts_raw) if isinstance(artifacts_raw, str) else (artifacts_raw or [])
+        except (json.JSONDecodeError, TypeError):
+            artifacts = []
+        if artifacts:
+            block.append("Artifacts: " + ", ".join(artifacts[:5]))
+
+        block.append("")
+
+        block_chars = sum(len(l) for l in block)
+        if total_chars + block_chars > MAX_CONTEXT_CHARS and i > 1:
+            # Soft cap reached -- stop adding more sessions
+            break
+
+        lines.extend(block)
+        total_chars += block_chars
+
+    lines.append("---")
+    lines.append("Use this context to avoid re-asking questions or repeating work from prior sessions.")
+    lines.append("If a prior session is directly relevant, query LoreConvo MCP tools for full details.")
+
+    return "\n".join(lines)
+
+
+def main():
+    """Main entry point for SessionStart hook."""
+    try:
+        stdin_data = sys.stdin.read()
+        if not stdin_data:
+            sys.exit(0)
+
+        hook_input = json.loads(stdin_data)
+        session_id = hook_input.get("session_id", "unknown")
+        cwd = hook_input.get("cwd", "")
+
+        db_path = get_db_path()
+
+        days_back = int(os.environ.get("LORECONVO_DAYS_BACK", "14"))
+        limit = int(os.environ.get("LORECONVO_LIMIT", "10"))
+        max_count = int(os.environ.get("LORECONVO_MAX_SESSIONS", "5"))
+
+        raw_sessions = query_recent_sessions(db_path, cwd, days_back=days_back, limit=limit)
+
+        if not raw_sessions:
+            sys.stderr.write(
+                f"LoreConvo auto-load: No recent sessions found for {cwd or 'any project'}\n"
+            )
+            sys.exit(0)
+
+        sessions = select_sessions(raw_sessions, max_count=max_count)
+
+        context = format_context(sessions, cwd)
+        if context:
+            print(context)
+            sys.stderr.write(
+                f"LoreConvo auto-load: Injected context from {len(sessions)} session(s) "
+                f"(scored from {len(raw_sessions)} candidates) for session {session_id}\n"
+            )
+
+    except json.JSONDecodeError:
+        sys.exit(0)
+    except Exception as e:
+        sys.stderr.write(f"LoreConvo auto-load error: {e}\n")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

hooks/scripts/auto_save.py

@@ -0,0 +1,301 @@
+"""LoreConvo SessionEnd auto-save hook.
+
+Receives session metadata via stdin JSON from Claude Code's SessionEnd hook.
+Parses the transcript JSONL to extract a summary, then saves directly to SQLite.
+
+Designed to run within the 3-5 second timeout window.
+"""
+
+import json
+import os
+import sys
+import sqlite3
+import uuid
+from datetime import datetime
+from pathlib import Path
+
+
+def get_db_path():
+    """Get database path, matching core/config.py logic."""
+    return os.environ.get("LORECONVO_DB", os.path.expanduser("~/.loreconvo/sessions.db"))
+
+
+def parse_transcript(transcript_path):
+    """Parse a Claude Code JSONL transcript into structured session data.
+
+    Extracts: title (from first user message), surface, summary of key exchanges,
+    decisions (lines starting with decision-like language), and artifacts.
+    """
+    if not transcript_path or not os.path.exists(transcript_path):
+        return None
+
+    messages = []
+    try:
+        with open(transcript_path, "r") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    entry = json.loads(line)
+                    messages.append(entry)
+                except json.JSONDecodeError:
+                    continue
+    except (IOError, PermissionError):
+        return None
+
+    if not messages:
+        return None
+
+    # Extract user and assistant messages
+    user_messages = []
+    assistant_messages = []
+    tool_uses = []
+
+    for msg in messages:
+        # Real Claude Code transcripts wrap messages: {"type":"user", "message": {"role":..., "content":...}}
+        inner = msg.get("message", msg)
+        role = inner.get("role", "") if isinstance(inner, dict) else msg.get("role", "")
+        content = inner.get("content", "") if isinstance(inner, dict) else msg.get("content", "")
+
+        # Handle content that's a list of blocks
+        if isinstance(content, list):
+            text_parts = []
+            for block in content:
+                if isinstance(block, dict):
+                    if block.get("type") == "text":
+                        text_parts.append(block.get("text", ""))
+                    elif block.get("type") == "tool_use":
+                        tool_name = block.get("name", "unknown")
+                        if tool_name == "Skill":
+                            # Extract the actual skill name from the input parameter
+                            # so skill-history shows e.g. "skill:langgraph-finance-workflow"
+                            # instead of the raw string "Skill"
+                            input_val = block.get("input") or {}
+                            skill_name = input_val.get("skill") if isinstance(input_val, dict) else None
+                            if skill_name:
+                                tool_uses.append(f"skill:{skill_name}")
+                            else:
+                                tool_uses.append("Skill")
+                        else:
+                            tool_uses.append(tool_name)
+                elif isinstance(block, str):
+                    text_parts.append(block)
+            content = " ".join(text_parts)
+
+        if role == "user" and content:
+            user_messages.append(content[:500])  # Truncate long messages
+        elif role == "assistant" and content:
+            assistant_messages.append(content[:500])
+
+    if not user_messages:
+        return None
+
+    # Title: first user message, truncated
+    first_msg = user_messages[0]
+    title = first_msg[:80].replace("\n", " ").strip()
+    if len(first_msg) > 80:
+        title += "..."
+
+    # Summary: combine first few exchanges
+    summary_parts = []
+    for i, msg in enumerate(user_messages[:3]):
+        summary_parts.append(f"User: {msg[:200]}")
+        if i < len(assistant_messages):
+            summary_parts.append(f"Assistant: {assistant_messages[i][:200]}")
+    summary = "\n".join(summary_parts)
+
+    # Truncate summary to reasonable length
+    if len(summary) > 2000:
+        summary = summary[:2000] + "..."
+
+    # Detect decisions (simple heuristic)
+    decisions = []
+    decision_keywords = ["decided", "agreed", "confirmed", "chose", "will use", "going with", "settled on"]
+    for msg in assistant_messages:
+        msg_lower = msg.lower()
+        for keyword in decision_keywords:
+            if keyword in msg_lower:
+                # Extract the sentence containing the keyword
+                for sentence in msg.split("."):
+                    if keyword in sentence.lower():
+                        clean = sentence.strip()
+                        if clean and len(clean) > 10:
+                            decisions.append(clean[:200])
+                break
+
+    # Detect artifacts (file paths, URLs)
+    artifacts = []
+    for msg in assistant_messages:
+        # Look for file paths
+        for word in msg.split():
+            if "/" in word and ("." in word.split("/")[-1]) and len(word) > 5:
+                clean = word.strip("(),\"'`")
+                if clean not in artifacts and len(artifacts) < 10:
+                    artifacts.append(clean)
+
+    # Unique tools used
+    unique_tools = list(set(tool_uses))[:20]
+
+    return {
+        "title": title,
+        "summary": summary,
+        "decisions": decisions[:10],
+        "artifacts": artifacts[:10],
+        "tools_used": unique_tools,
+        "message_count": len(user_messages) + len(assistant_messages),
+    }
+
+
+def ensure_tables(conn):
+    """Create tables if they don't exist (matches core/database.py schema)."""
+    conn.executescript("""
+        CREATE TABLE IF NOT EXISTS sessions (
+            id TEXT PRIMARY KEY NOT NULL,
+            title TEXT NOT NULL,
+            surface TEXT NOT NULL,
+            project TEXT,
+            summary TEXT,
+            decisions TEXT DEFAULT '[]',
+            artifacts TEXT DEFAULT '[]',
+            open_questions TEXT DEFAULT '[]',
+            tags TEXT DEFAULT '[]',
+            start_date TEXT,
+            end_date TEXT,
+            created_at TEXT DEFAULT (datetime('now')),
+            updated_at TEXT DEFAULT (datetime('now'))
+        );
+        CREATE TABLE IF NOT EXISTS session_skills (
+            session_id TEXT NOT NULL,
+            skill_name TEXT NOT NULL,
+            FOREIGN KEY (session_id) REFERENCES sessions(id),
+            UNIQUE(session_id, skill_name)
+        );
+        CREATE VIRTUAL TABLE IF NOT EXISTS sessions_fts USING fts5(
+            title, summary, decisions, content=sessions, content_rowid=rowid
+        );
+    """)
+
+
+def save_to_db(db_path, session_id, parsed):
+    """Save parsed session data directly to SQLite."""
+    os.makedirs(os.path.dirname(db_path), exist_ok=True)
+
+    conn = sqlite3.connect(db_path)
+    try:
+        ensure_tables(conn)
+
+        # Use Claude's session_id as our primary key so dedup actually works.
+        # Previous bug: generated a random UUID for id but checked WHERE id = session_id,
+        # so the duplicate guard never matched anything.
+        session_uuid = session_id
+
+        # Check if session already exists (e.g., resumed session or duplicate hook fire)
+        cursor = conn.execute("SELECT id FROM sessions WHERE id = ?", (session_uuid,))
+        if cursor.fetchone():
+            # Already saved -- update instead of duplicate
+            now = datetime.now().isoformat()
+            conn.execute(
+                """UPDATE sessions SET summary = ?, decisions = ?, artifacts = ?,
+                   tags = ?, end_date = ?, updated_at = ?
+                   WHERE id = ?""",
+                (
+                    parsed["summary"],
+                    json.dumps(parsed["decisions"]),
+                    json.dumps(parsed["artifacts"]),
+                    json.dumps(["auto-saved"]),
+                    now,
+                    now,
+                    session_uuid,
+                ),
+            )
+            conn.commit()
+            return True  # Updated existing record
+
+        now = datetime.now().isoformat()
+
+        conn.execute(
+            """INSERT INTO sessions (id, title, surface, summary, decisions, artifacts,
+               open_questions, tags, start_date, end_date)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            (
+                session_uuid,
+                parsed["title"],
+                "code",
+                parsed["summary"],
+                json.dumps(parsed["decisions"]),
+                json.dumps(parsed["artifacts"]),
+                json.dumps([]),
+                json.dumps(["auto-saved"]),
+                now,
+                now,
+            ),
+        )
+
+        # Update FTS index
+        try:
+            conn.execute(
+                """INSERT INTO sessions_fts(rowid, title, summary, decisions)
+                   SELECT rowid, title, summary, decisions
+                   FROM sessions WHERE id = ?""",
+                (session_uuid,),
+            )
+        except sqlite3.OperationalError:
+            pass  # FTS table might not exist in older DBs
+
+        # Save skill/tool usage
+        for tool in parsed.get("tools_used", []):
+            try:
+                conn.execute(
+                    "INSERT INTO session_skills (session_id, skill_name) VALUES (?, ?)",
+                    (session_uuid, tool),
+                )
+            except sqlite3.IntegrityError:
+                pass
+
+        conn.commit()
+        return True
+    except Exception as e:
+        sys.stderr.write(f"LoreConvo auto-save DB error: {e}\n")
+        return False
+    finally:
+        conn.close()
+
+
+def main():
+    """Main entry point for SessionEnd hook."""
+    try:
+        # Read hook input from stdin
+        stdin_data = sys.stdin.read()
+        if not stdin_data:
+            sys.exit(0)
+
+        hook_input = json.loads(stdin_data)
+        session_id = hook_input.get("session_id", "unknown")
+        transcript_path = hook_input.get("transcript_path", "")
+
+        # Parse transcript
+        parsed = parse_transcript(transcript_path)
+        if not parsed:
+            sys.exit(0)
+
+        # Skip very short sessions (less than 2 messages)
+        if parsed["message_count"] < 2:
+            sys.exit(0)
+
+        # Save to database
+        db_path = get_db_path()
+        saved = save_to_db(db_path, session_id, parsed)
+
+        if saved:
+            sys.stderr.write(f"LoreConvo: Auto-saved session '{parsed['title']}'\n")
+
+    except json.JSONDecodeError:
+        sys.exit(0)
+    except Exception as e:
+        sys.stderr.write(f"LoreConvo auto-save error: {e}\n")
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

loreconvo-0.3.0.dist-info/LICENSE

@@ -0,0 +1,93 @@
+Business Source License 1.1
+
+Parameters
+
+Licensor:             Labyrinth Analytics Consulting
+Licensed Work:        LoreConvo v0.3.0
+                      The Licensed Work is (c) 2026 Labyrinth Analytics Consulting
+Additional Use Grant: You may make personal, non-commercial use of the Licensed Work,
+                      subject to the following limitation: you may store no more than
+                      50 sessions in total across all databases on your machine. Any
+                      use that exceeds this limit, or any commercial use, requires a
+                      paid license from the Licensor.
+Change Date:          2030-03-31
+Change License:       Apache License, Version 2.0
+
+For information about alternative licensing arrangements for the Licensed Work,
+please contact: info@labyrinthanalyticsconsulting.com
+
+---
+
+Business Source License 1.1
+
+License text copyright (c) 2017 MariaDB Corporation Ab, All Rights Reserved.
+"Business Source License" is a trademark of MariaDB Corporation Ab.
+
+Terms
+
+The Licensor hereby grants you the right to copy, modify, create derivative
+works, redistribute, and make non-production use of the Licensed Work. The
+Licensor may make an Additional Use Grant, above, permitting limited production
+use.
+
+Effective on the Change Date, or the fourth anniversary of the first publicly
+available distribution of a specific version of the Licensed Work under this
+License, whichever comes first, the Licensor hereby grants you rights under
+the terms of the Change License, and the rights granted in the paragraph
+above terminate.
+
+If your use of the Licensed Work does not comply with the requirements
+currently in effect as described in this License, you must purchase a
+commercial license from the Licensor, its affiliated entities, or authorized
+resellers, or you must refrain from using the Licensed Work.
+
+All copies of the original and modified Licensed Work, and derivative works
+of the Licensed Work, are subject to this License. This License applies
+separately for each version of the Licensed Work and the Change Date may vary
+for each version of the Licensed Work released by Licensor.
+
+You must conspicuously display this License on each original or modified copy
+of the Licensed Work. If you receive a copy of the Licensed Work in
+combination with other programs, as part of a larger work, or packaged by a
+third party, and you receive the Licensed Work under a different license from
+the one described in this License, you are required to comply with the license
+applicable to you.
+
+Any use of the Licensed Work in violation of this License will automatically
+terminate your rights under this License for the current and all other
+versions of the Licensed Work.
+
+This License does not grant you any right in any trademark or logo of
+Licensor or its affiliates (provided that you may use a trademark or logo of
+Licensor as expressly required by this License).
+
+TO THE EXTENT PERMITTED BY APPLICABLE LAW, THE LICENSED WORK IS PROVIDED ON
+AN "AS IS" BASIS. LICENSOR HEREBY DISCLAIMS ALL WARRANTIES AND CONDITIONS,
+EXPRESS OR IMPLIED, INCLUDING (WITHOUT LIMITATION) WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, NON-INFRINGEMENT, AND
+TITLE.
+
+MariaDB hereby grants you permission to use this License's text to license
+your works, and to refer to it using the trademark "Business Source License",
+as long as you comply with the Covenants of Licensor below.
+
+Covenants of Licensor
+
+In consideration of the right to use this License's text and the "Business
+Source License" name and trademark, Licensor covenants to MariaDB, and to all
+other recipients of the licensed work to be provided under this License:
+
+1. To specify as the Change License the GPL Version 2.0 or any later version,
+   or a license that is compatible with GPL Version 2.0 or a later version,
+   where "compatible" means that software provided under the Change License can
+   be included in a program with software provided under GPL Version 2.0 or a
+   later version. Licensor may specify additional Change Licenses without
+   limitation.
+
+2. To either: (a) specify an additional grant of rights to use that does not
+   impose any additional restriction on the right granted in this License, as
+   the Additional Use Grant; or (b) insert the text "None".
+
+3. To specify a Change Date.
+
+4. Not to modify this License in any other way.