flonat-research 0.1.0

package/.scripts/count_inventory.py

@@ -0,0 +1,275 @@
+#!/usr/bin/env python3
+"""Count automation: scan filesystem for ground-truth infrastructure counts
+and propagate them across all documentation files.
+
+Usage:
+    uv run python .scripts/count_inventory.py [--check | --fix] [--json]
+
+Exit codes:
+    0  All counts match (--check) or fixes applied (--fix)
+    1  Stale counts found (--check)
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from dataclasses import dataclass, asdict
+from pathlib import Path
+
+# ── Ground truth ─────────────────────────────────────────────────────────
+
+# Hardcoded constants (not derivable from filesystem)
+NOTION_DBS = 6
+RESOURCE_REPOS = 43  # 15 academics + 23 general + 5 bibliography
+# Note: skill count is derived from filesystem (skills/*/SKILL.md), not hardcoded
+
+
+def get_ground_truth(root: Path) -> dict[str, int]:
+    """Derive infrastructure counts from the filesystem."""
+    skills = len(list((root / "skills").glob("*/SKILL.md")))
+    # Also count skill.md (lowercase) to avoid missing any
+    skills += len([p for p in (root / "skills").glob("*/skill.md")
+                   if not any(s.name == "SKILL.md" for s in p.parent.iterdir())])
+    agents = len(list((root / ".claude" / "agents").glob("*.md")))
+    rules = len(list((root / ".claude" / "rules").glob("*.md")))
+    hooks_sh = len(list((root / "hooks").glob("*.sh")))
+    hooks_py = len(list((root / "hooks").glob("*.py")))
+    hooks = hooks_sh + hooks_py
+    return {
+        "skills": skills,
+        "agents": agents,
+        "rules": rules,
+        "hooks": hooks,
+    }
+
+
+# ── Scan configuration ──────────────────────────────────────────────────
+
+# Files to scan (relative to repo root)
+SCAN_FILES = [
+    "CLAUDE.md",
+    "README.md",
+    "docs/skills.md",
+    "docs/rules.md",
+    "docs/hooks.md",
+    "docs/agents.md",
+    "docs/system.md",
+    "docs/installation.md",
+    ".context/projects/_index.md",
+    "skills/shared/skill-index.md",
+    "docs/user-manual/user-manual.tex",
+    "docs/setup-overview/setup-overview.tex",
+]
+
+# Lines matching these patterns are EXCLUDED from replacement.
+# They are historical log entries, category subtotals, or external references.
+EXCLUDE_LINE_PATTERNS = [
+    re.compile(r"\b\d+ to \d+ skills"),  # "55 to 62 skills" changelog
+    re.compile(r"Added \d+ new skills"),  # "Added 7 new skills" changelog
+    re.compile(r"\d+ agents \+ multiple skills"),  # changelog
+    re.compile(r"hugo|sant.anna|clo-author", re.IGNORECASE),  # external refs
+    re.compile(r"shared/"),  # "shared/" references
+    re.compile(r"^\s*\|.*category", re.IGNORECASE),  # table rows with category subtotals
+    re.compile(r"Research & Writing|Task Management.*Code|Publishing & Submission|Utilities", re.IGNORECASE),  # skill category subtotal lines
+    re.compile(r"^\s*#"),  # comment-only lines in code blocks
+    re.compile(r"Referee.2 agent performs"),  # prose about what an agent does
+    re.compile(r"Referee.2 agent .+never"),  # prose about agent behavior
+    re.compile(r"Referee.2 Agent", re.IGNORECASE),  # section title "The Referee~2 Agent"
+]
+
+
+@dataclass
+class Mismatch:
+    file: str
+    line_num: int
+    found: int
+    expected: int
+    context: str  # the line text
+    count_key: str  # skills, agents, rules, hooks
+
+
+# Pattern tuples: (compiled regex, count_key)
+# Each regex has a single capture group for the number.
+# All patterns are case-insensitive to catch "81 Skills", "25 Hooks" etc.
+SCAN_PATTERNS: list[tuple[re.Pattern, str]] = [
+    (re.compile(r"(\d+)\s+skills?\b", re.IGNORECASE), "skills"),
+    (re.compile(r"(\d+)\s+skill definitions?\b", re.IGNORECASE), "skills"),
+    (re.compile(r"(\d+)\s+reusable\b", re.IGNORECASE), "skills"),
+    (re.compile(r"(\d+)\s+agents?\b", re.IGNORECASE), "agents"),
+    (re.compile(r"(\d+)\s+agent definitions?\b", re.IGNORECASE), "agents"),
+    (re.compile(r"(\d+)\s+rules?\b", re.IGNORECASE), "rules"),
+    (re.compile(r"(\d+)\s+auto-loaded\b", re.IGNORECASE), "rules"),
+    (re.compile(r"(\d+)\s+hooks?\b", re.IGNORECASE), "hooks"),
+    (re.compile(r"(\d+)\s+hook scripts?\b", re.IGNORECASE), "hooks"),
+    # Heading format: ## Hooks (N scripts)
+    (re.compile(r"\((\d+)\s+scripts?\)"), "hooks"),
+]
+
+
+def _is_excluded(line: str) -> bool:
+    """Return True if the line should be skipped."""
+    return any(p.search(line) for p in EXCLUDE_LINE_PATTERNS)
+
+
+def scan(root: Path, truth: dict[str, int]) -> list[Mismatch]:
+    """Scan all registered files for stale counts."""
+    mismatches: list[Mismatch] = []
+    seen: set[tuple[str, int, str]] = set()  # (file, line_num, count_key)
+
+    for rel_path in SCAN_FILES:
+        fpath = root / rel_path
+        if not fpath.exists():
+            continue
+
+        lines = fpath.read_text(encoding="utf-8").splitlines()
+        for line_idx, line in enumerate(lines, start=1):
+            if _is_excluded(line):
+                continue
+
+            for pattern, key in SCAN_PATTERNS:
+                for m in pattern.finditer(line):
+                    dedup_key = (rel_path, line_idx, key)
+                    if dedup_key in seen:
+                        continue
+                    seen.add(dedup_key)
+
+                    found = int(m.group(1))
+                    expected = truth[key]
+                    if found != expected:
+                        mismatches.append(
+                            Mismatch(
+                                file=rel_path,
+                                line_num=line_idx,
+                                found=found,
+                                expected=expected,
+                                context=line.strip(),
+                                count_key=key,
+                            )
+                        )
+
+    return mismatches
+
+
+def fix(root: Path, mismatches: list[Mismatch]) -> int:
+    """Apply fixes for all mismatches. Returns number of fixes applied."""
+    # Group mismatches by file to minimise I/O
+    by_file: dict[str, list[Mismatch]] = {}
+    for mm in mismatches:
+        by_file.setdefault(mm.file, []).append(mm)
+
+    total_fixed = 0
+
+    for rel_path, file_mismatches in by_file.items():
+        fpath = root / rel_path
+        lines = fpath.read_text(encoding="utf-8").splitlines()
+
+        # Sort by line number descending so index shifts don't matter
+        for mm in sorted(file_mismatches, key=lambda m: m.line_num, reverse=True):
+            idx = mm.line_num - 1
+            old_line = lines[idx]
+
+            # Find the specific pattern match and replace the number
+            new_line = old_line
+            for pattern, key in SCAN_PATTERNS:
+                if key != mm.count_key:
+                    continue
+                for m in pattern.finditer(old_line):
+                    if int(m.group(1)) == mm.found:
+                        # Replace just this occurrence
+                        start, end = m.span(1)
+                        new_line = (
+                            new_line[:start] + str(mm.expected) + new_line[end:]
+                        )
+                        break
+                if new_line != old_line:
+                    break
+
+            if new_line != old_line:
+                lines[idx] = new_line
+                total_fixed += 1
+
+        fpath.write_text("\n".join(lines) + "\n", encoding="utf-8")
+
+    return total_fixed
+
+
+# ── CLI ──────────────────────────────────────────────────────────────────
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Count automation for infrastructure docs"
+    )
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument(
+        "--check",
+        action="store_true",
+        help="Report stale counts (default)",
+    )
+    group.add_argument(
+        "--fix", action="store_true", help="Fix stale counts in place"
+    )
+    parser.add_argument(
+        "--json", action="store_true", help="Output as JSON"
+    )
+    args = parser.parse_args()
+
+    root = Path(__file__).resolve().parent.parent
+    truth = get_ground_truth(root)
+    mismatches = scan(root, truth)
+
+    if args.json:
+        data = {
+            "ground_truth": truth,
+            "constants": {
+                "notion_dbs": NOTION_DBS,
+                "resource_repos": RESOURCE_REPOS,
+            },
+            "mismatches": [asdict(m) for m in mismatches],
+            "total_mismatches": len(mismatches),
+        }
+        print(json.dumps(data, indent=2))
+        return 1 if mismatches and not args.fix else 0
+
+    if args.fix:
+        if not mismatches:
+            print(f"All counts match ground truth: {truth}")
+            return 0
+
+        n_fixed = fix(root, mismatches)
+
+        # Re-scan to verify
+        remaining = scan(root, truth)
+        print(f"Ground truth: {truth}")
+        print(f"Fixed {n_fixed} stale counts across {len(set(m.file for m in mismatches))} files")
+        if remaining:
+            print(f"WARNING: {len(remaining)} counts still stale after fix:")
+            for m in remaining:
+                print(f"  {m.file}:{m.line_num}: found {m.found}, expected {m.expected}")
+                print(f"    {m.context}")
+            return 1
+        print("All counts now match.")
+        return 0
+
+    # --check (default)
+    print(f"Ground truth: {truth}")
+    if not mismatches:
+        print("All counts match.")
+        return 0
+
+    print(f"\n{len(mismatches)} stale counts found:\n")
+    current_file = None
+    for m in mismatches:
+        if m.file != current_file:
+            current_file = m.file
+            print(f"  {m.file}:")
+        print(f"    L{m.line_num}: {m.count_key} {m.found} → {m.expected}")
+        print(f"      {m.context}")
+    return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/.scripts/daily_digest.py

@@ -0,0 +1,288 @@
+#!/usr/bin/env python3
+"""
+Daily Digest Generator
+
+Generates a morning briefing to help with daily planning.
+Designed to work with Claude/Cowork for interactive planning sessions.
+
+Usage with Claude:
+    "Help me plan my day" -> Triggers this workflow
+
+The digest includes:
+- Overdue tasks
+- Tasks due today
+- Upcoming deadlines (next 7 days)
+- Current focus from context library
+- Questions to help prioritise
+"""
+
+import argparse
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from config import CONTEXT_DIR, DATABASES
+
+
+def load_current_focus() -> Optional[str]:
+    """
+    Load the current-focus.md file from the context library.
+    """
+    focus_file = CONTEXT_DIR / "current-focus.md"
+    if focus_file.exists():
+        return focus_file.read_text()
+    return None
+
+
+def generate_planning_questions(
+    overdue_count: int = 0,
+    due_today_count: int = 0,
+    has_meetings: bool = False,
+) -> List[str]:
+    """
+    Generate contextual questions to help with daily planning.
+    """
+    questions = []
+
+    # Always start with energy check
+    questions.append("How are you feeling today - high energy for deep work, or better suited for lighter tasks?")
+
+    if has_meetings:
+        questions.append("You have meetings today. What do you need to prepare?")
+
+    if overdue_count > 0:
+        questions.append(f"You have {overdue_count} overdue task(s). Which of these is most important to address today?")
+
+    if due_today_count > 3:
+        questions.append(f"You have {due_today_count} tasks due today. That's a lot - which 2-3 are truly non-negotiable?")
+
+    questions.append("What were you working on yesterday? Should you continue, or switch focus?")
+    questions.append("Is anything weighing on your mind that we should capture or address?")
+
+    return questions
+
+
+def format_task_summary(tasks: List[Dict]) -> str:
+    """
+    Format a list of tasks into a readable summary.
+    """
+    if not tasks:
+        return "_None_"
+
+    lines = []
+    for task in tasks[:10]:  # Limit to 10
+        priority = task.get("Priority", "")
+        due = task.get("Due date", "")
+        project = task.get("Project", "")
+
+        priority_emoji = {"High": "🔴", "Medium": "🟡", "Low": "🟢"}.get(priority, "⚪")
+
+        line = f"- {priority_emoji} **{task.get('Task name', 'Untitled')}**"
+        if project:
+            line += f" [{project}]"
+        if due:
+            line += f" (due: {due})"
+
+        lines.append(line)
+
+    if len(tasks) > 10:
+        lines.append(f"_...and {len(tasks) - 10} more_")
+
+    return "\n".join(lines)
+
+
+def generate_digest_template(
+    date: str,
+    overdue_tasks: List[Dict] = None,
+    due_today: List[Dict] = None,
+    upcoming: List[Dict] = None,
+    current_focus: Optional[str] = None,
+) -> str:
+    """
+    Generate the full daily digest document.
+    """
+    today = datetime.now()
+    day_name = today.strftime("%A")
+
+    digest = []
+
+    digest.append(f"# Daily Planning - {day_name}, {date}")
+    digest.append("")
+
+    # Planning Questions
+    digest.append("## Let's Plan Your Day")
+    digest.append("")
+    digest.append("Before diving in, let me ask a few questions:")
+    digest.append("")
+
+    questions = generate_planning_questions(
+        overdue_count=len(overdue_tasks or []),
+        due_today_count=len(due_today or []),
+        has_meetings=False,  # Would need calendar integration
+    )
+
+    for i, q in enumerate(questions, 1):
+        digest.append(f"{i}. {q}")
+
+    digest.append("")
+    digest.append("---")
+    digest.append("")
+
+    # Overdue Tasks
+    digest.append("## ⚠️ Overdue Tasks")
+    digest.append("")
+    digest.append(format_task_summary(overdue_tasks or []))
+    digest.append("")
+
+    # Due Today
+    digest.append("## 📅 Due Today")
+    digest.append("")
+    digest.append(format_task_summary(due_today or []))
+    digest.append("")
+
+    # Upcoming (next 7 days)
+    digest.append("## 🔮 Upcoming (Next 7 Days)")
+    digest.append("")
+    digest.append(format_task_summary(upcoming or []))
+    digest.append("")
+
+    # Current Focus
+    if current_focus:
+        digest.append("## 🎯 Current Focus")
+        digest.append("")
+        # Extract just the key parts
+        digest.append("_From your context library:_")
+        digest.append("")
+        # Include first 500 chars of current focus
+        preview = current_focus[:500]
+        if len(current_focus) > 500:
+            preview += "..."
+        digest.append(preview)
+        digest.append("")
+
+    digest.append("---")
+    digest.append("")
+
+    # Daily Plan Template
+    digest.append("## Today's Plan")
+    digest.append("")
+    digest.append("Based on your answers, here's a suggested structure:")
+    digest.append("")
+    digest.append("### Must Do (non-negotiable)")
+    digest.append("1. ")
+    digest.append("")
+    digest.append("### Should Do (important but flexible)")
+    digest.append("2. ")
+    digest.append("3. ")
+    digest.append("")
+    digest.append("### Could Do (if time permits)")
+    digest.append("4. ")
+    digest.append("")
+    digest.append("### Parking Lot (explicitly deferred)")
+    digest.append("- ")
+    digest.append("")
+
+    return "\n".join(digest)
+
+
+def generate_claude_instructions() -> str:
+    """
+    Generate instructions for Claude on how to use this for daily planning.
+    """
+    return """
+## How to Help the user Plan His Day
+
+When the user asks for help with daily planning, follow this workflow:
+
+### Step 1: Ask Orientation Questions
+Don't just dump a task list. Start with questions:
+- "How's your energy today?"
+- "Any meetings or fixed commitments?"
+- "What were you working on yesterday?"
+- "Anything weighing on your mind?"
+
+### Step 2: Query Notion for Tasks
+Use the Notion tools to get:
+1. **Overdue tasks**: Status != Done AND Due date < today
+2. **Due today**: Due date = today
+3. **Upcoming**: Due date within next 7 days
+
+Query the Tasks Tracker database:
+- Data source: `collection://YOUR-TASKS-DATABASE-ID-HERE`
+
+### Step 3: Read Context
+Check `.context/current-focus.md` for:
+- What the user was working on
+- Current priorities
+- Open loops
+
+### Step 4: Help Prioritise
+Based on answers and data:
+- Suggest 3-5 realistic tasks
+- Flag blocking items
+- Consider energy level
+- Mix different types of work
+
+### Step 5: Create the Plan
+Format as:
+- **Must Do**: Non-negotiable items
+- **Should Do**: Important but flexible
+- **Could Do**: If time permits
+- **Parking Lot**: Explicitly deferred
+
+### Remember:
+- the user prefers questions over lists
+- Don't overwhelm - be realistic
+- It's OK to suggest removing tasks
+- Update current-focus.md at end of session
+"""
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate daily planning digest")
+    parser.add_argument("--date", help="Date for digest (YYYY-MM-DD)")
+    parser.add_argument("--instructions", action="store_true", help="Show Claude instructions")
+    args = parser.parse_args()
+
+    if args.instructions:
+        print(generate_claude_instructions())
+        return
+
+    date = args.date or datetime.now().strftime("%d %B %Y")
+
+    print("Daily Digest Generator")
+    print("=" * 40)
+    print()
+
+    # Load current focus
+    current_focus = load_current_focus()
+
+    # Generate template (without actual Notion data - Claude will fill this in)
+    print("When used with Claude/Cowork, this generates a daily planning session.")
+    print()
+    print("Example usage:")
+    print('  "Help me plan my day"')
+    print('  "What should I focus on today?"')
+    print('  "Morning briefing please"')
+    print()
+    print("-" * 40)
+    print()
+
+    # Show template structure
+    print(generate_digest_template(
+        date=date,
+        overdue_tasks=[
+            {"Task name": "[Claude will query Notion]", "Priority": "High", "Project": "..."}
+        ],
+        due_today=[
+            {"Task name": "[Tasks due today]", "Priority": "Medium"}
+        ],
+        upcoming=[
+            {"Task name": "[Upcoming tasks]", "Priority": "Low", "Due date": "..."}
+        ],
+        current_focus=current_focus,
+    ))
+
+
+if __name__ == "__main__":
+    main()