flonat-research 0.1.0

package/.scripts/done

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+Mark a task as complete in Notion.
+
+Usage:
+    done "[Journal] feedback"      # Search and mark matching task as done
+    done --list               # Show recent tasks to mark done
+"""
+
+import argparse
+import json
+import os
+import sys
+import urllib.request
+import urllib.error
+
+
+NOTION_TOKEN = os.environ.get("NOTION_TOKEN")
+DATABASE_ID = "YOUR-TASKS-DATABASE-ID-HERE"
+
+
+def query_tasks(search_term=None):
+    """Query tasks from Notion."""
+    if not NOTION_TOKEN:
+        print("❌ NOTION_TOKEN not set")
+        sys.exit(1)
+
+    data = {
+        "filter": {
+            "property": "Status",
+            "status": {"does_not_equal": "Done"}
+        },
+        "sorts": [
+            {"property": "Due date", "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:
+            result = json.loads(response.read().decode("utf-8"))
+            pages = result.get("results", [])
+
+            if search_term:
+                search_lower = search_term.lower()
+                pages = [p for p in pages if search_lower in get_title(p).lower()]
+
+            return pages
+    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_title(page):
+    """Get task title from page."""
+    title_prop = page.get("properties", {}).get("Task name", {}).get("title", [])
+    return title_prop[0].get("plain_text", "") if title_prop else ""
+
+
+def get_project(page):
+    """Get project from page."""
+    proj = page.get("properties", {}).get("Project", {}).get("select")
+    return proj.get("name", "") if proj else ""
+
+
+def mark_done(page_id):
+    """Mark a task as done."""
+    data = {
+        "properties": {
+            "Status": {"status": {"name": "Done"}}
+        }
+    }
+
+    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 main():
+    parser = argparse.ArgumentParser(description="Mark tasks as done")
+    parser.add_argument("search", nargs="?", help="Search term to find task")
+    parser.add_argument("--list", action="store_true", help="List recent incomplete tasks")
+
+    args = parser.parse_args()
+
+    if args.list:
+        pages = query_tasks()[:15]
+        if not pages:
+            print("No incomplete tasks found.")
+            return
+
+        print("📋 Incomplete Tasks")
+        print("-" * 40)
+        for i, page in enumerate(pages, 1):
+            title = get_title(page)
+            project = get_project(page)
+            line = f"{i:2}. {title}"
+            if project:
+                line += f" [{project}]"
+            print(line)
+        return
+
+    if not args.search:
+        parser.print_help()
+        return
+
+    pages = query_tasks(args.search)
+
+    if not pages:
+        print(f"No tasks found matching '{args.search}'")
+        return
+
+    if len(pages) == 1:
+        page = pages[0]
+        title = get_title(page)
+        if mark_done(page["id"]):
+            print(f"✅ Done: {title}")
+    else:
+        print(f"Found {len(pages)} matching tasks:")
+        print("-" * 40)
+        for i, page in enumerate(pages, 1):
+            title = get_title(page)
+            project = get_project(page)
+            line = f"{i}. {title}"
+            if project:
+                line += f" [{project}]"
+            print(line)
+
+        print()
+        try:
+            choice = input("Which one? (number or 'q' to cancel): ").strip()
+            if choice.lower() == 'q':
+                print("Cancelled.")
+                return
+
+            idx = int(choice) - 1
+            if 0 <= idx < len(pages):
+                page = pages[idx]
+                title = get_title(page)
+                if mark_done(page["id"]):
+                    print(f"✅ Done: {title}")
+            else:
+                print("Invalid choice.")
+        except (ValueError, KeyboardInterrupt):
+            print("\nCancelled.")
+
+
+if __name__ == "__main__":
+    main()

package/.scripts/extract_meeting_actions.py

@@ -0,0 +1,223 @@
+#!/usr/bin/env python3
+"""
+Meeting Action Item Extractor
+
+This script is designed to work with Claude/Cowork to:
+1. Find recent meeting transcripts in Notion (pages starting with @)
+2. Extract action items using pattern matching and AI
+3. Create corresponding tasks in the Tasks Tracker database
+
+Usage with Claude:
+    "Run the meeting action extractor on yesterday's meeting with [Supervisor]"
+
+Manual usage:
+    python extract_meeting_actions.py --date "2026-01-14"
+"""
+
+import argparse
+import re
+from datetime import datetime, timedelta
+from typing import List, Dict, Optional
+from pathlib import Path
+
+from notion_helpers import (
+    extract_action_patterns,
+    parse_deadline_from_text,
+    infer_project_from_context,
+    infer_priority_from_context,
+    format_task_for_notion,
+)
+from config import DATABASES, CONTEXT_DIR
+
+
+def find_meeting_transcripts_query(since_date: Optional[str] = None) -> str:
+    """
+    Generate a search query to find meeting transcripts in Notion.
+
+    Meeting transcripts are pages with titles like "@14 January 2026 14:31"
+    """
+    query = "@ January" if not since_date else f"@{since_date}"
+    return query
+
+
+def parse_meeting_title(title: str) -> Optional[datetime]:
+    """
+    Parse a meeting title like "@14 January 2026 14:31" into a datetime.
+    """
+    # Pattern: @DD Month YYYY HH:MM
+    pattern = r"@(\d{1,2})\s+(\w+)\s+(\d{4})\s+(\d{1,2}):(\d{2})"
+    match = re.match(pattern, title)
+
+    if match:
+        day, month, year, hour, minute = match.groups()
+        month_map = {
+            "january": 1, "february": 2, "march": 3, "april": 4,
+            "may": 5, "june": 6, "july": 7, "august": 8,
+            "september": 9, "october": 10, "november": 11, "december": 12
+        }
+        month_num = month_map.get(month.lower())
+        if month_num:
+            return datetime(int(year), month_num, int(day), int(hour), int(minute))
+
+    return None
+
+
+def identify_meeting_participants(content: str) -> List[str]:
+    """
+    Try to identify who was in the meeting based on content.
+    """
+    # Known names from context
+    known_people = [
+        "[Supervisor]", "[Supervisor]", "[Collaborator]", "[Collaborator]", "[Collaborator]",
+        "Francois", "David", "Toby", "Walter"
+    ]
+
+    found = []
+    content_lower = content.lower()
+
+    for person in known_people:
+        if person.lower() in content_lower:
+            found.append(person)
+
+    return found
+
+
+def extract_actions_from_transcript(
+    content: str,
+    meeting_date: str,
+    participants: List[str] = None
+) -> List[Dict]:
+    """
+    Extract structured action items from meeting transcript content.
+
+    Args:
+        content: The meeting transcript text
+        meeting_date: Date string of the meeting
+        participants: List of people who were in the meeting
+
+    Returns:
+        List of action item dictionaries ready for task creation
+    """
+    # Use pattern matching to find potential actions
+    raw_actions = extract_action_patterns(content)
+
+    # Enrich each action with context
+    enriched_actions = []
+
+    for action in raw_actions:
+        task_text = action["text"]
+
+        # Clean up the task text
+        task_text = task_text.strip()
+        if task_text.endswith((",", ".", ";")):
+            task_text = task_text[:-1]
+
+        # Skip very short or unclear actions
+        if len(task_text) < 5:
+            continue
+
+        # Infer additional context
+        deadline = parse_deadline_from_text(task_text)
+        project = infer_project_from_context(task_text, participants)
+        is_supervisor = any(p in ["[Supervisor]", "[Supervisor]"] for p in (participants or []))
+        priority = infer_priority_from_context(
+            task_text,
+            has_deadline=deadline is not None,
+            is_supervisor_request=is_supervisor and action["type"] == "request"
+        )
+
+        enriched = {
+            "task_name": f"{task_text} - from {meeting_date} meeting",
+            "original_text": action["text"],
+            "deadline": deadline,
+            "project": project,
+            "priority": priority,
+            "source": "Meeting",
+            "meeting_date": meeting_date,
+            "participants": participants or [],
+            "action_type": action["type"],
+        }
+
+        enriched_actions.append(enriched)
+
+    return enriched_actions
+
+
+def generate_task_creation_instructions(actions: List[Dict]) -> str:
+    """
+    Generate instructions for Claude to create tasks in Notion.
+
+    This is the output format when used with Claude/Cowork.
+    """
+    if not actions:
+        return "No action items found in this transcript."
+
+    output = []
+    output.append("## Extracted Action Items\n")
+    output.append(f"Found {len(actions)} potential action items:\n")
+
+    for i, action in enumerate(actions, 1):
+        output.append(f"### {i}. {action['task_name']}")
+        output.append(f"- **Priority:** {action['priority']}")
+        if action['deadline']:
+            output.append(f"- **Due:** {action['deadline']}")
+        if action['project']:
+            output.append(f"- **Project:** {action['project']}")
+        output.append(f"- **Source:** Meeting ({action['meeting_date']})")
+        if action['participants']:
+            output.append(f"- **With:** {', '.join(action['participants'])}")
+        output.append("")
+
+    output.append("\n---\n")
+    output.append("**To create these tasks in Notion:**")
+    output.append("Use the `notion-create-pages` tool with parent:")
+    output.append(f"  `{{'data_source_id': '{DATABASES['tasks_tracker_collection']}'}}`")
+
+    return "\n".join(output)
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Extract meeting action items")
+    parser.add_argument("--date", help="Meeting date (YYYY-MM-DD)")
+    parser.add_argument("--days", type=int, default=7, help="Look back N days")
+    parser.add_argument("--dry-run", action="store_true", help="Don't create tasks")
+    args = parser.parse_args()
+
+    print("Meeting Action Extractor")
+    print("=" * 40)
+    print()
+    print("This script helps extract action items from meeting transcripts.")
+    print("When used with Claude/Cowork, it will:")
+    print("  1. Search Notion for meeting transcripts (@DATE pages)")
+    print("  2. Extract action items using pattern matching")
+    print("  3. Create tasks in the Tasks Tracker database")
+    print()
+    print("Example usage with Claude:")
+    print('  "Extract action items from my meeting yesterday with [Supervisor]"')
+    print('  "Process all unprocessed meeting transcripts from this week"')
+    print()
+
+    if args.dry_run:
+        # Demo with sample text
+        sample_transcript = """
+        the user, I know you would be operative for you, right? So when you have these events,
+        you need to give a list of the names of people coming to the desk downstairs at the Shard.
+        I'll send you an email about the catering costs by Friday.
+        Can you also update the course guide and send it to the students?
+        We agreed to meet again next Tuesday to discuss progress.
+        """
+
+        print("Demo extraction from sample text:")
+        print("-" * 40)
+
+        actions = extract_actions_from_transcript(
+            sample_transcript,
+            meeting_date="14 January 2026",
+            participants=["[Supervisor]"]
+        )
+
+        print(generate_task_creation_instructions(actions))
+
+
+if __name__ == "__main__":
+    main()

package/.scripts/focus

@@ -0,0 +1,176 @@
+#!/usr/bin/env python3
+"""
+Quick update to current-focus.md
+
+Usage:
+    focus "Working on [Journal] section 4"       # Update what you're working on
+    focus --left-off "Finished draft"       # Update where you left off
+    focus --next "Review with [Supervisor]"      # Add next step
+    focus --show                            # Show current focus
+"""
+
+import argparse
+import os
+from datetime import datetime
+from pathlib import Path
+
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+CONTEXT_DIR = BASE_DIR / ".context"
+FOCUS_FILE = CONTEXT_DIR / "current-focus.md"
+
+
+def read_focus():
+    """Read current focus file."""
+    if FOCUS_FILE.exists():
+        return FOCUS_FILE.read_text()
+    return ""
+
+
+def write_focus(content):
+    """Write focus file."""
+    FOCUS_FILE.write_text(content)
+
+
+def update_section(content, section_name, new_value):
+    """Update a specific section in the markdown."""
+    lines = content.split("\n")
+    new_lines = []
+    in_section = False
+    section_updated = False
+
+    for i, line in enumerate(lines):
+        if line.startswith(f"## {section_name}"):
+            in_section = True
+            new_lines.append(line)
+            new_lines.append(new_value)
+            section_updated = True
+            continue
+        elif line.startswith("## ") and in_section:
+            in_section = False
+
+        if not in_section:
+            new_lines.append(line)
+        elif not line.strip():
+            new_lines.append(line)
+
+    if not section_updated:
+        # Add section at end
+        new_lines.append(f"\n## {section_name}")
+        new_lines.append(new_value)
+
+    return "\n".join(new_lines)
+
+
+def create_default_template():
+    """Create default focus template."""
+    now = datetime.now().strftime("%Y-%m-%d %H:%M")
+    return f"""# Current Focus
+
+Last updated: {now}
+
+## What I'm Working On
+
+
+## Where I Left Off
+
+
+## Next Steps
+-
+
+## Open Questions
+-
+
+## Notes
+
+"""
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Update current focus")
+    parser.add_argument("working_on", nargs="?", help="What you're working on")
+    parser.add_argument("--left-off", dest="left_off", help="Where you left off")
+    parser.add_argument("--next", dest="next_step", help="Next step to add")
+    parser.add_argument("--question", help="Open question to add")
+    parser.add_argument("--note", help="Note to add")
+    parser.add_argument("--show", action="store_true", help="Show current focus")
+    parser.add_argument("--clear", action="store_true", help="Clear and start fresh")
+
+    args = parser.parse_args()
+
+    # Show current focus
+    if args.show:
+        content = read_focus()
+        if content:
+            print(content)
+        else:
+            print("No current focus set.")
+        return
+
+    # Clear and start fresh
+    if args.clear:
+        write_focus(create_default_template())
+        print("✅ Focus cleared")
+        return
+
+    # Read existing or create new
+    content = read_focus()
+    if not content:
+        content = create_default_template()
+
+    # Update timestamp
+    now = datetime.now().strftime("%Y-%m-%d %H:%M")
+    if "Last updated:" in content:
+        lines = content.split("\n")
+        for i, line in enumerate(lines):
+            if line.startswith("Last updated:"):
+                lines[i] = f"Last updated: {now}"
+                break
+        content = "\n".join(lines)
+
+    updated = False
+
+    # Update what working on
+    if args.working_on:
+        content = update_section(content, "What I'm Working On", args.working_on)
+        updated = True
+        print(f"✅ Working on: {args.working_on}")
+
+    # Update where left off
+    if args.left_off:
+        content = update_section(content, "Where I Left Off", args.left_off)
+        updated = True
+        print(f"✅ Left off: {args.left_off}")
+
+    # Add next step
+    if args.next_step:
+        section = "Next Steps"
+        if f"## {section}" in content:
+            content = content.replace(f"## {section}\n", f"## {section}\n- {args.next_step}\n")
+        updated = True
+        print(f"✅ Next: {args.next_step}")
+
+    # Add question
+    if args.question:
+        section = "Open Questions"
+        if f"## {section}" in content:
+            content = content.replace(f"## {section}\n", f"## {section}\n- {args.question}\n")
+        updated = True
+        print(f"✅ Question: {args.question}")
+
+    # Add note
+    if args.note:
+        section = "Notes"
+        if f"## {section}" in content:
+            content = content.replace(f"## {section}\n", f"## {section}\n{args.note}\n")
+        updated = True
+        print(f"✅ Note added")
+
+    if updated:
+        write_focus(content)
+    else:
+        parser.print_help()
+
+
+if __name__ == "__main__":
+    main()