aidebrief 0.1.0__tar.gz

aidebrief-0.1.0/PKG-INFO

@@ -0,0 +1,64 @@
+Metadata-Version: 2.4
+Name: aidebrief
+Version: 0.1.0
+Summary: Passive AI conversation capture, full-text search, and decision extraction for your local dev environment
+Author-email: Deepan Karthik <deepankarthik@gmail.com>
+License: MIT
+Project-URL: homepage, https://github.com/deepankarthik/aidebrief
+Project-URL: repository, https://github.com/deepankarthik/aidebrief
+Project-URL: changelog, https://github.com/deepankarthik/aidebrief/releases
+Keywords: ai,conversation,search,mcp,sqlite,fts5,copilot,claude,opencode
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Version Control
+Classifier: Topic :: Text Processing :: Indexing
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: mcp>=1.0.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: ruff>=0.4; extra == "test"
+
+# aidebrief
+
+**Passive AI conversation capture + full-text search + decision extraction for your local dev environment.**
+
+Every AI coding conversation — from Copilot, Claude Code, opencode — vanishes the
+moment you close the session. aidebrief captures them automatically, extracts
+engineering decisions, and makes everything searchable in a local SQLite database.
+No cloud, no telemetry, no infrastructure.
+
+## Quick start
+
+```bash
+pip install aidebrief
+aidebrief init
+aidebrief daemon
+aidebrief search "why did we use sqlite instead of postgres"
+```
+
+## How it works
+
+aidebrief runs as a background daemon that monitors hook files dropped by AI
+coding tools. When a conversation completes, it captures the transcript, indexes
+it with FTS5, and extracts structured engineering decisions using regex patterns.
+An MCP server exposes the database via tools that AI agents can call directly.
+
+## Features
+
+- **Capture** — Hooks into Copilot, Claude Code, opencode, and git
+- **Search** — Full-text search across all conversations
+- **Context** — Given your current question, returns the most relevant past sessions
+- **Decisions** — Automatically extracts structured engineering decisions
+- **Contradictions** — Checks if a new proposal conflicts with past decisions
+- **Supervise** — One combined call returning context + decisions + contradictions — designed for AI subagents
+
+## Requirements
+
+Python 3.11+ and `mcp>=1.0.0`. No other dependencies.

aidebrief-0.1.0/README.md

@@ -0,0 +1,37 @@
+# aidebrief
+
+**Passive AI conversation capture + full-text search + decision extraction for your local dev environment.**
+
+Every AI coding conversation — from Copilot, Claude Code, opencode — vanishes the
+moment you close the session. aidebrief captures them automatically, extracts
+engineering decisions, and makes everything searchable in a local SQLite database.
+No cloud, no telemetry, no infrastructure.
+
+## Quick start
+
+```bash
+pip install aidebrief
+aidebrief init
+aidebrief daemon
+aidebrief search "why did we use sqlite instead of postgres"
+```
+
+## How it works
+
+aidebrief runs as a background daemon that monitors hook files dropped by AI
+coding tools. When a conversation completes, it captures the transcript, indexes
+it with FTS5, and extracts structured engineering decisions using regex patterns.
+An MCP server exposes the database via tools that AI agents can call directly.
+
+## Features
+
+- **Capture** — Hooks into Copilot, Claude Code, opencode, and git
+- **Search** — Full-text search across all conversations
+- **Context** — Given your current question, returns the most relevant past sessions
+- **Decisions** — Automatically extracts structured engineering decisions
+- **Contradictions** — Checks if a new proposal conflicts with past decisions
+- **Supervise** — One combined call returning context + decisions + contradictions — designed for AI subagents
+
+## Requirements
+
+Python 3.11+ and `mcp>=1.0.0`. No other dependencies.

aidebrief-0.1.0/aidebrief/__init__.py

@@ -0,0 +1,7 @@
+"""
+aidebrief — Passive AI conversation capture and full-text search.
+
+Captures conversations from Copilot, Claude Code, and opencode into a
+local SQLite database with FTS5 search. Provides an MCP server with
+three tools: capture, search, health.
+"""

aidebrief-0.1.0/aidebrief/__main__.py

@@ -0,0 +1,439 @@
+"""Entry point for `aidebrief` CLI."""
+
+import argparse
+import asyncio
+import json
+import os
+import shutil
+import stat
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+from .capture import Daemon, _ingest_opencode_events, ingest_hook_file
+from .main import main as mcp_main
+from .store import Store, get_default_db_path, get_default_hooks_dir
+
+
+def _get_store(db_path: str | None = None) -> Store:
+    store = Store(db_path or get_default_db_path())
+    store.init()
+    return store
+
+
+def _bold(text: str) -> str:
+    return f"\033[1m{text}\033[0m"
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="aidebrief",
+        description="Passive AI conversation capture + full-text search",
+    )
+    sub = parser.add_subparsers(dest="command")
+
+    sub.add_parser("daemon", help="Run the background capture daemon")
+    sub.add_parser("serve", help="Run the MCP server (stdio)")
+    sub.add_parser("health", help="Check server health")
+
+    init_parser = sub.add_parser("init", help="Install hooks and create database")
+    init_parser.add_argument("--db", help="Path to SQLite database", default="")
+    init_parser.add_argument("--hooks-dir", help="Hook install directory", default="")
+    init_parser.add_argument("--backfill", type=int, default=0,
+                            help="Import last N opencode sessions into the DB")
+
+    capture_parser = sub.add_parser("capture", help="Capture a single hook file")
+    capture_parser.add_argument("file", help="Path to .complete.json hook file")
+
+    search_parser = sub.add_parser("search", help="Search captured conversations")
+    search_parser.add_argument("query", help="Search query")
+    search_parser.add_argument("--limit", type=int, default=10)
+    search_parser.add_argument("--source")
+
+    list_parser = sub.add_parser("list", help="List recent sessions")
+    list_parser.add_argument("--limit", type=int, default=20)
+    list_parser.add_argument("--source")
+
+    context_parser = sub.add_parser("context", help="Retrieve relevant past sessions as context")
+    context_parser.add_argument("query", help="Current prompt or topic to find context for")
+    context_parser.add_argument("--limit", type=int, default=3, help="Max sessions to return")
+    context_parser.add_argument("--source", help="Filter by source")
+    context_parser.add_argument("--file-paths", nargs="*", help="Current files being worked on")
+
+    decisions_parser = sub.add_parser("decisions", help="Search extracted engineering decisions")
+    decisions_parser.add_argument("query", nargs="?", help="Search topic or keyword (omit for all)")
+    decisions_parser.add_argument("--limit", type=int, default=10)
+    decisions_parser.add_argument("--source")
+    decisions_parser.add_argument("--file-paths", nargs="*")
+
+    contradictions_parser = sub.add_parser("contradictions", help="Check for contradictions with past decisions")
+    contradictions_parser.add_argument("query", help="Current prompt or proposal")
+    contradictions_parser.add_argument("--file-paths", nargs="*")
+
+    supervise_parser = sub.add_parser(
+        "supervise",
+        help="Combined context + decisions + contradictions for the current prompt",
+    )
+    supervise_parser.add_argument("query", help="Current user message")
+    supervise_parser.add_argument("--file-paths", nargs="*")
+
+    sub.add_parser("open", help="Open the database in a SQLite browser")
+    sub.add_parser("status", help="Database summary")
+
+    prune_parser = sub.add_parser("prune", help="Delete old sessions with tiered retention")
+    prune_parser.add_argument("--days", type=int, default=30,
+                              help="Sessions older than this many days are candidates (default: 30)")
+    prune_parser.add_argument("--apply", action="store_true",
+                              help="Actually delete (default is dry-run)")
+    prune_parser.add_argument("--include-committed", action="store_true",
+                              help="Also delete committed sessions (default: protected)")
+    prune_parser.add_argument("--keep-last", type=int, default=0,
+                              help="Always keep the N most recent sessions (default: 0)")
+
+    args = parser.parse_args()
+
+    dispatch = {
+        "init": lambda: _do_init(args.db, args.hooks_dir, args.backfill),
+        "capture": lambda: _do_capture(args.file),
+        "search": lambda: _do_search(args.query, args.limit, args.source),
+        "context": lambda: _do_context(args.query, args.limit, args.source, args.file_paths),
+        "decisions": lambda: _do_decisions(args.query, args.limit, args.source, args.file_paths),
+        "contradictions": lambda: _do_contradictions(args.query, args.file_paths),
+        "supervise": lambda: _do_supervise(args.query, args.file_paths),
+        "list": lambda: _do_list(args.limit, args.source),
+        "open": _do_open,
+        "status": _do_status,
+        "prune": lambda: _do_prune(args.days, args.apply, args.include_committed, args.keep_last),
+        "daemon": lambda: Daemon(get_default_db_path()).run(),
+        "serve": lambda: asyncio.run(mcp_main()),
+        "health": _do_health,
+    }
+    handler = dispatch.get(args.command)
+    if handler:
+        handler()
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+
+def _do_init(db: str, hooks_dir: str, backfill: int = 0) -> None:
+    db_path = Path(db or get_default_db_path()).expanduser()
+    hooks_path = Path(hooks_dir or get_default_hooks_dir(str(db_path))).expanduser()
+
+    hooks_path.mkdir(parents=True, exist_ok=True)
+    db_path.parent.mkdir(parents=True, exist_ok=True)
+
+    _init_install_resources(hooks_path)
+    store = _init_create_db_and_workdirs(db_path, hooks_path)
+    _init_backfill(store, hooks_path, db_path, backfill)
+    _init_print_instructions(hooks_path)
+
+
+def _init_install_resources(hooks_path: Path) -> None:
+    resources = Path(__file__).parent.parent.parent / "resources"
+    entries = [
+        ("hooks/aidebrief_hook.py", None),
+        ("hooks/post-commit", None),
+        ("bridge/opencode_bridge.py", None),
+    ]
+    for rel, dst_name in entries:
+        src = resources / rel
+        if not src.exists():
+            continue
+        dst = hooks_path / (dst_name or src.name)
+        shutil.copy2(str(src), str(dst))
+        dst.chmod(dst.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+        print(f"  Hook: {dst}")
+
+
+def _init_create_db_and_workdirs(db_path: Path, hooks_path: Path) -> Store:
+    store = Store(str(db_path))
+    store.init()
+    print(f"  Database: {db_path}")
+
+    for name in ("runs", "commits"):
+        (hooks_path / name).mkdir(parents=True, exist_ok=True)
+        print(f"  {name.capitalize()} dir: {hooks_path / name}")
+
+    return store
+
+
+def _init_backfill(store: Store, hooks_path: Path, db_path: Path, count: int) -> None:
+    if count <= 0:
+        return
+    bridge_script = hooks_path / "opencode_bridge.py"
+    if not bridge_script.exists():
+        return
+    project_flag = []
+    if os.environ.get("AIDEBRIEF_DB"):
+        project_flag = ["--project-dir", str(db_path.parent.parent.resolve())]
+    print(f"\n  Backfilling last {count} opencode sessions...")
+    try:
+        result = subprocess.run(
+            [sys.executable, str(bridge_script), "--backfill", str(count), *project_flag],
+            capture_output=True, text=True, timeout=60,
+        )
+        ingested = _ingest_opencode_events(store, result.stdout)
+        print(f"  Backfilled {ingested} opencode sessions")
+    except Exception as e:
+        print(f"  Backfill error: {e}")
+
+
+def _init_print_instructions(hooks_path: Path) -> None:
+    print()
+    print("aidebrief initialized.")
+    print()
+    print("To enable Copilot hooks, add to ~/.copilot/hooks/<name>.json:")
+    print(json.dumps({
+        "hooks": {
+            "Stop": [{
+                "type": "command",
+                "command": f"python3 {hooks_path / 'aidebrief_hook.py'}",
+                "timeout": 30,
+            }],
+        },
+    }, indent=2))
+    print()
+    print("Then enable: VS Code setting 'chat.useHooks: true'")
+    print()
+    print("To enable post-commit hooks:")
+    print(f"  git config --global core.hooksPath {hooks_path}")
+    print()
+    print("To enable opencode bridge:")
+    print("  aidebrief daemon")
+    print()
+    print("For Claude Code, add to ~/.claude.json:")
+    print(json.dumps({
+        "mcpServers": {
+            "aidebrief": {
+                "command": sys.executable,
+                "args": ["-m", "aidebrief"],
+            },
+        },
+    }, indent=2))
+
+
+def _do_health() -> None:
+    store = _get_store()
+    health = store.health()
+    print(json.dumps(health, indent=2))
+
+
+def _do_capture(file: str) -> None:
+    store = _get_store()
+    result = ingest_hook_file(store, file)
+    print(json.dumps(result, indent=2))
+
+
+def _do_search(query: str, limit: int, source: str | None) -> None:
+    store = _get_store()
+    results = store.search_sessions(query, source=source, limit=limit)
+    print(json.dumps(results, indent=2, default=str))
+
+
+def _do_context(
+    query: str, limit: int, source: str | None, file_paths: list[str] | None,
+) -> None:
+    store = _get_store()
+    sessions = store.get_context(
+        query=query,
+        source=source,
+        max_sessions=limit,
+        file_paths=file_paths or None,
+    )
+
+    if not sessions:
+        print("No relevant past sessions found.")
+        return
+
+    for s in sessions:
+        started = datetime.fromtimestamp(s["started_at"] / 1000).strftime("%b %d %H:%M")
+        print(f"## Session: {s['title']} ({s['source']}, {started})")
+        print(f"  Score: {s['score']:.2f}  "
+              f"(relevance={s['fts_score']:.2f}, "
+              f"recency={s['recency_score']:.2f}, "
+              f"file_overlap={s['file_overlap_score']:.2f})")
+        print()
+        for msg in s["messages"]:
+            if msg["prompt"]:
+                prompt = msg["prompt"][:200]
+                print(f"  User: {prompt}")
+            if msg["response"]:
+                resp = msg["response"][:200]
+                print(f"  Assistant: {resp}")
+            if msg.get("file_paths"):
+                print(f"  Files: {' '.join(msg['file_paths'])}")
+            print()
+        print()
+
+
+def _do_decisions(
+    query: str | None, limit: int, source: str | None, file_paths: list[str] | None,
+) -> None:
+    store = _get_store()
+    results = store.search_decisions(
+        query=query, source=source, file_paths=file_paths or None, limit=limit,
+    )
+    print(json.dumps(results, indent=2, default=str))
+
+
+def _do_contradictions(query: str, file_paths: list[str] | None) -> None:
+    store = _get_store()
+    results = store.check_contradictions(query=query, file_paths=file_paths or None)
+
+    if not results:
+        print("No contradictions found.")
+        return
+
+    print("## Potential Contradictions")
+    for d in results:
+        topic = d.get("topic") or "unknown"
+        print()
+        print(f"### {topic}")
+        print(f"- **Decision:** {d['decision_text']}")
+        if d.get("rationale"):
+            print(f"- **Rationale:** {d['rationale']}")
+        if d.get("related_files"):
+            files = d["related_files"]
+            if isinstance(files, list):
+                print(f"- **Files:** {' '.join(files)}")
+        print(f"- **Session:** {d['session_id'][:12]} ({d['source']})")
+        print(f"- **Status:** {d['status']}")
+
+
+def _do_supervise(query: str, file_paths: list[str] | None) -> None:
+    store = _get_store()
+    result = store.get_supervisory_context(query=query, file_paths=file_paths)
+    print(json.dumps(result, indent=2, default=str))
+
+
+def _do_status() -> None:
+    store = _get_store()
+    s = store.status()
+
+    size_mb = s["db_size_bytes"] / (1024 * 1024)
+    print(f"Database: {s['db_path']} ({size_mb:.1f} MB)")
+    print()
+
+    header = (
+        f"{'Sessions':<10} {'Messages':<10} {'Decisions':<10} "
+        f"{'Committed':<11} {'Uncommitted':<13} {'Pending Extr':<12}"
+    )
+    print(header)
+    print("-" * len(header))
+    print(
+        f"{s['sessions']:<10} {s['messages']:<10} {s['decisions']:<10} "
+        f"{s['committed_sessions']:<11} {s['uncommitted_sessions']:<13} {s['pending_extraction']:<12}"
+    )
+
+    if s["last_session_at"]:
+        dt = datetime.fromtimestamp(s["last_session_at"] / 1000).strftime("%b %d %H:%M")
+        title = (s["last_session_title"] or "")[:60]
+        source = s["last_session_source"] or "?"
+        print()
+        print(f'Last session: "{title}" ({source}, {dt})')
+
+
+def _do_list(limit: int, source: str | None) -> None:
+    store = _get_store()
+    sessions = store.list_sessions(limit=limit, source=source)
+
+    if not sessions:
+        print("No sessions found.")
+        return
+
+    header = f"{'Session':<12} {'Source':<12} {'Msgs':<5} {'Date':<17} {'Title'}"
+    print(header)
+    print("-" * len(header))
+    for s in sessions:
+        sid = s["id"][:12]
+        source_label = s["source"][:12]
+        msgs = s["message_count"]
+        started = datetime.fromtimestamp(s["started_at"] / 1000).strftime("%b %d %H:%M")
+        title = (s["title"] or "")[:60]
+        print(f"{sid:<12} {source_label:<12} {msgs:<5} {started:<17} {title}")
+
+
+def _do_open() -> None:
+    db_path = get_default_db_path()
+    if not os.path.exists(db_path):
+        print(f"Database not found at {db_path}")
+        return
+    print(f"Database: {db_path}")
+    print()
+
+    viewers = [
+        ("sqlite3", [shutil.which("sqlite3"), db_path]),
+        ("sqlitebrowser", [shutil.which("sqlitebrowser"), db_path]),
+        ("datasette", [shutil.which("datasette"), db_path]),
+        ("lazycli", [shutil.which("lazycli"), db_path]),
+    ]
+    viewers = [(name, args) for name, args in viewers if args[0] is not None]
+
+    if not viewers:
+        print("No SQLite viewer found. Install one:")
+        print("  sudo apt install sqlite3           # CLI")
+        print("  npm install -g datasette           # Web UI")
+        print("  sudo apt install sqlitebrowser     # GUI")
+        print()
+        print("Or open it manually:")
+        print(f"  sqlite3 {db_path}")
+        return
+
+    for name, args in viewers:
+        print(f"Opening with {name}...")
+        try:
+            subprocess.run([a for a in args if a is not None], check=True)
+            return
+        except (FileNotFoundError, subprocess.CalledProcessError):
+            continue
+
+    print("Could not open database with any viewer.")
+    print(f"Try: sqlite3 {db_path}")
+
+
+def _do_prune(days: int, apply: bool = False, include_committed: bool = False, keep_last: int = 0) -> None:
+    db_path = get_default_db_path()
+    if not os.path.exists(db_path):
+        print(f"Database not found at {db_path}")
+        return
+    store = _get_store(db_path)
+    dry_run = not apply
+    result = store.prune_sessions(
+        days=days,
+        include_committed=include_committed,
+        keep_last=keep_last,
+        dry_run=dry_run,
+    )
+    c = result["total_candidates"]
+    if c == 0:
+        print(f"No sessions older than {days} days to prune.")
+        return
+
+    label = "Would delete" if dry_run else "Deleted"
+    print(f"  {_bold(label)} {c} session{'s' if c != 1 else ''} older than {days} days:")
+    print(f"    Committed (protected):               {result['committed']:>3}")
+    print(f"    Uncommitted with decisions:           {result['uncommitted_with_decisions']:>3}")
+    print(f"    Uncommitted without decisions:        {result['uncommitted_without_decisions']:>3}")
+
+    if result["oldest_title"]:
+        oldest_dt = datetime.fromtimestamp(result["oldest_started_at"] / 1000, tz=timezone.utc)
+        newest_dt = datetime.fromtimestamp(result["newest_started_at"] / 1000, tz=timezone.utc)
+        print(f"    Oldest: \"{result['oldest_title']}\" ({oldest_dt.strftime('%b %d')})")
+        print(f"    Newest: \"{result['newest_title']}\" ({newest_dt.strftime('%b %d')})")
+
+    if dry_run:
+        print()
+        print(f"  Pass {_bold('--apply')} to delete,"
+              f" or {_bold('--include-committed')} to also delete committed sessions.")
+        if keep_last > 0:
+            print(f"  {_bold(f'--keep-last {keep_last}')} is active"
+                  f" (protecting the {keep_last} most recent sessions).")
+    else:
+        print(f"  Deleted {result['deleted']} session(s).")
+
+
+if __name__ == "__main__":
+    main()