flonat-research 0.1.0

package/.scripts/papers

@@ -0,0 +1,227 @@
+#!/usr/bin/env python3
+"""
+View and update research pipeline in Notion.
+
+Usage:
+    papers                              # Show all papers
+    papers --active                     # Show papers in progress
+    papers --update "[Journal]" "R&R"        # Update paper stage
+"""
+
+import argparse
+import json
+import os
+import sys
+import urllib.request
+import urllib.error
+
+
+NOTION_TOKEN = os.environ.get("NOTION_TOKEN")
+DATABASE_ID = "YOUR-PIPELINE-DATABASE-ID-HERE"  # Research Pipeline
+
+STAGES = [
+    "Idea",
+    "Literature Review",
+    "Drafting",
+    "Internal Review",
+    "Submitted",
+    "Under Review",
+    "R&R",
+    "Revising",
+    "Accepted",
+    "Published",
+]
+
+
+def query_papers():
+    """Query papers from Notion."""
+    if not NOTION_TOKEN:
+        print("❌ NOTION_TOKEN not set")
+        sys.exit(1)
+
+    data = {
+        "sorts": [
+            {"property": "Priority", "direction": "ascending"}
+        ]
+    }
+
+    req = urllib.request.Request(
+        f"https://api.notion.com/v1/databases/{DATABASE_ID}/query",
+        data=json.dumps(data).encode("utf-8"),
+        headers={
+            "Authorization": f"Bearer {NOTION_TOKEN}",
+            "Content-Type": "application/json",
+            "Notion-Version": "2022-06-28",
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(req) as response:
+            return json.loads(response.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        error_body = json.loads(e.read().decode("utf-8"))
+        print(f"❌ Error: {e.code}")
+        print(error_body.get("message", str(error_body)))
+        sys.exit(1)
+
+
+def get_property(page, prop_name, prop_type):
+    """Extract property value from a Notion page."""
+    prop = page.get("properties", {}).get(prop_name, {})
+
+    if prop_type == "title":
+        title_list = prop.get("title", [])
+        return title_list[0].get("plain_text", "") if title_list else ""
+    elif prop_type == "select":
+        select = prop.get("select")
+        return select.get("name", "") if select else ""
+    elif prop_type == "status":
+        status = prop.get("status")
+        return status.get("name", "") if status else ""
+    elif prop_type == "rich_text":
+        text_list = prop.get("rich_text", [])
+        return text_list[0].get("plain_text", "") if text_list else ""
+    return ""
+
+
+def update_paper_stage(page_id, new_stage):
+    """Update a paper's stage."""
+    # Note: Stage might be a status or select property
+    data = {
+        "properties": {
+            "Stage": {"status": {"name": new_stage}}
+        }
+    }
+
+    req = urllib.request.Request(
+        f"https://api.notion.com/v1/pages/{page_id}",
+        data=json.dumps(data).encode("utf-8"),
+        headers={
+            "Authorization": f"Bearer {NOTION_TOKEN}",
+            "Content-Type": "application/json",
+            "Notion-Version": "2022-06-28",
+        },
+        method="PATCH",
+    )
+
+    try:
+        with urllib.request.urlopen(req) as response:
+            return True
+    except urllib.error.HTTPError as e:
+        error_body = json.loads(e.read().decode("utf-8"))
+        print(f"❌ Error: {e.code}")
+        print(error_body.get("message", str(error_body)))
+        return False
+
+
+def format_paper(page):
+    """Format a paper for display."""
+    title = get_property(page, "Paper Title", "title")
+    stage = get_property(page, "Stage", "status")
+    journal = get_property(page, "Target Journal", "rich_text")
+    priority = get_property(page, "Priority", "select")
+    uni = get_property(page, "University", "select")
+
+    priority_emoji = {"High": "🔴", "Medium": "🟡", "Low": "🟢"}.get(priority, "⚪")
+
+    stage_emoji = {
+        "Idea": "💡",
+        "Literature Review": "📚",
+        "Drafting": "✍️",
+        "Internal Review": "👀",
+        "Submitted": "📤",
+        "Under Review": "⏳",
+        "R&R": "🔄",
+        "Revising": "✍️",
+        "Accepted": "✅",
+        "Published": "🎉",
+    }.get(stage, "📄")
+
+    line = f"{priority_emoji} {stage_emoji} {title}"
+    if stage:
+        line += f" [{stage}]"
+    if journal:
+        line += f" → {journal}"
+
+    return line
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Research pipeline manager")
+    parser.add_argument("--active", action="store_true", help="Show only active papers")
+    parser.add_argument("--update", nargs=2, metavar=("SEARCH", "STAGE"), help="Update paper stage")
+    parser.add_argument("--stages", action="store_true", help="List available stages")
+
+    args = parser.parse_args()
+
+    if args.stages:
+        print("Available stages:")
+        for s in STAGES:
+            print(f"  - {s}")
+        return
+
+    if args.update:
+        search_term, new_stage = args.update
+
+        # Validate stage
+        if new_stage not in STAGES:
+            print(f"❌ Invalid stage: {new_stage}")
+            print(f"Valid stages: {', '.join(STAGES)}")
+            return
+
+        result = query_papers()
+        pages = result.get("results", [])
+
+        # Find matching paper
+        search_lower = search_term.lower()
+        matches = [p for p in pages if search_lower in get_property(p, "Paper Title", "title").lower()]
+
+        if not matches:
+            print(f"No papers found matching '{search_term}'")
+            return
+
+        if len(matches) == 1:
+            page = matches[0]
+            title = get_property(page, "Paper Title", "title")
+            if update_paper_stage(page["id"], new_stage):
+                print(f"✅ Updated: {title} → {new_stage}")
+        else:
+            print(f"Found {len(matches)} matching papers:")
+            for i, page in enumerate(matches, 1):
+                title = get_property(page, "Paper Title", "title")
+                print(f"{i}. {title}")
+
+            try:
+                choice = input("Which one? (number): ").strip()
+                idx = int(choice) - 1
+                if 0 <= idx < len(matches):
+                    page = matches[idx]
+                    title = get_property(page, "Paper Title", "title")
+                    if update_paper_stage(page["id"], new_stage):
+                        print(f"✅ Updated: {title} → {new_stage}")
+            except (ValueError, KeyboardInterrupt):
+                print("\nCancelled.")
+        return
+
+    # List papers
+    result = query_papers()
+    pages = result.get("results", [])
+
+    if args.active:
+        active_stages = ["Literature Review", "Drafting", "Internal Review", "R&R", "Revising"]
+        pages = [p for p in pages if get_property(p, "Stage", "status") in active_stages]
+
+    if not pages:
+        print("No papers found.")
+        return
+
+    print(f"📚 Research Pipeline ({len(pages)} papers)")
+    print("-" * 50)
+
+    for page in pages:
+        print(format_paper(page))
+
+
+if __name__ == "__main__":
+    main()

package/.scripts/query

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+"""
+Query your task management system from the terminal.
+
+Usage:
+    query "game theory"           # search across files and Notion
+    query --files "keyword"          # search only local context files
+    query --notion "topic"       # search only Notion
+    query --papers "collaboration" # search Research Pipeline
+    query --tasks "meeting"       # search Tasks Tracker
+"""
+
+import argparse
+import json
+import os
+import sys
+import urllib.request
+import urllib.error
+from pathlib import Path
+
+NOTION_TOKEN = os.environ.get("NOTION_TOKEN")
+BASE_DIR = Path(__file__).resolve().parent.parent
+CONTEXT_PATH = BASE_DIR / ".context"
+
+# Database IDs
+TASKS_DB = "f8e5b15d28db4e2bb430b5fbc580f7eb"
+PAPERS_DB = "YOUR-PIPELINE-DATABASE-ID-HERE"
+CONFERENCES_DB = "YOUR-CONFERENCES-DATABASE-ID-HERE"
+
+
+def search_files(query):
+    """Search local context files for a query."""
+    results = []
+    query_lower = query.lower()
+
+    if not CONTEXT_PATH.exists():
+        return results
+
+    for file_path in CONTEXT_PATH.rglob("*.md"):
+        try:
+            content = file_path.read_text()
+            if query_lower in content.lower():
+                # Find matching lines
+                lines = content.split("\n")
+                matches = []
+                for i, line in enumerate(lines):
+                    if query_lower in line.lower():
+                        matches.append((i + 1, line.strip()))
+
+                results.append({
+                    "file": str(file_path.relative_to(CONTEXT_PATH)),
+                    "matches": matches[:5]  # Limit to 5 matches per file
+                })
+        except Exception:
+            pass
+
+    return results
+
+
+def search_notion(query, database_id=None):
+    """Search Notion for a query."""
+    if not NOTION_TOKEN:
+        return {"error": "NOTION_TOKEN not set"}
+
+    # Use Notion search API
+    data = {
+        "query": query,
+        "page_size": 10
+    }
+
+    if database_id:
+        data["filter"] = {"property": "object", "value": "page"}
+
+    req = urllib.request.Request(
+        "https://api.notion.com/v1/search",
+        data=json.dumps(data).encode("utf-8"),
+        headers={
+            "Authorization": f"Bearer {NOTION_TOKEN}",
+            "Content-Type": "application/json",
+            "Notion-Version": "2022-06-28",
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(req) as response:
+            result = json.loads(response.read().decode("utf-8"))
+            pages = []
+            for page in result.get("results", []):
+                title = ""
+                props = page.get("properties", {})
+
+                # Try to find title property
+                for prop_name, prop_value in props.items():
+                    if prop_value.get("type") == "title":
+                        title_list = prop_value.get("title", [])
+                        if title_list:
+                            title = title_list[0].get("plain_text", "")
+                        break
+
+                if not title:
+                    title = page.get("url", "Untitled")
+
+                pages.append({
+                    "title": title,
+                    "url": page.get("url", ""),
+                    "type": page.get("object", "page"),
+                    "parent": page.get("parent", {}).get("type", "")
+                })
+
+            return {"pages": pages}
+    except urllib.error.HTTPError as e:
+        return {"error": f"Notion API error: {e.code}"}
+
+
+def query_database(database_id, title_property="Name"):
+    """Query a specific Notion database."""
+    if not NOTION_TOKEN:
+        return {"error": "NOTION_TOKEN not set"}
+
+    req = urllib.request.Request(
+        f"https://api.notion.com/v1/databases/{database_id}/query",
+        data=json.dumps({"page_size": 100}).encode("utf-8"),
+        headers={
+            "Authorization": f"Bearer {NOTION_TOKEN}",
+            "Content-Type": "application/json",
+            "Notion-Version": "2022-06-28",
+        },
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(req) as response:
+            return json.loads(response.read().decode("utf-8"))
+    except urllib.error.HTTPError as e:
+        return {"error": f"Notion API error: {e.code}"}
+
+
+def print_file_results(results, query):
+    """Print file search results."""
+    if not results:
+        print(f"  No matches in context files")
+        return
+
+    for result in results:
+        print(f"\n  📄 {result['file']}")
+        for line_num, line in result['matches']:
+            # Highlight the query in the line
+            print(f"     L{line_num}: {line[:80]}{'...' if len(line) > 80 else ''}")
+
+
+def print_notion_results(results):
+    """Print Notion search results."""
+    if "error" in results:
+        print(f"  ❌ {results['error']}")
+        return
+
+    pages = results.get("pages", [])
+    if not pages:
+        print(f"  No matches in Notion")
+        return
+
+    for page in pages:
+        print(f"\n  📝 {page['title']}")
+        print(f"     {page['url']}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Query your task management system")
+    parser.add_argument("query", nargs="?", help="Search query")
+    parser.add_argument("--files", action="store_true", help="Search only local files")
+    parser.add_argument("--notion", action="store_true", help="Search only Notion")
+    parser.add_argument("--papers", action="store_true", help="Search Research Pipeline")
+    parser.add_argument("--tasks", action="store_true", help="Search Tasks Tracker")
+    parser.add_argument("--conferences", action="store_true", help="Search Conferences")
+
+    args = parser.parse_args()
+
+    if not args.query:
+        parser.print_help()
+        return
+
+    query = args.query
+    print(f"🔍 Searching for: \"{query}\"")
+    print("=" * 50)
+
+    # Determine what to search
+    search_all = not (args.files or args.notion or args.papers or args.tasks or args.conferences)
+
+    # Search local files
+    if args.files or search_all:
+        print("\n📁 Context Files:")
+        file_results = search_files(query)
+        print_file_results(file_results, query)
+
+    # Search Notion
+    if args.notion or search_all:
+        print("\n☁️  Notion:")
+        notion_results = search_notion(query)
+        print_notion_results(notion_results)
+
+    # Search specific databases
+    if args.papers:
+        print("\n📚 Research Pipeline:")
+        notion_results = search_notion(query)
+        # Filter to only show papers
+        print_notion_results(notion_results)
+
+    if args.tasks:
+        print("\n✅ Tasks:")
+        notion_results = search_notion(query)
+        print_notion_results(notion_results)
+
+    if args.conferences:
+        print("\n📅 Conferences:")
+        notion_results = search_notion(query)
+        print_notion_results(notion_results)
+
+    print()
+
+
+if __name__ == "__main__":
+    main()

package/.scripts/session-history.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python3
+"""Query session history from skill-outcomes.jsonl via SQLite.
+
+Indexes the JSONL file into an in-memory SQLite database for fast queries.
+The DB is rebuilt on each invocation (the source file is small).
+
+Usage:
+    uv run python .scripts/session-history.py                    # show all
+    uv run python .scripts/session-history.py --skill proofread  # filter by skill
+    uv run python .scripts/session-history.py --project Task-Management
+    uv run python .scripts/session-history.py --since 2026-03-15
+    uv run python .scripts/session-history.py --outcome error
+    uv run python .scripts/session-history.py --stats            # summary stats
+    uv run python .scripts/session-history.py --top-skills       # most-used skills
+    uv run python .scripts/session-history.py --by-project       # breakdown by project
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sqlite3
+import sys
+from datetime import datetime
+from pathlib import Path
+
+
+JSONL_PATH = Path.home() / ".claude" / "ecc" / "skill-outcomes.jsonl"
+
+
+def load_db() -> sqlite3.Connection:
+    """Load JSONL into an in-memory SQLite database."""
+    conn = sqlite3.connect(":memory:")
+    conn.row_factory = sqlite3.Row
+    conn.execute("""
+        CREATE TABLE outcomes (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            skill TEXT NOT NULL,
+            timestamp TEXT NOT NULL,
+            outcome TEXT NOT NULL,
+            session TEXT,
+            project TEXT,
+            note TEXT
+        )
+    """)
+    conn.execute("CREATE INDEX idx_skill ON outcomes(skill)")
+    conn.execute("CREATE INDEX idx_project ON outcomes(project)")
+    conn.execute("CREATE INDEX idx_timestamp ON outcomes(timestamp)")
+    conn.execute("CREATE INDEX idx_outcome ON outcomes(outcome)")
+
+    if not JSONL_PATH.exists():
+        print(f"No history file at {JSONL_PATH}", file=sys.stderr)
+        return conn
+
+    with open(JSONL_PATH) as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                row = json.loads(line)
+                conn.execute(
+                    "INSERT INTO outcomes (skill, timestamp, outcome, session, project, note) VALUES (?, ?, ?, ?, ?, ?)",
+                    (
+                        row.get("skill", ""),
+                        row.get("timestamp", ""),
+                        row.get("outcome", ""),
+                        row.get("session", ""),
+                        row.get("project", ""),
+                        row.get("note", ""),
+                    ),
+                )
+            except (json.JSONDecodeError, KeyError):
+                continue
+    conn.commit()
+    return conn
+
+
+def fmt_table(rows: list[sqlite3.Row], columns: list[str]) -> str:
+    """Format rows as a simple table."""
+    if not rows:
+        return "No results."
+
+    widths = [len(c) for c in columns]
+    str_rows = []
+    for row in rows:
+        vals = [str(row[c] or "") for c in columns]
+        str_rows.append(vals)
+        for i, v in enumerate(vals):
+            widths[i] = max(widths[i], len(v))
+
+    header = "  ".join(c.ljust(widths[i]) for i, c in enumerate(columns))
+    sep = "  ".join("-" * widths[i] for i in range(len(columns)))
+    lines = [header, sep]
+    for vals in str_rows:
+        lines.append("  ".join(vals[i].ljust(widths[i]) for i in range(len(columns))))
+    return "\n".join(lines)
+
+
+def cmd_list(conn: sqlite3.Connection, args: argparse.Namespace) -> None:
+    """List outcomes with optional filters."""
+    clauses = []
+    params: list[str] = []
+
+    if args.skill:
+        clauses.append("skill LIKE ?")
+        params.append(f"%{args.skill}%")
+    if args.project:
+        clauses.append("project LIKE ?")
+        params.append(f"%{args.project}%")
+    if args.outcome:
+        clauses.append("outcome = ?")
+        params.append(args.outcome)
+    if args.since:
+        clauses.append("timestamp >= ?")
+        params.append(args.since)
+
+    where = f"WHERE {' AND '.join(clauses)}" if clauses else ""
+    query = f"SELECT timestamp, skill, project, outcome, note FROM outcomes {where} ORDER BY timestamp DESC"
+
+    if args.limit:
+        query += f" LIMIT {args.limit}"
+
+    rows = conn.execute(query, params).fetchall()
+    print(fmt_table(rows, ["timestamp", "skill", "project", "outcome", "note"]))
+
+
+def cmd_stats(conn: sqlite3.Connection, _args: argparse.Namespace) -> None:
+    """Show summary statistics."""
+    total = conn.execute("SELECT COUNT(*) as n FROM outcomes").fetchone()["n"]
+    success = conn.execute("SELECT COUNT(*) as n FROM outcomes WHERE outcome='success'").fetchone()["n"]
+    error = conn.execute("SELECT COUNT(*) as n FROM outcomes WHERE outcome='error'").fetchone()["n"]
+    partial = conn.execute("SELECT COUNT(*) as n FROM outcomes WHERE outcome='partial'").fetchone()["n"]
+    skills = conn.execute("SELECT COUNT(DISTINCT skill) as n FROM outcomes").fetchone()["n"]
+    projects = conn.execute("SELECT COUNT(DISTINCT project) as n FROM outcomes WHERE project != ''").fetchone()["n"]
+
+    first = conn.execute("SELECT MIN(timestamp) as t FROM outcomes").fetchone()["t"]
+    last = conn.execute("SELECT MAX(timestamp) as t FROM outcomes").fetchone()["t"]
+
+    print(f"Total invocations:  {total}")
+    print(f"Unique skills:      {skills}")
+    print(f"Unique projects:    {projects}")
+    print(f"Success:            {success} ({100*success//max(total,1)}%)")
+    print(f"Error:              {error} ({100*error//max(total,1)}%)")
+    print(f"Partial:            {partial} ({100*partial//max(total,1)}%)")
+    print(f"First recorded:     {first or 'N/A'}")
+    print(f"Last recorded:      {last or 'N/A'}")
+
+
+def cmd_top_skills(conn: sqlite3.Connection, args: argparse.Namespace) -> None:
+    """Show most-used skills."""
+    limit = args.limit or 20
+    rows = conn.execute(
+        """SELECT skill,
+                  COUNT(*) as invocations,
+                  SUM(CASE WHEN outcome='success' THEN 1 ELSE 0 END) as ok,
+                  SUM(CASE WHEN outcome='error' THEN 1 ELSE 0 END) as err
+           FROM outcomes GROUP BY skill ORDER BY invocations DESC LIMIT ?""",
+        (limit,),
+    ).fetchall()
+    print(fmt_table(rows, ["skill", "invocations", "ok", "err"]))
+
+
+def cmd_by_project(conn: sqlite3.Connection, _args: argparse.Namespace) -> None:
+    """Show breakdown by project."""
+    rows = conn.execute(
+        """SELECT project,
+                  COUNT(*) as invocations,
+                  COUNT(DISTINCT skill) as skills_used,
+                  MAX(timestamp) as last_activity
+           FROM outcomes WHERE project != '' GROUP BY project ORDER BY invocations DESC""",
+    ).fetchall()
+    print(fmt_table(rows, ["project", "invocations", "skills_used", "last_activity"]))
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="Query session history")
+    parser.add_argument("--skill", help="Filter by skill name (substring match)")
+    parser.add_argument("--project", help="Filter by project name (substring match)")
+    parser.add_argument("--outcome", choices=["success", "error", "partial"], help="Filter by outcome")
+    parser.add_argument("--since", help="Show entries since date (ISO format, e.g. 2026-03-15)")
+    parser.add_argument("--limit", type=int, help="Max rows to show")
+    parser.add_argument("--stats", action="store_true", help="Show summary statistics")
+    parser.add_argument("--top-skills", action="store_true", help="Show most-used skills")
+    parser.add_argument("--by-project", action="store_true", help="Show breakdown by project")
+    args = parser.parse_args()
+
+    conn = load_db()
+
+    if args.stats:
+        cmd_stats(conn, args)
+    elif args.top_skills:
+        cmd_top_skills(conn, args)
+    elif args.by_project:
+        cmd_by_project(conn, args)
+    else:
+        cmd_list(conn, args)
+
+
+if __name__ == "__main__":
+    main()