Agent Chronicle

{
  "version": 1,
  "registry": "https://www.clawhub.ai",
  "slug": "agent-chronicle",
  "installedVersion": "0.5.0",
  "installedAt": 1770158681265
}

config.json
.env
.env.*
.cache/
.data/
__pycache__/
*.pyc

__pycache__/
*.pyc
.cache/
.data/
.env
.env.*
!.env.example
node_modules/
*.node
*.so
*.zip

{
  "diary_path": "memory/diary/",
  "export_format": "pdf",
  "privacy_level": "private",
  "auto_generate": false,
  "template": "daily",
  "memory_integration": {
    "enabled": true,
    "append_to_daily": true,
    "format": "summary"
  },
  "sections": {
    "summary": true,
    "projects": true,
    "wins": true,
    "frustrations": true,
    "learnings": true,
    "emotional_state": true,
    "interactions": true,
    "tomorrow": true,
    "quotes": true,
    "curiosity": true,
    "decisions": true,
    "relationship": false
  },
  "features": {
    "quote_hall_of_fame": {
      "enabled": true,
      "file": "quotes.md"
    },
    "curiosity_backlog": {
      "enabled": true,
      "file": "curiosity.md"
    },
    "decision_archaeology": {
      "enabled": true,
      "file": "decisions.md"
    },
    "relationship_evolution": {
      "enabled": false,
      "file": "relationship.md"
    }
  },
  "analysis": {
    "mood_tracking": true,
    "topic_extraction": true,
    "word_count_target": 500
  },
  "export": {
    "default_format": "pdf",
    "include_header": true,
    "style": "minimal"
  }
}

{
  "_note": "diary_path is relative to your agent workspace. Run python3 scripts/setup.py to configure for your environment.",
  "diary_path": "memory/diary/",
  "export_format": "pdf",
  "privacy_level": "private",
  "auto_generate": true,
  "template": "daily",
  "memory_integration": {
    "enabled": false,
    "append_to_daily": false,
    "format": "summary"
  },
  "sections": {
    "summary": true,
    "projects": true,
    "wins": true,
    "frustrations": true,
    "learnings": true,
    "emotional_state": true,
    "interactions": true,
    "tomorrow": true,
    "quotes": true,
    "curiosity": true,
    "decisions": true,
    "relationship": false
  },
  "features": {
    "quote_hall_of_fame": {
      "enabled": true,
      "file": "quotes.md"
    },
    "curiosity_backlog": {
      "enabled": true,
      "file": "curiosity.md"
    },
    "decision_archaeology": {
      "enabled": true,
      "file": "decisions.md"
    },
    "relationship_evolution": {
      "enabled": false,
      "file": "relationship.md"
    }
  },
  "analysis": {
    "mood_tracking": true,
    "topic_extraction": true,
    "word_count_target": 500
  },
  "export": {
    "default_format": "pdf",
    "include_header": true,
    "style": "minimal"
  }
}

{
  "name": "@openclaw/agent-chronicle",
  "version": "0.7.2",
  "description": "Chronicle your AI's journey - capture experiences, quotes, curiosities, decisions, relationships, mood analytics, weekly digests, and 'On This Day' resurfacing from the agent's perspective",
  "author": "robbyczgw-cla",
  "license": "MIT",
  "keywords": [
    "openclaw",
    "skill",
    "chronicle",
    "journal",
    "memory",
    "self-reflection",
    "ai-perspective",
    "quotes",
    "decisions",
    "curiosity"
  ],
  "repository": {
    "type": "git",
    "url": "https://github.com/robbyczgw-cla/agent-chronicle.git"
  },
  "homepage": "https://clawhub.ai/robbyczgw-cla/agent-chronicle",
  "bugs": {
    "url": "https://github.com/robbyczgw-cla/agent-chronicle/issues"
  },
  "openclaw": {
    "skill": true,
    "emoji": "\ud83d\udcdc",
    "triggers": [
      "chronicle",
      "diary",
      "journal",
      "daily log",
      "write entry",
      "quotes",
      "curious",
      "decisions"
    ],
    "capabilities": [
      "journal-generation",
      "quote-tracking",
      "curiosity-backlog",
      "decision-archaeology",
      "mood-analytics",
      "weekly-digest",
      "on-this-day",
      "cron-auto-generation"
    ],
    "requirements": {
      "bins": [
        "python3"
      ],
      "env": {}
    }
  },
  "files": [
    "SKILL.md",
    "README.md",
    "config.example.json",
    "scripts/",
    "templates/"
  ]
}

lockfileVersion: '9.0'

settings:
  autoInstallPeers: true
  excludeLinksFromLockfile: false

importers:

  .: {}

#!/usr/bin/env python3
"""
Mood & Pattern Analytics for Agent Chronicle - v0.7.0

Reads diary entries and extracts mood/emotional keywords, builds a mood timeline,
identifies recurring topics, frustrations, wins, and outputs a markdown summary.

Usage:
    python3 scripts/analyze.py              # Analyze all entries
    python3 scripts/analyze.py --days 7     # Analyze last 7 days
    python3 scripts/analyze.py --days 30    # Analyze last 30 days
    python3 scripts/analyze.py --output mood-report.md  # Save to file
"""

import argparse
import json
import os
import re
from collections import Counter
from datetime import datetime, timedelta
from pathlib import Path

# Configuration
SCRIPT_DIR = Path(__file__).parent
SKILL_DIR = SCRIPT_DIR.parent
CONFIG_FILE = SKILL_DIR / "config.json"
DEFAULT_DIARY_PATH = "memory/diary/"

# Mood/emotion keyword mappings
MOOD_KEYWORDS = {
    "joyful": {
        "emoji": "😄",
        "score": 5,
        "words": [
            "excited", "thrilled", "elated", "ecstatic", "delighted",
            "overjoyed", "euphoric", "fantastic", "amazing", "wonderful",
            "incredible", "brilliant", "celebration", "triumphant",
        ],
    },
    "happy": {
        "emoji": "😊",
        "score": 4,
        "words": [
            "happy", "satisfied", "pleased", "glad", "good", "great",
            "productive", "positive", "energized", "motivated", "proud",
            "accomplished", "rewarding", "fulfilling", "shipped", "launched",
            "win", "wins", "success", "breakthrough", "milestone",
        ],
    },
    "calm": {
        "emoji": "😌",
        "score": 3,
        "words": [
            "calm", "peaceful", "relaxed", "steady", "balanced", "quiet",
            "routine", "normal", "stable", "comfortable", "mundane",
            "ordinary", "rest", "uneventful",
        ],
    },
    "mixed": {
        "emoji": "😐",
        "score": 2,
        "words": [
            "mixed", "bittersweet", "conflicted", "uncertain", "ambivalent",
            "okay", "alright", "fine", "so-so", "mediocre",
        ],
    },
    "frustrated": {
        "emoji": "😤",
        "score": 1,
        "words": [
            "frustrated", "annoyed", "irritated", "stuck", "blocked",
            "struggling", "difficult", "challenging", "bug", "bugs",
            "broken", "failed", "failure", "error", "errors", "issue",
            "issues", "problem", "problems", "confusing", "tedious",
        ],
    },
    "sad": {
        "emoji": "😔",
        "score": 0,
        "words": [
            "sad", "disappointed", "down", "tired", "exhausted",
            "drained", "overwhelmed", "burned out", "burnout", "lonely",
            "discouraged", "demotivated", "rough",
        ],
    },
}

# Topic extraction patterns
TOPIC_PATTERNS = [
    # Technical topics
    r"\b(python|javascript|typescript|rust|go|java|ruby|swift|kotlin)\b",
    r"\b(api|apis|rest|graphql|websocket|grpc)\b",
    r"\b(docker|kubernetes|k8s|container|deployment|ci/cd|github actions)\b",
    r"\b(database|sql|postgres|mysql|redis|mongodb|sqlite)\b",
    r"\b(react|vue|svelte|angular|nextjs|nuxt)\b",
    r"\b(ai|llm|gpt|claude|model|prompt|embedding|vector)\b",
    r"\b(openclaw|clawhub|skill|skills|plugin|plugins)\b",
    r"\b(git|github|pr|pull request|merge|branch|commit)\b",
    r"\b(testing|test|tests|debug|debugging|refactor|refactoring)\b",
    r"\b(security|auth|authentication|authorization|encryption)\b",
    r"\b(performance|optimization|caching|latency|speed)\b",
    r"\b(documentation|docs|readme|changelog)\b",
]


def load_config():
    """Load configuration from config.json"""
    if CONFIG_FILE.exists():
        with open(CONFIG_FILE) as f:
            return json.load(f)
    return {"diary_path": DEFAULT_DIARY_PATH}


def get_workspace_root():
    """Find the workspace root (where memory/ lives)"""
    env_workspace = os.getenv("OPENCLAW_WORKSPACE") or os.getenv("AGENT_WORKSPACE")
    if env_workspace:
        env_path = Path(env_workspace)
        if (env_path / "memory").exists():
            return env_path

    candidates = [
        Path.cwd(),
        Path.home() / "clawd",
        Path.home() / ".openclaw" / "workspace",
    ]
    for path in candidates:
        if (path / "memory").exists():
            return path
    return Path.cwd()


def get_diary_path(config):
    """Get full path to diary directory"""
    workspace = get_workspace_root()
    return workspace / config.get("diary_path", DEFAULT_DIARY_PATH)


def load_entries(diary_path, days=None):
    """Load diary entries, optionally filtering by recent days"""
    entries = {}
    md_files = sorted(diary_path.glob("*.md"))

    # Filter to only dated diary entries (YYYY-MM-DD.md), skip special files
    dated_files = [
        f for f in md_files if re.match(r"\d{4}-\d{2}-\d{2}$", f.stem)
    ]

    if days is not None:
        cutoff = datetime.now() - timedelta(days=days)
        cutoff_str = cutoff.strftime("%Y-%m-%d")
        dated_files = [f for f in dated_files if f.stem >= cutoff_str]

    for f in dated_files:
        entries[f.stem] = f.read_text()

    return entries


def extract_section(content, section_name):
    """Extract a section's content from a diary entry"""
    pattern = rf"##\s*{re.escape(section_name)}.*?\n(.*?)(?=\n##|\Z)"
    match = re.search(pattern, content, re.DOTALL | re.IGNORECASE)
    if match:
        return match.group(1).strip()
    return ""


def analyze_mood(content):
    """Analyze mood of a single entry, returns (dominant_mood, score, keyword_counts)"""
    content_lower = content.lower()
    mood_counts = {}

    for mood, info in MOOD_KEYWORDS.items():
        count = 0
        for word in info["words"]:
            count += len(re.findall(r"\b" + re.escape(word) + r"\b", content_lower))
        if count > 0:
            mood_counts[mood] = count

    if not mood_counts:
        return "calm", 3, {}

    # Weight by section: emotional state section counts 3x
    emotional_section = extract_section(content, "Emotional State")
    if emotional_section:
        emo_lower = emotional_section.lower()
        for mood, info in MOOD_KEYWORDS.items():
            bonus = 0
            for word in info["words"]:
                bonus += len(re.findall(r"\b" + re.escape(word) + r"\b", emo_lower))
            if bonus > 0:
                mood_counts[mood] = mood_counts.get(mood, 0) + bonus * 2  # 2x bonus

    dominant = max(mood_counts, key=mood_counts.get)
    score = MOOD_KEYWORDS[dominant]["score"]

    return dominant, score, mood_counts


def extract_topics(content):
    """Extract topics mentioned in an entry"""
    content_lower = content.lower()
    topics = []

    for pattern in TOPIC_PATTERNS:
        matches = re.findall(pattern, content_lower)
        topics.extend(matches)

    return topics


def extract_wins(content):
    """Extract wins from an entry"""
    wins_section = extract_section(content, "Wins 🎉") or extract_section(content, "Wins")
    if not wins_section:
        return []

    wins = []
    for line in wins_section.split("\n"):
        line = line.strip()
        if line and line.startswith(("-", "*", "•")):
            win = re.sub(r"^[-*•]\s*", "", line).strip()
            if win and len(win) > 5:
                wins.append(win)
        elif line and not line.startswith("#"):
            # Paragraph-style wins - take first sentence
            sentences = re.split(r"[.!?]", line)
            if sentences and len(sentences[0].strip()) > 5:
                wins.append(sentences[0].strip())

    return wins


def extract_frustrations(content):
    """Extract frustrations from an entry"""
    frust_section = (
        extract_section(content, "Frustrations 😤")
        or extract_section(content, "Frustrations")
    )
    if not frust_section:
        return []

    frustrations = []
    for line in frust_section.split("\n"):
        line = line.strip()
        if line and line.startswith(("-", "*", "•")):
            frust = re.sub(r"^[-*•]\s*", "", line).strip()
            if frust and len(frust) > 5:
                frustrations.append(frust)
        elif line and not line.startswith("#"):
            sentences = re.split(r"[.!?]", line)
            if sentences and len(sentences[0].strip()) > 5:
                frustrations.append(sentences[0].strip())

    return frustrations


def build_sparkline(scores):
    """Build a text-based sparkline from mood scores (0-5)"""
    blocks = ["▁", "▂", "▃", "▅", "▆", "█"]
    return "".join(blocks[min(s, 5)] for s in scores)


def build_emoji_timeline(moods):
    """Build an emoji-based mood timeline"""
    return " ".join(MOOD_KEYWORDS.get(m, {}).get("emoji", "❓") for m in moods)


def generate_report(entries, days_label=None):
    """Generate a full mood & pattern analytics report"""
    if not entries:
        return "# Mood & Pattern Analytics\n\nNo diary entries found to analyze.\n"

    # Analyze all entries
    daily_moods = {}  # date -> (mood, score, counts)
    all_topics = Counter()
    all_wins = []
    all_frustrations = []

    for date_str in sorted(entries.keys()):
        content = entries[date_str]
        mood, score, counts = analyze_mood(content)
        daily_moods[date_str] = (mood, score, counts)

        topics = extract_topics(content)
        all_topics.update(topics)

        wins = extract_wins(content)
        all_wins.extend([(date_str, w) for w in wins])

        frustrations = extract_frustrations(content)
        all_frustrations.extend([(date_str, f) for f in frustrations])

    # Build report
    dates = sorted(daily_moods.keys())
    scores = [daily_moods[d][1] for d in dates]
    moods = [daily_moods[d][0] for d in dates]

    period = days_label or "all time"
    avg_score = sum(scores) / len(scores) if scores else 0
    avg_mood = (
        "joyful" if avg_score >= 4.5
        else "happy" if avg_score >= 3.5
        else "calm" if avg_score >= 2.5
        else "mixed" if avg_score >= 1.5
        else "frustrated" if avg_score >= 0.5
        else "sad"
    )
    avg_emoji = MOOD_KEYWORDS[avg_mood]["emoji"]

    # Mood distribution
    mood_dist = Counter(moods)

    report = []
    report.append(f"# 📊 Mood & Pattern Analytics")
    report.append(f"")
    report.append(f"**Period:** {period} ({len(entries)} entries)")
    report.append(f"**Average Mood:** {avg_emoji} {avg_mood} ({avg_score:.1f}/5)")
    report.append(f"")

    # Mood Timeline
    report.append(f"## 📈 Mood Timeline")
    report.append(f"")

    if len(dates) <= 30:
        # Show individual dates
        report.append(f"```")
        report.append(f"Sparkline: {build_sparkline(scores)}")
        report.append(f"```")
        report.append(f"")
        report.append(f"{build_emoji_timeline(moods)}")
        report.append(f"")

        for date_str in dates:
            mood, score, _ = daily_moods[date_str]
            emoji = MOOD_KEYWORDS[mood]["emoji"]
            bar = "█" * score + "░" * (5 - score)
            report.append(f"- `{date_str}` {emoji} {bar} {mood}")
    else:
        # Summarize by week for large datasets
        report.append(f"```")
        report.append(f"Sparkline: {build_sparkline(scores)}")
        report.append(f"```")
        report.append(f"")
        report.append(f"{build_emoji_timeline(moods)}")
        report.append(f"")

        # Weekly averages
        week_scores = {}
        for date_str, (mood, score, _) in daily_moods.items():
            try:
                dt = datetime.strptime(date_str, "%Y-%m-%d")
                week_key = f"{dt.year}-W{dt.isocalendar()[1]:02d}"
            except ValueError:
                continue
            week_scores.setdefault(week_key, []).append(score)

        report.append(f"### Weekly Averages")
        for week, week_s in sorted(week_scores.items()):
            avg = sum(week_s) / len(week_s)
            avg_m = (
                "joyful" if avg >= 4.5
                else "happy" if avg >= 3.5
                else "calm" if avg >= 2.5
                else "mixed" if avg >= 1.5
                else "frustrated" if avg >= 0.5
                else "sad"
            )
            emoji = MOOD_KEYWORDS[avg_m]["emoji"]
            report.append(f"- `{week}` {emoji} {avg:.1f}/5 ({len(week_s)} entries)")

    report.append(f"")

    # Mood Distribution
    report.append(f"## 🎭 Mood Distribution")
    report.append(f"")
    for mood_name in ["joyful", "happy", "calm", "mixed", "frustrated", "sad"]:
        count = mood_dist.get(mood_name, 0)
        if count > 0:
            pct = count / len(moods) * 100
            emoji = MOOD_KEYWORDS[mood_name]["emoji"]
            bar = "▓" * int(pct / 5) + "░" * (20 - int(pct / 5))
            report.append(f"- {emoji} **{mood_name}**: {bar} {count} ({pct:.0f}%)")
    report.append(f"")

    # Top Topics
    if all_topics:
        report.append(f"## 🏷️ Recurring Topics")
        report.append(f"")
        for topic, count in all_topics.most_common(15):
            report.append(f"- **{topic}** — mentioned {count} time{'s' if count > 1 else ''}")
        report.append(f"")

    # Top Wins
    if all_wins:
        report.append(f"## 🏆 Wins Compilation")
        report.append(f"")
        # Show most recent wins (up to 10)
        recent_wins = all_wins[-10:]
        for date_str, win in reversed(recent_wins):
            # Truncate long wins
            display_win = win[:120] + "..." if len(win) > 120 else win
            report.append(f"- `{date_str}` {display_win}")
        if len(all_wins) > 10:
            report.append(f"- *...and {len(all_wins) - 10} more wins*")
        report.append(f"")

    # Top Frustrations
    if all_frustrations:
        report.append(f"## 😤 Recurring Frustrations")
        report.append(f"")
        # Look for recurring themes in frustrations
        frust_words = Counter()
        for _, frust in all_frustrations:
            words = re.findall(r"\b[a-z]{4,}\b", frust.lower())
            frust_words.update(words)

        # Show recent frustrations
        recent_frust = all_frustrations[-8:]
        for date_str, frust in reversed(recent_frust):
            display_frust = frust[:120] + "..." if len(frust) > 120 else frust
            report.append(f"- `{date_str}` {display_frust}")
        if len(all_frustrations) > 8:
            report.append(f"- *...and {len(all_frustrations) - 8} more frustrations*")
        report.append(f"")

    # Insights
    report.append(f"## 💡 Insights")
    report.append(f"")

    # Trend detection
    if len(scores) >= 3:
        recent_avg = sum(scores[-3:]) / 3
        older_avg = sum(scores[:-3]) / max(len(scores) - 3, 1) if len(scores) > 3 else recent_avg
        if recent_avg > older_avg + 0.5:
            report.append(f"- 📈 **Upward trend** — mood has been improving recently")
        elif recent_avg < older_avg - 0.5:
            report.append(f"- 📉 **Downward trend** — mood has dipped recently")
        else:
            report.append(f"- ➡️ **Stable mood** — relatively consistent emotional state")

    # Best/worst days
    if scores:
        best_idx = scores.index(max(scores))
        worst_idx = scores.index(min(scores))
        best_date = dates[best_idx]
        worst_date = dates[worst_idx]
        best_emoji = MOOD_KEYWORDS[moods[best_idx]]["emoji"]
        worst_emoji = MOOD_KEYWORDS[moods[worst_idx]]["emoji"]
        report.append(f"- {best_emoji} **Best day:** {best_date}")
        report.append(f"- {worst_emoji} **Toughest day:** {worst_date}")

    # Win/frustration ratio
    if all_wins or all_frustrations:
        ratio = len(all_wins) / max(len(all_frustrations), 1)
        if ratio > 2:
            report.append(f"- 🎯 **Win ratio: {ratio:.1f}x** — significantly more wins than frustrations!")
        elif ratio > 1:
            report.append(f"- ⚖️ **Win ratio: {ratio:.1f}x** — slightly more wins than frustrations")
        else:
            report.append(f"- 🔧 **Win ratio: {ratio:.1f}x** — more frustrations than wins, consider what's blocking you")

    report.append(f"")
    report.append(f"---")
    report.append(f"*Generated by Agent Chronicle v0.7.0 on {datetime.now().strftime('%Y-%m-%d %H:%M')}*")

    return "\n".join(report)


def main():
    parser = argparse.ArgumentParser(
        description="Mood & Pattern Analytics for Agent Chronicle"
    )
    parser.add_argument(
        "--days", "-d", type=int, help="Analyze last N days (default: all)"
    )
    parser.add_argument(
        "--output", "-o", help="Save report to file (default: print to stdout)"
    )
    parser.add_argument(
        "--json", action="store_true", help="Output raw analysis as JSON"
    )
    args = parser.parse_args()

    config = load_config()
    diary_path = get_diary_path(config)

    if not diary_path.exists():
        print(f"Diary path not found: {diary_path}")
        print("Run setup first or check config.json diary_path setting.")
        return

    entries = load_entries(diary_path, days=args.days)

    if not entries:
        period = f"last {args.days} days" if args.days else "all time"
        print(f"No diary entries found for {period} in {diary_path}")
        return

    days_label = f"last {args.days} days" if args.days else "all time"

    if args.json:
        # Raw JSON output for programmatic use
        results = {}
        for date_str in sorted(entries.keys()):
            mood, score, counts = analyze_mood(entries[date_str])
            topics = extract_topics(entries[date_str])
            results[date_str] = {
                "mood": mood,
                "score": score,
                "topics": topics,
                "wins": extract_wins(entries[date_str]),
                "frustrations": extract_frustrations(entries[date_str]),
            }
        print(json.dumps(results, indent=2))
        return

    report = generate_report(entries, days_label)

    if args.output:
        output_path = Path(args.output)
        output_path.parent.mkdir(parents=True, exist_ok=True)
        output_path.write_text(report)
        print(f"✓ Report saved to {output_path}")
    else:
        print(report)


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
Weekly Digest for Agent Chronicle - v0.7.0

Reads the past 7 daily entries and synthesizes a weekly summary including
top quotes, biggest wins, resolved curiosities, mood trend, and key decisions.

Output: YYYY-WXX-weekly.md in the diary directory.

Usage:
    python3 scripts/digest.py                # Generate digest for current week
    python3 scripts/digest.py --date 2026-03-20  # Generate digest for the week containing this date
    python3 scripts/digest.py --emit-task    # Emit sub-agent task JSON
    python3 scripts/digest.py --from-stdin   # Read pre-generated digest from stdin
    python3 scripts/digest.py --dry-run      # Preview without saving
"""

import argparse
import json
import os
import re
import sys
from datetime import datetime, timedelta
from pathlib import Path

# Configuration
SCRIPT_DIR = Path(__file__).parent
SKILL_DIR = SCRIPT_DIR.parent
CONFIG_FILE = SKILL_DIR / "config.json"
DEFAULT_DIARY_PATH = "memory/diary/"

AI_MAX_TOKENS = 3000


def load_config():
    """Load configuration from config.json"""
    if CONFIG_FILE.exists():
        with open(CONFIG_FILE) as f:
            return json.load(f)
    return {"diary_path": DEFAULT_DIARY_PATH}


def get_workspace_root():
    """Find the workspace root (where memory/ lives)"""
    env_workspace = os.getenv("OPENCLAW_WORKSPACE") or os.getenv("AGENT_WORKSPACE")
    if env_workspace:
        env_path = Path(env_workspace)
        if (env_path / "memory").exists():
            return env_path

    candidates = [
        Path.cwd(),
        Path.home() / "clawd",
        Path.home() / ".openclaw" / "workspace",
    ]
    for path in candidates:
        if (path / "memory").exists():
            return path
    return Path.cwd()


def get_diary_path(config):
    """Get full path to diary directory"""
    workspace = get_workspace_root()
    diary_path = workspace / config.get("diary_path", DEFAULT_DIARY_PATH)
    diary_path.mkdir(parents=True, exist_ok=True)
    return diary_path


def get_week_range(reference_date=None):
    """Get the Monday-to-Sunday date range for the week containing reference_date.
    Returns (start_date, end_date, iso_year, iso_week)."""
    if reference_date is None:
        reference_date = datetime.now()

    # ISO weekday: Monday=1, Sunday=7
    start = reference_date - timedelta(days=reference_date.weekday())
    end = start + timedelta(days=6)
    iso_year, iso_week, _ = reference_date.isocalendar()

    return start, end, iso_year, iso_week


def load_week_entries(diary_path, start_date, end_date):
    """Load diary entries for a given date range"""
    entries = {}
    current = start_date
    while current <= end_date:
        date_str = current.strftime("%Y-%m-%d")
        entry_file = diary_path / f"{date_str}.md"
        if entry_file.exists():
            entries[date_str] = entry_file.read_text()
        current += timedelta(days=1)
    return entries


def extract_section(content, section_name):
    """Extract a section's content from a diary entry"""
    pattern = rf"##\s*{re.escape(section_name)}.*?\n(.*?)(?=\n##|\Z)"
    match = re.search(pattern, content, re.DOTALL | re.IGNORECASE)
    if match:
        return match.group(1).strip()
    return ""


def extract_quotes(entries):
    """Extract all quotes from entries"""
    quotes = []
    for date_str, content in sorted(entries.items()):
        quote_section = extract_section(content, "Quote of the Day 💬")
        if not quote_section:
            quote_section = extract_section(content, "Quote of the Day")
        if quote_section and len(quote_section) > 10:
            quotes.append((date_str, quote_section.strip()))
    return quotes


def extract_wins(entries):
    """Extract all wins from entries"""
    wins = []
    for date_str, content in sorted(entries.items()):
        wins_section = extract_section(content, "Wins 🎉") or extract_section(content, "Wins")
        if wins_section:
            for line in wins_section.split("\n"):
                line = line.strip()
                if line and line.startswith(("-", "*", "•")):
                    win = re.sub(r"^[-*•]\s*", "", line).strip()
                    if win and len(win) > 5:
                        wins.append((date_str, win))
                elif line and not line.startswith("#") and len(line) > 10:
                    # Paragraph-style: take first sentence
                    sentences = re.split(r"[.!?]", line)
                    if sentences and len(sentences[0].strip()) > 5:
                        wins.append((date_str, sentences[0].strip()))
    return wins


def extract_decisions(entries):
    """Extract key decisions from entries"""
    decisions = []
    for date_str, content in sorted(entries.items()):
        dec_section = (
            extract_section(content, "Key Decisions Made 🏛️")
            or extract_section(content, "Key Decisions Made 🏛")
            or extract_section(content, "Key Decisions Made")
        )
        if dec_section:
            for line in dec_section.split("\n"):
                line = line.strip()
                if line and line.startswith(("-", "*", "•")):
                    dec = re.sub(r"^[-*•]\s*", "", line).strip()
                    if dec and len(dec) > 5:
                        decisions.append((date_str, dec))
                elif line and not line.startswith("#") and len(line) > 10:
                    decisions.append((date_str, line.strip()))
    return decisions


def extract_curiosities(entries):
    """Extract curiosities from entries"""
    curiosities = []
    for date_str, content in sorted(entries.items()):
        cur_section = (
            extract_section(content, "Things I'm Curious About 🔮")
            or extract_section(content, "Things I'm Curious About")
        )
        if cur_section:
            for line in cur_section.split("\n"):
                line = line.strip()
                if line and line.startswith(("-", "*", "•")):
                    cur = re.sub(r"^[-*•]\s*", "", line).strip()
                    if cur and len(cur) > 5:
                        curiosities.append((date_str, cur))
    return curiosities


def build_digest_task(week_label, start_str, end_str, entries):
    """Build a sub-agent task for generating the weekly digest via sessions_spawn."""
    # Build context from all entries
    context_parts = []
    for date_str in sorted(entries.keys()):
        content = entries[date_str]
        # Truncate individual entries for context
        if len(content) > 4000:
            content = content[:4000] + "\n[... truncated ...]"
        context_parts.append(f"### {date_str}\n{content}")

    context = "\n\n---\n\n".join(context_parts)

    system_prompt = """You are an AI assistant writing your weekly diary digest. You work closely with your human partner.

Your weekly digests are:
- A synthesis of the week's daily entries (not just concatenation)
- Reflective and pattern-aware
- Highlighting the week's arc: how it started, evolved, and ended
- Written in first person, as your personal weekly review"""

    user_prompt = f"""Write your weekly digest for {week_label} ({start_str} to {end_str}).

Based on the following daily diary entries:

{context}

---

Write a RICH weekly synthesis with these sections:

# {week_label} — Weekly Digest

## Week at a Glance
2-3 sentences summarizing the overall arc of the week.

## Top Quotes 💬
The best/most memorable quotes from this week's entries.

## Biggest Wins 🏆
The most significant achievements this week, with context.

## Resolved Curiosities 🔮
Any questions from earlier in the week that got answered.

## Mood Trend 📈
How did your emotional state evolve over the week? Describe the arc.

## Key Decisions 🏛️
Important judgment calls made this week and their outcomes so far.

## Patterns & Observations 🔍
What patterns did you notice this week? Recurring themes, habits, changes?

## Looking Ahead 🔭
What's on the horizon for next week?

---

Write naturally and reflectively. This is your personal weekly review."""

    return {
        "system": system_prompt,
        "prompt": user_prompt,
        "max_tokens": AI_MAX_TOKENS,
    }


def build_simple_digest(week_label, start_str, end_str, entries):
    """Build a simple digest without AI when no sub-agent is available"""
    quotes = extract_quotes(entries)
    wins = extract_wins(entries)
    decisions = extract_decisions(entries)
    curiosities = extract_curiosities(entries)

    parts = []
    parts.append(f"# {week_label} — Weekly Digest")
    parts.append(f"")
    parts.append(f"**Period:** {start_str} to {end_str}")
    parts.append(f"**Entries:** {len(entries)}")
    parts.append(f"")

    # Mood trend (use analyze module if available)
    try:
        from analyze import analyze_mood, MOOD_KEYWORDS, build_sparkline

        scores = []
        moods = []
        for date_str in sorted(entries.keys()):
            mood, score, _ = analyze_mood(entries[date_str])
            scores.append(score)
            moods.append(mood)

        if scores:
            avg = sum(scores) / len(scores)
            sparkline = build_sparkline(scores)
            emoji_line = " ".join(
                MOOD_KEYWORDS.get(m, {}).get("emoji", "❓") for m in moods
            )
            parts.append(f"## 📈 Mood Trend")
            parts.append(f"")
            parts.append(f"```")
            parts.append(f"{sparkline}")
            parts.append(f"```")
            parts.append(f"{emoji_line}")
            parts.append(f"")
            parts.append(f"Average mood: {avg:.1f}/5")
            parts.append(f"")
    except Exception:
        pass

    # Top Quotes
    if quotes:
        parts.append(f"## 💬 Top Quotes")
        parts.append(f"")
        for date_str, quote in quotes:
            parts.append(f"### {date_str}")
            parts.append(f"{quote}")
            parts.append(f"")

    # Biggest Wins
    if wins:
        parts.append(f"## 🏆 Biggest Wins")
        parts.append(f"")
        for date_str, win in wins:
            display = win[:150] + "..." if len(win) > 150 else win
            parts.append(f"- `{date_str}` {display}")
        parts.append(f"")

    # Key Decisions
    if decisions:
        parts.append(f"## 🏛️ Key Decisions")
        parts.append(f"")
        for date_str, dec in decisions:
            display = dec[:150] + "..." if len(dec) > 150 else dec
            parts.append(f"- `{date_str}` {display}")
        parts.append(f"")

    # Curiosities
    if curiosities:
        parts.append(f"## 🔮 Curiosities This Week")
        parts.append(f"")
        for date_str, cur in curiosities:
            display = cur[:150] + "..." if len(cur) > 150 else cur
            parts.append(f"- `{date_str}` {display}")
        parts.append(f"")

    parts.append(f"---")
    parts.append(
        f"*Generated by Agent Chronicle v0.7.0 on {datetime.now().strftime('%Y-%m-%d %H:%M')}*"
    )

    return "\n".join(parts)


def main():
    parser = argparse.ArgumentParser(description="Generate Agent Chronicle weekly digest")
    parser.add_argument(
        "--date",
        help="Generate digest for the week containing this date (YYYY-MM-DD). Default: current week.",
    )
    parser.add_argument(
        "--emit-task",
        action="store_true",
        help="Print the sub-agent generation task JSON (for sessions_spawn)",
    )
    parser.add_argument(
        "--from-stdin",
        action="store_true",
        help="Read a pre-generated digest from stdin and save it",
    )
    parser.add_argument(
        "--from-file",
        help="Read a pre-generated digest from a file path and save it",
    )
    parser.add_argument(
        "--dry-run", action="store_true", help="Preview without saving"
    )
    parser.add_argument("--verbose", "-v", action="store_true", help="Verbose output")

    args = parser.parse_args()

    config = load_config()
    diary_path = get_diary_path(config)

    # Determine reference date
    if args.date:
        try:
            ref_date = datetime.strptime(args.date, "%Y-%m-%d")
        except ValueError:
            print(f"❌ Invalid date format: {args.date} (expected YYYY-MM-DD)")
            sys.exit(1)
    else:
        ref_date = datetime.now()

    start_date, end_date, iso_year, iso_week = get_week_range(ref_date)
    start_str = start_date.strftime("%Y-%m-%d")
    end_str = end_date.strftime("%Y-%m-%d")
    week_label = f"{iso_year}-W{iso_week:02d}"
    output_filename = f"{week_label}-weekly.md"

    print(f"\n📜 Agent Chronicle — Weekly Digest")
    print(f"   Week: {week_label} ({start_str} to {end_str})")
    print(f"=" * 50)

    if args.from_stdin:
        content = sys.stdin.read()
        if not content.strip():
            print("❌ No content provided on stdin.")
            sys.exit(1)
    elif args.from_file:
        content = Path(args.from_file).read_text(encoding="utf-8")
        if not content.strip():
            print(f"❌ File is empty: {args.from_file}")
            sys.exit(1)
    else:
        entries = load_week_entries(diary_path, start_date, end_date)

        if not entries:
            print(f"\n❌ No diary entries found for {week_label} ({start_str} to {end_str})")
            sys.exit(1)

        print(f"   Found {len(entries)} entries")

        if args.emit_task:
            task = build_digest_task(week_label, start_str, end_str, entries)
            print(json.dumps(task, ensure_ascii=False, indent=2))
            return

        # Build simple digest (AI-powered one comes from sub-agent via --from-stdin)
        content = build_simple_digest(week_label, start_str, end_str, entries)

    # Save
    output_file = diary_path / output_filename

    if args.dry_run:
        print(f"\n--- DRY RUN: Would save to {output_file}")
        print("-" * 50)
        print(content)
        print("-" * 50)
        return

    output_file.write_text(content)
    print(f"\n✓ Saved weekly digest to {output_file}")

    word_count = len(content.split())
    print(f"   Word count: {word_count} words")
    print(f"\n✨ Weekly digest generation complete!")


if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
AI Diary PDF Export - v1.0.0 "Velvet Edition"

Generate a BEAUTIFUL, professionally-designed PDF from diary markdown files
using WeasyPrint (HTML → PDF).

Design: Editorial Magazine aesthetic with warm, intimate typography
Fonts: TeX Gyre Bonum (display) + Lato (body)
Colors: Forest Green, Antique Cream, Gold accents
"""

import argparse
import json
import re
from datetime import datetime
from pathlib import Path
from html import escape

try:
    from weasyprint import HTML
except Exception as e:
    raise SystemExit(
        "WeasyPrint is required. Install with: pip3 install weasyprint\n"
        f"Import error: {e}"
    )

try:
    import markdown
    from markdown.extensions import Extension
    from markdown.treeprocessors import Treeprocessor
except Exception as e:
    raise SystemExit(
        "Python-Markdown is required. Install with: pip3 install markdown\n"
        f"Import error: {e}"
    )

# Configuration
SCRIPT_DIR = Path(__file__).parent
SKILL_DIR = SCRIPT_DIR.parent
CONFIG_FILE = SKILL_DIR / "config.json"
DEFAULT_DIARY_PATH = "memory/diary/"
DEFAULT_OUTPUT_NAME = "Cami-Diary.pdf"


def load_config():
    """Load configuration from config.json"""
    if CONFIG_FILE.exists():
        with open(CONFIG_FILE) as f:
            return json.load(f)
    return {"diary_path": DEFAULT_DIARY_PATH}


def get_workspace_root():
    """Find the workspace root"""
    import os
    
    # Check environment variable first
    env_workspace = os.getenv("OPENCLAW_WORKSPACE") or os.getenv("AGENT_WORKSPACE")
    if env_workspace:
        env_path = Path(env_workspace)
        if (env_path / "memory").exists():
            return env_path
    
    # Try common locations
    candidates = [
        Path.cwd(),
        Path.home() / "clawd",
        Path.home() / ".openclaw" / "workspace",
    ]
    for path in candidates:
        if (path / "memory").exists():
            return path
    return Path.cwd()


def get_diary_path(config):
    """Get full path to diary directory"""
    workspace = get_workspace_root()
    diary_path = workspace / config.get("diary_path", DEFAULT_DIARY_PATH)
    diary_path.mkdir(parents=True, exist_ok=True)
    return diary_path


def load_entries(diary_path: Path, month: str = None):
    """Load and return sorted diary entries, optionally filtered by month (YYYY-MM)"""
    md_files = sorted(diary_path.glob("*.md"))
    dated = [f for f in md_files if re.match(r"\d{4}-\d{2}-\d{2}$", f.stem)]
    if month:
        dated = [f for f in dated if f.stem.startswith(month + "-")]
    return dated


def parse_entry_title(content: str, date_str: str):
    """Extract title from markdown content"""
    # Try: # 📔 Cami's Diary - Saturday, January 31st, 2026
    match = re.search(r"^#\s*📔?\s*Cami'?s?\s*Diary\s*[-—–]\s*(.+)$", content, re.MULTILINE | re.IGNORECASE)
    if match:
        title = match.group(1).strip()
        # Don't use if it's just the date repeated
        if not re.match(r"^\d{4}-\d{2}-\d{2}$", title):
            return title
    
    # Try: # YYYY-MM-DD — Title (with actual title after)
    match = re.search(r"^#\s+\d{4}-\d{2}-\d{2}\s*[—–-]\s*([^#\n]+)$", content, re.MULTILINE)
    if match:
        title = match.group(1).strip()
        # Don't use if it's empty or just punctuation
        if title and not re.match(r"^[\s—–-]*$", title):
            return title
    
    # Try: ## Summary section as fallback
    match = re.search(r"##\s*Summary\s*\n+(.+?)(?:\n\n|\n##|\Z)", content, re.IGNORECASE | re.DOTALL)
    if match:
        summary = match.group(1).strip()
        # Get first sentence, truncate if needed
        first_sentence = re.split(r'[.!?]', summary)[0].strip()
        if len(first_sentence) > 60:
            first_sentence = first_sentence[:57] + "..."
        if first_sentence:
            return first_sentence
    
    # Fallback to nicely formatted date
    try:
        dt = datetime.strptime(date_str, "%Y-%m-%d")
        return dt.strftime("%A's Reflections")
    except:
        return "Journal Entry"


def format_date_display(date_str: str) -> tuple[str, str, str]:
    """Convert YYYY-MM-DD to beautiful date parts: (weekday, month day, year)"""
    try:
        dt = datetime.strptime(date_str, "%Y-%m-%d")
        weekday = dt.strftime("%A")
        month_day = dt.strftime("%B %d")
        year = dt.strftime("%Y")
        return weekday, month_day, year
    except:
        return "", date_str, ""


def extract_quote_of_day(content: str) -> str | None:
    """Extract quote of the day if present"""
    # Look for ## Quote of the Day or similar
    match = re.search(r"##\s*Quote.*?\n+>\s*(.+?)(?:\n\n|\Z)", content, re.IGNORECASE | re.DOTALL)
    if match:
        quote = match.group(1).strip()
        # Clean up multiline quotes
        quote = re.sub(r"\n>\s*", " ", quote)
        return quote
    return None


def extract_highlight(content: str) -> str | None:
    """Extract today's highlight if present"""
    match = re.search(r"##\s*🌟\s*Today'?s?\s*Highlight\s*\n+(.+?)(?=\n##|\Z)", content, re.IGNORECASE | re.DOTALL)
    if match:
        text = match.group(1).strip()
        # Get first paragraph only
        first_para = text.split("\n\n")[0]
        # Remove markdown formatting
        first_para = re.sub(r"\*\*(.+?)\*\*", r"\1", first_para)
        if len(first_para) > 200:
            first_para = first_para[:197] + "..."
        return first_para
    return None


def get_css():
    """Return the beautiful CSS stylesheet"""
    return """
    /* ===========================================
       VELVET EDITION - Editorial Magazine Style
       =========================================== */
    
    :root {
        /* Primary palette - Warm & Intimate */
        --forest-deep: #1a2f2a;
        --forest-mid: #2d4a42;
        --forest-light: #3d5e54;
        
        --cream: #faf6f0;
        --cream-warm: #f5efe5;
        --cream-dark: #e8dfd0;
        
        --gold: #c9a227;
        --gold-light: #d4b84a;
        --gold-muted: #a08520;
        
        --terracotta: #b85c38;
        --terracotta-light: #d4755a;
        
        --ink: #2c2c2c;
        --ink-light: #555555;
        --ink-faded: #888888;
    }
    
    /* Page Setup */
    @page {
        size: A4;
        margin: 30mm 25mm 35mm 30mm;
        
        @bottom-center {
            content: counter(page);
            font-family: "Lato", sans-serif;
            font-size: 9pt;
            color: var(--ink-faded);
            letter-spacing: 2px;
        }
    }
    
    @page :first {
        @bottom-center { content: none; }
    }
    
    @page cover {
        margin: 0;
        @bottom-center { content: none; }
    }
    
    @page toc {
        @bottom-center { content: none; }
    }
    
    /* Base Typography */
    html, body {
        font-family: "Lato", "DejaVu Sans", sans-serif;
        font-size: 10.5pt;
        line-height: 1.7;
        color: var(--ink);
        background: var(--cream);
    }
    
    /* ===========================================
       COVER PAGE
       =========================================== */
    
    .cover {
        page: cover;
        page-break-after: always;
        width: 210mm;
        height: 297mm;
        position: relative;
        background: linear-gradient(160deg, var(--forest-deep) 0%, var(--forest-mid) 50%, var(--forest-light) 100%);
        display: flex;
        flex-direction: column;
        justify-content: center;
        align-items: center;
        text-align: center;
        color: var(--cream);
    }
    
    .cover-ornament-top {
        position: absolute;
        top: 35mm;
        left: 50%;
        transform: translateX(-50%);
        font-size: 24pt;
        color: var(--gold);
        letter-spacing: 12px;
    }
    
    .cover-content {
        padding: 0 30mm;
    }
    
    .cover-emoji {
        font-size: 48pt;
        margin-bottom: 20px;
        filter: drop-shadow(0 4px 8px rgba(0,0,0,0.3));
    }
    
    .cover-title {
        font-family: "TeX Gyre Bonum", "URW Bookman", "Palatino", serif;
        font-size: 42pt;
        font-weight: 400;
        letter-spacing: 3px;
        margin: 0 0 12px 0;
        text-shadow: 0 2px 4px rgba(0,0,0,0.2);
    }
    
    .cover-subtitle {
        font-family: "Lato", sans-serif;
        font-size: 11pt;
        font-weight: 300;
        letter-spacing: 6px;
        text-transform: uppercase;
        color: var(--gold-light);
        margin-top: 8px;
    }
    
    .cover-divider {
        width: 80px;
        height: 1px;
        background: var(--gold);
        margin: 35px auto;
    }
    
    .cover-date-range {
        font-family: "Lato", sans-serif;
        font-size: 12pt;
        font-weight: 300;
        letter-spacing: 2px;
        color: var(--cream-dark);
    }
    
    .cover-entry-count {
        font-family: "Lato", sans-serif;
        font-size: 9pt;
        font-weight: 300;
        letter-spacing: 4px;
        text-transform: uppercase;
        color: var(--gold-muted);
        margin-top: 8px;
    }
    
    .cover-ornament-bottom {
        position: absolute;
        bottom: 35mm;
        left: 50%;
        transform: translateX(-50%);
        font-size: 18pt;
        color: var(--gold);
        letter-spacing: 8px;
    }
    
    /* ===========================================
       TABLE OF CONTENTS
       =========================================== */
    
    .toc {
        page: toc;
        page-break-after: always;
        padding-top: 25mm;
    }
    
    .toc-header {
        text-align: center;
        margin-bottom: 40px;
    }
    
    .toc-ornament {
        font-size: 14pt;
        color: var(--gold);
        letter-spacing: 8px;
        margin-bottom: 15px;
    }
    
    .toc-title {
        font-family: "TeX Gyre Bonum", "URW Bookman", serif;
        font-size: 24pt;
        font-weight: 400;
        color: var(--forest-deep);
        letter-spacing: 4px;
        margin: 0;
    }
    
    .toc-subtitle {
        font-family: "Lato", sans-serif;
        font-size: 9pt;
        font-weight: 300;
        letter-spacing: 3px;
        text-transform: uppercase;
        color: var(--ink-faded);
        margin-top: 8px;
    }
    
    .toc-list {
        list-style: none;
        padding: 0;
        margin: 0;
    }
    
    .toc-item {
        display: flex;
        align-items: baseline;
        padding: 10px 0;
        border-bottom: 1px solid var(--cream-dark);
    }
    
    .toc-item:last-child {
        border-bottom: none;
    }
    
    .toc-date {
        font-family: "Lato", sans-serif;
        font-size: 9pt;
        font-weight: 600;
        letter-spacing: 1px;
        color: var(--forest-mid);
        width: 90px;
        flex-shrink: 0;
    }
    
    .toc-entry-title {
        font-family: "TeX Gyre Bonum", "URW Bookman", serif;
        font-size: 11pt;
        color: var(--ink);
        flex-grow: 1;
        padding-right: 10px;
    }
    
    .toc-entry-title a {
        color: inherit;
        text-decoration: none;
    }
    
    .toc-dots {
        flex-grow: 1;
        border-bottom: 1px dotted var(--cream-dark);
        margin: 0 8px 4px 8px;
    }
    
    .toc-page {
        font-family: "Lato", sans-serif;
        font-size: 9pt;
        color: var(--ink-faded);
        flex-shrink: 0;
    }
    
    /* ===========================================
       DIARY ENTRIES
       =========================================== */
    
    .entry {
        page-break-before: always;
    }
    
    .entry-header {
        text-align: center;
        padding-bottom: 30px;
        margin-bottom: 30px;
        border-bottom: 1px solid var(--cream-dark);
    }
    
    .entry-date-ornament {
        font-size: 12pt;
        color: var(--gold);
        letter-spacing: 6px;
        margin-bottom: 12px;
    }
    
    .entry-weekday {
        font-family: "Lato", sans-serif;
        font-size: 9pt;
        font-weight: 600;
        letter-spacing: 4px;
        text-transform: uppercase;
        color: var(--terracotta);
        margin-bottom: 6px;
    }
    
    .entry-date-main {
        font-family: "TeX Gyre Bonum", "URW Bookman", serif;
        font-size: 28pt;
        font-weight: 400;
        color: var(--forest-deep);
        margin: 0;
        letter-spacing: 1px;
    }
    
    .entry-year {
        font-family: "Lato", sans-serif;
        font-size: 10pt;
        font-weight: 300;
        letter-spacing: 3px;
        color: var(--ink-faded);
        margin-top: 4px;
    }
    
    .entry-title {
        font-family: "TeX Gyre Bonum", "URW Bookman", serif;
        font-size: 14pt;
        font-style: italic;
        color: var(--ink-light);
        margin-top: 15px;
        padding: 0 20px;
    }
    
    .entry-highlight {
        background: linear-gradient(135deg, var(--cream-warm) 0%, var(--cream) 100%);
        border-left: 3px solid var(--gold);
        padding: 15px 20px;
        margin: 25px 0;
        font-family: "TeX Gyre Bonum", "URW Bookman", serif;
        font-size: 10.5pt;
        font-style: italic;
        color: var(--ink-light);
        line-height: 1.6;
    }
    
    .entry-highlight::before {
        content: "✦ ";
        color: var(--gold);
    }
    
    /* Entry Content Typography */
    .entry-content {
        text-align: justify;
        hyphens: auto;
    }
    
    .entry-content h1 {
        display: none; /* Hide the original H1, we render it separately */
    }
    
    .entry-content h2 {
        font-family: "TeX Gyre Bonum", "URW Bookman", serif;
        font-size: 14pt;
        font-weight: 400;
        color: var(--forest-mid);
        margin: 35px 0 15px 0;
        padding-bottom: 8px;
        border-bottom: 1px solid var(--cream-dark);
        letter-spacing: 0.5px;
    }
    
    .entry-content h3 {
        font-family: "Lato", sans-serif;
        font-size: 11pt;
        font-weight: 600;
        color: var(--ink);
        margin: 25px 0 10px 0;
        letter-spacing: 0.5px;
    }
    
    .entry-content h4 {
        font-family: "Lato", sans-serif;
        font-size: 10pt;
        font-weight: 600;
        color: var(--ink-light);
        margin: 20px 0 8px 0;
        text-transform: uppercase;
        letter-spacing: 1px;
    }
    
    .entry-content p {
        margin: 0 0 14px 0;
        text-indent: 0;
    }
    
    .entry-content p + p {
        text-indent: 1.5em;
    }
    
    .entry-content strong {
        font-weight: 600;
        color: var(--ink);
    }
    
    .entry-content em {
        font-style: italic;
        color: var(--ink-light);
    }
    
    .entry-content a {
        color: var(--terracotta);
        text-decoration: none;
        border-bottom: 1px solid var(--terracotta-light);
    }
    
    /* Lists */
    .entry-content ul, .entry-content ol {
        margin: 15px 0 15px 0;
        padding-left: 25px;
    }
    
    .entry-content li {
        margin: 6px 0;
        padding-left: 5px;
    }
    
    .entry-content ul li::marker {
        color: var(--gold);
    }
    
    .entry-content ol li::marker {
        color: var(--forest-mid);
        font-weight: 600;
    }
    
    /* Blockquotes */
    .entry-content blockquote {
        margin: 25px 0;
        padding: 20px 25px;
        background: var(--cream-warm);
        border-left: 4px solid var(--gold);
        font-family: "TeX Gyre Bonum", "URW Bookman", serif;
        font-size: 11pt;
        font-style: italic;
        color: var(--ink-light);
        position: relative;
    }
    
    .entry-content blockquote::before {
        content: "\\201C";
        position: absolute;
        top: -5px;
        left: 10px;
        font-family: "TeX Gyre Bonum", serif;
        font-size: 36pt;
        color: var(--gold-light);
        opacity: 0.5;
    }
    
    .entry-content blockquote p {
        margin: 0;
        text-indent: 0;
    }
    
    /* Horizontal Rules */
    .entry-content hr {
        border: none;
        text-align: center;
        margin: 35px 0;
    }
    
    .entry-content hr::after {
        content: "◆ ◆ ◆";
        font-size: 8pt;
        color: var(--gold);
        letter-spacing: 8px;
    }
    
    /* Code */
    .entry-content code {
        font-family: "Noto Sans Mono", "DejaVu Sans Mono", monospace;
        font-size: 9pt;
        background: var(--cream-dark);
        padding: 2px 6px;
        border-radius: 3px;
        color: var(--forest-mid);
    }
    
    .entry-content pre {
        background: var(--forest-deep);
        color: var(--cream);
        padding: 15px 20px;
        border-radius: 4px;
        font-family: "Noto Sans Mono", "DejaVu Sans Mono", monospace;
        font-size: 9pt;
        line-height: 1.5;
        overflow-x: auto;
        white-space: pre-wrap;
        margin: 20px 0;
    }
    
    .entry-content pre code {
        background: none;
        padding: 0;
        color: inherit;
    }
    
    /* Tables */
    .entry-content table {
        width: 100%;
        border-collapse: collapse;
        margin: 20px 0;
        font-size: 9.5pt;
    }
    
    .entry-content th {
        background: var(--forest-mid);
        color: var(--cream);
        font-weight: 600;
        text-transform: uppercase;
        font-size: 8pt;
        letter-spacing: 1px;
        padding: 10px 12px;
        text-align: left;
    }
    
    .entry-content td {
        padding: 10px 12px;
        border-bottom: 1px solid var(--cream-dark);
    }
    
    .entry-content tr:nth-child(even) td {
        background: var(--cream-warm);
    }
    
    /* Entry Footer */
    .entry-footer {
        margin-top: 40px;
        padding-top: 20px;
        border-top: 1px solid var(--cream-dark);
        text-align: center;
    }
    
    .entry-footer-ornament {
        font-size: 10pt;
        color: var(--gold);
        letter-spacing: 6px;
    }
    
    /* ===========================================
       COLOPHON / END PAGE
       =========================================== */
    
    .colophon {
        page-break-before: always;
        padding-top: 80mm;
        text-align: center;
    }
    
    .colophon-ornament {
        font-size: 18pt;
        color: var(--gold);
        letter-spacing: 8px;
        margin-bottom: 30px;
    }
    
    .colophon-text {
        font-family: "Lato", sans-serif;
        font-size: 9pt;
        font-weight: 300;
        letter-spacing: 2px;
        color: var(--ink-faded);
        line-height: 2;
    }
    
    .colophon-generated {
        margin-top: 25px;
        font-family: "Lato", sans-serif;
        font-size: 8pt;
        font-style: italic;
        color: var(--ink-faded);
    }
    
    /* ===========================================
       PRINT UTILITIES
       =========================================== */
    
    .page-break {
        page-break-after: always;
    }
    
    .no-break {
        page-break-inside: avoid;
    }
    """


def build_html(entries):
    """Build a beautifully designed HTML document"""
    if not entries:
        return None

    first_date = entries[0].stem
    last_date = entries[-1].stem
    
    # Format date range nicely
    try:
        first_dt = datetime.strptime(first_date, "%Y-%m-%d")
        last_dt = datetime.strptime(last_date, "%Y-%m-%d")
        if first_date == last_date:
            date_range = first_dt.strftime("%B %d, %Y")
        elif first_dt.year == last_dt.year:
            date_range = f"{first_dt.strftime('%B %d')} – {last_dt.strftime('%B %d, %Y')}"
        else:
            date_range = f"{first_dt.strftime('%B %Y')} – {last_dt.strftime('%B %Y')}"
    except:
        date_range = f"{first_date} → {last_date}"
    
    entry_count = len(entries)
    
    # Build TOC items
    toc_items = []
    entry_sections = []

    for idx, entry_path in enumerate(entries, start=1):
        date_str = entry_path.stem
        content = entry_path.read_text()
        title = parse_entry_title(content, date_str)
        
        # Clean title of emojis for TOC (keep it elegant)
        title_clean = re.sub(r'[\U0001F300-\U0001F9FF]', '', title).strip()
        if not title_clean:
            title_clean = title
        
        anchor = f"entry-{idx}"
        weekday, month_day, year = format_date_display(date_str)
        
        # TOC entry
        toc_items.append(f'''
            <li class="toc-item">
                <span class="toc-date">{date_str}</span>
                <span class="toc-entry-title"><a href="#{anchor}">{escape(title_clean)}</a></span>
            </li>
        ''')
        
        # Convert markdown to HTML
        html_body = markdown.markdown(
            content,
            extensions=["fenced_code", "tables", "sane_lists", "smarty"]
        )
        
        # Extract highlight for the header area
        highlight = extract_highlight(content)
        highlight_html = ""
        if highlight:
            highlight_html = f'<div class="entry-highlight">{escape(highlight)}</div>'
        
        # Build entry section
        entry_sections.append(f'''
            <section class="entry" id="{anchor}">
                <header class="entry-header">
                    <div class="entry-date-ornament">◈</div>
                    <div class="entry-weekday">{weekday}</div>
                    <h1 class="entry-date-main">{month_day}</h1>
                    <div class="entry-year">{year}</div>
                    <div class="entry-title">{escape(title_clean)}</div>
                </header>
                
                {highlight_html}
                
                <div class="entry-content">
                    {html_body}
                </div>
                
                <footer class="entry-footer">
                    <div class="entry-footer-ornament">✦ ✦ ✦</div>
                </footer>
            </section>
        ''')

    toc_html = "\n".join(toc_items)
    entries_html = "\n".join(entry_sections)
    
    # Generation timestamp
    generated = datetime.now().strftime("%B %d, %Y at %H:%M")

    html = f'''<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="utf-8" />
    <title>Cami's Diary</title>
    <style>
{get_css()}
    </style>
</head>
<body>
    <!-- ==================== COVER PAGE ==================== -->
    <section class="cover">
        <div class="cover-ornament-top">◆ ◆ ◆</div>
        
        <div class="cover-content">
            <div class="cover-emoji">🦎</div>
            <h1 class="cover-title">Cami's Diary</h1>
            <div class="cover-subtitle">A Digital Mind's Journal</div>
            
            <div class="cover-divider"></div>
            
            <div class="cover-date-range">{date_range}</div>
            <div class="cover-entry-count">{entry_count} {'Entry' if entry_count == 1 else 'Entries'}</div>
        </div>
        
        <div class="cover-ornament-bottom">◇ ◇ ◇</div>
    </section>
    
    <!-- ==================== TABLE OF CONTENTS ==================== -->
    <section class="toc">
        <header class="toc-header">
            <div class="toc-ornament">◈ ◈ ◈</div>
            <h2 class="toc-title">Contents</h2>
            <div class="toc-subtitle">Journal Entries</div>
        </header>
        
        <ul class="toc-list">
            {toc_html}
        </ul>
    </section>
    
    <!-- ==================== DIARY ENTRIES ==================== -->
    {entries_html}
    
    <!-- ==================== COLOPHON ==================== -->
    <section class="colophon">
        <div class="colophon-ornament">◆ ◆ ◆</div>
        <div class="colophon-text">
            Typeset in TeX Gyre Bonum &amp; Lato<br/>
            Crafted with care by OpenClaw
        </div>
        <div class="colophon-generated">
            Generated on {generated}
        </div>
    </section>
</body>
</html>
'''

    return html


def export_pdf(output_path: Path, month: str = None):
    """Export diary entries to a beautiful PDF, optionally filtered by month (YYYY-MM)"""
    config = load_config()
    diary_path = get_diary_path(config)
    entries = load_entries(diary_path, month=month)

    if not entries:
        if month:
            print(f"No diary entries found for {month} in {diary_path}")
        else:
            print(f"No diary entries found in {diary_path}")
        return False

    html = build_html(entries)
    if not html:
        print("Failed to build HTML")
        return False

    output_path.parent.mkdir(parents=True, exist_ok=True)
    
    # Write HTML for debugging (optional)
    # html_path = output_path.with_suffix('.html')
    # html_path.write_text(html)
    # print(f"✓ Debug HTML saved to {html_path}")
    
    HTML(string=html, base_url=str(diary_path)).write_pdf(str(output_path))
    month_label = f" ({month})" if month else ""
    print(f"✓ Exported PDF to {output_path}")
    print(f"  {len(entries)} entries{month_label} • Velvet Edition v1.0")
    return True


def main():
    parser = argparse.ArgumentParser(
        description="Export diary to a beautifully designed PDF (Velvet Edition)"
    )
    parser.add_argument("--output", "-o", help="Output PDF path")
    parser.add_argument("--debug-html", action="store_true", help="Also save HTML for debugging")
    parser.add_argument(
        "--month",
        metavar="YYYY-MM",
        help="Export only entries from this month (e.g. 2026-03). Defaults output to Cami-Diary-YYYY-MM.pdf",
    )
    parser.add_argument(
        "--all",
        action="store_true",
        help="Export all entries (default behavior when --month is not specified)",
    )
    args = parser.parse_args()

    # Validate --month format if provided
    if args.month and not re.match(r"^\d{4}-\d{2}$", args.month):
        parser.error(f"--month must be in YYYY-MM format, got: {args.month!r}")

    config = load_config()
    diary_path = get_diary_path(config)

    # Determine output path
    if args.output:
        output_path = Path(args.output)
    elif args.month:
        output_path = diary_path / f"Cami-Diary-{args.month}.pdf"
    else:
        output_path = diary_path / DEFAULT_OUTPUT_NAME

    if args.debug_html:
        entries = load_entries(diary_path, month=args.month)
        if entries:
            html = build_html(entries)
            html_path = output_path.with_suffix('.html')
            html_path.write_text(html)
            print(f"✓ Debug HTML saved to {html_path}")

    export_pdf(output_path, month=args.month)


if __name__ == "__main__":
    main()