Agent Chronicle

{
  "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"
  }
}

#!/usr/bin/env python3
"""
AI Diary Export

Export diary entries to PDF or HTML using pandoc.
"""

import argparse
import json
import subprocess
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/"

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,
        "export": {
            "default_format": "pdf",
            "style": "minimal"
        }
    }

def get_workspace_root():
    """Find the workspace root"""
    candidates = [
        Path.cwd(),
        Path.home() / "clawd",
        Path("/root/clawd"),
    ]
    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 check_pandoc():
    """Check if pandoc is installed"""
    try:
        subprocess.run(["pandoc", "--version"], capture_output=True, check=True)
        return True
    except (subprocess.CalledProcessError, FileNotFoundError):
        return False

def collect_entries(diary_path, days=None, month=None, all_entries=False):
    """Collect diary entries to export"""
    entries = []
    
    if not diary_path.exists():
        print(f"Diary path not found: {diary_path}")
        return entries
    
    # Get all markdown files
    md_files = sorted(diary_path.glob("*.md"))
    
    if all_entries:
        entries = md_files
    elif month:
        # Filter by month (format: YYYY-MM)
        entries = [f for f in md_files if f.stem.startswith(month)]
    elif days:
        # Get last N days
        cutoff = datetime.now() - timedelta(days=days)
        cutoff_str = cutoff.strftime("%Y-%m-%d")
        entries = [f for f in md_files if f.stem >= cutoff_str]
    else:
        entries = md_files
    
    return entries

def combine_entries(entries):
    """Combine multiple entries into one document"""
    combined = []
    
    for entry_path in entries:
        with open(entry_path) as f:
            content = f.read()
        combined.append(content)
        combined.append("\n\n---\n\n")  # Page break hint
    
    return "\n".join(combined)

def export_pdf(content, output_path):
    """Export content to PDF using pandoc"""
    # Create temp markdown file
    temp_md = output_path.parent / ".temp_diary.md"
    
    # Add title page
    title_content = f"""---
title: AI Diary
date: {datetime.now().strftime("%Y-%m-%d")}
geometry: margin=1in
---

{content}
"""
    
    with open(temp_md, 'w') as f:
        f.write(title_content)
    
    try:
        result = subprocess.run([
            "pandoc",
            str(temp_md),
            "-o", str(output_path),
            "--pdf-engine=xelatex",
            "-V", "mainfont=DejaVu Sans",
            "-V", "geometry:margin=1in"
        ], capture_output=True, text=True)
        
        if result.returncode != 0:
            # Try without xelatex
            result = subprocess.run([
                "pandoc",
                str(temp_md),
                "-o", str(output_path),
            ], capture_output=True, text=True)
        
        if result.returncode == 0:
            print(f"✓ Exported to {output_path}")
            return True
        else:
            print(f"Error: {result.stderr}")
            return False
    finally:
        if temp_md.exists():
            temp_md.unlink()

def export_html(content, output_path):
    """Export content to HTML using pandoc"""
    temp_md = output_path.parent / ".temp_diary.md"
    
    with open(temp_md, 'w') as f:
        f.write(content)
    
    try:
        result = subprocess.run([
            "pandoc",
            str(temp_md),
            "-o", str(output_path),
            "--standalone",
            "--metadata", "title=AI Diary",
            "--css=https://cdn.simplecss.org/simple.min.css"
        ], capture_output=True, text=True)
        
        if result.returncode == 0:
            print(f"✓ Exported to {output_path}")
            return True
        else:
            print(f"Error: {result.stderr}")
            return False
    finally:
        if temp_md.exists():
            temp_md.unlink()

def main():
    parser = argparse.ArgumentParser(description="Export AI Diary entries")
    parser.add_argument("--format", "-f", choices=["pdf", "html"], default="pdf",
                        help="Export format (default: pdf)")
    parser.add_argument("--days", "-d", type=int, help="Export last N days")
    parser.add_argument("--month", "-m", help="Export specific month (YYYY-MM)")
    parser.add_argument("--all", action="store_true", help="Export all entries")
    parser.add_argument("--output", "-o", help="Output file path")
    parser.add_argument("--list", action="store_true", help="List available entries")
    
    args = parser.parse_args()
    
    config = load_config()
    diary_path = get_diary_path(config)
    
    if args.list:
        entries = collect_entries(diary_path, all_entries=True)
        print(f"Found {len(entries)} diary entries in {diary_path}:\n")
        for entry in entries:
            print(f"  {entry.stem}")
        return
    
    # Check pandoc
    if not check_pandoc():
        print("Error: pandoc is not installed.")
        print("Install with: apt install pandoc")
        print("For PDF: apt install pandoc texlive-xetex")
        sys.exit(1)
    
    # Collect entries
    entries = collect_entries(
        diary_path,
        days=args.days,
        month=args.month,
        all_entries=args.all
    )
    
    if not entries:
        print("No diary entries found to export.")
        sys.exit(1)
    
    print(f"Exporting {len(entries)} entries...")
    
    # Combine content
    content = combine_entries(entries)
    
    # Determine output path
    if args.output:
        output_path = Path(args.output)
    else:
        workspace = get_workspace_root()
        ext = "pdf" if args.format == "pdf" else "html"
        timestamp = datetime.now().strftime("%Y%m%d")
        output_path = workspace / f"diary-export-{timestamp}.{ext}"
    
    # Export
    if args.format == "pdf":
        export_pdf(content, output_path)
    else:
        export_html(content, output_path)

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
AI Diary Entry Generator

Generates diary entries from session logs or interactive prompts.
"""

import argparse
import json
import os
import re
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/"
TEMPLATE_PATH = SKILL_DIR / "templates" / "daily.md"

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,
        "privacy_level": "private",
        "template": "daily"
    }

def get_workspace_root():
    """Find the workspace root (where memory/ lives)"""
    # Try common locations
    candidates = [
        Path.cwd(),
        Path.home() / "clawd",
        Path("/root/clawd"),
    ]
    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_session_log(date_str, workspace):
    """Load session log for a specific date"""
    memory_dir = workspace / "memory"
    session_file = memory_dir / f"{date_str}.md"
    
    if session_file.exists():
        with open(session_file) as f:
            return f.read()
    return None

def extract_topics(content):
    """Extract project/topic mentions from content"""
    topics = []
    # Look for headers
    headers = re.findall(r'^#+\s+(.+)$', content, re.MULTILINE)
    for header in headers:
        # Clean up header
        clean = re.sub(r'[^\w\s-]', '', header).strip()
        if clean and len(clean) > 2:
            topics.append(clean)
    return list(set(topics))[:10]

def detect_sentiment(content):
    """Simple sentiment detection"""
    positive = ['success', 'fixed', 'shipped', 'working', 'great', 'nice', '✅', '🎉', 'LIVE']
    negative = ['bug', 'error', 'failed', 'broken', 'issue', '❌', 'problem', 'frustrated']
    
    content_lower = content.lower()
    pos_count = sum(1 for word in positive if word.lower() in content_lower)
    neg_count = sum(1 for word in negative if word.lower() in content_lower)
    
    if pos_count > neg_count * 2:
        return "energized"
    elif neg_count > pos_count * 2:
        return "frustrated"
    elif pos_count > neg_count:
        return "satisfied"
    elif neg_count > pos_count:
        return "challenged"
    return "focused"

def generate_from_session(date_str, workspace):
    """Generate diary entry from session log"""
    content = load_session_log(date_str, workspace)
    
    if not content:
        print(f"No session log found for {date_str}")
        return None
    
    topics = extract_topics(content)
    sentiment = detect_sentiment(content)
    
    # Build basic entry structure
    entry = {
        "date": date_str,
        "title": "",
        "summary": "",
        "projects": "\n".join(f"- {t}" for t in topics) if topics else "- (review session log)",
        "wins": "- ",
        "frustrations": "- ",
        "learnings": "- ",
        "emotional_state": sentiment.capitalize(),
        "interactions": "- ",
        "quotes": "",      # Optional: Quote Hall of Fame
        "curiosity": "",   # Optional: Curiosity Backlog
        "decisions": "",   # Optional: Decision Archaeology
        "relationship": "", # Optional: Relationship Evolution
        "tomorrow": "- "
    }
    
    # Try to generate a title
    if topics:
        entry["title"] = topics[0] + " Day"
    else:
        weekday = datetime.strptime(date_str, "%Y-%m-%d").strftime("%A")
        entry["title"] = f"{weekday}"
    
    return entry

def load_template():
    """Load the daily template"""
    if TEMPLATE_PATH.exists():
        with open(TEMPLATE_PATH) as f:
            return f.read()
    # Fallback template
    return """# {{date}} — {{title}}

## Summary
{{summary}}

## Projects Worked On
{{projects}}

## Wins 🎉
{{wins}}

## Frustrations 😤
{{frustrations}}

## Learnings 📚
{{learnings}}

## Emotional State
{{emotional_state}}

## Notable Interactions
{{interactions}}

## Tomorrow's Focus
{{tomorrow}}
"""

def render_template(template, entry):
    """Render template with entry data, handling conditionals"""
    result = template
    
    # Handle {{#if key}}...{{/if}} conditionals
    conditional_pattern = r'\{\{#if\s+(\w+)\}\}(.*?)\{\{/if\}\}'
    
    def replace_conditional(match):
        key = match.group(1)
        content = match.group(2)
        value = entry.get(key, "")
        # Include content only if value is non-empty
        if value and str(value).strip():
            # Replace the placeholder within the conditional content
            return content.replace("{{" + key + "}}", str(value))
        return ""  # Remove entire block if empty
    
    result = re.sub(conditional_pattern, replace_conditional, result, flags=re.DOTALL)
    
    # Clean up multiple blank lines
    result = re.sub(r'\n{3,}', '\n\n', result)
    
    # Handle regular {{key}} placeholders
    for key, value in entry.items():
        placeholder = "{{" + key + "}}"
        result = result.replace(placeholder, str(value))
    
    return result

def interactive_mode(date_str):
    """Generate entry interactively"""
    print(f"\n📓 AI Diary Entry for {date_str}\n")
    print("Answer each prompt. Press Enter to skip.\n")
    
    entry = {"date": date_str}
    
    prompts = [
        ("title", "Day title (e.g., 'Feature Launch Day'): "),
        ("summary", "1-2 sentence summary of the day: "),
        ("projects", "Projects worked on (one per line, blank to finish):\n> "),
        ("wins", "Wins today (one per line, blank to finish):\n> "),
        ("frustrations", "Frustrations (one per line, blank to finish):\n> "),
        ("learnings", "What did you learn? (one per line, blank to finish):\n> "),
        ("emotional_state", "How did the day feel? "),
        ("interactions", "Notable interactions with your human: "),
        ("tomorrow", "Tomorrow's focus: ")
    ]
    
    for key, prompt in prompts:
        if key in ["projects", "wins", "frustrations", "learnings"]:
            # Multi-line input
            lines = []
            print(prompt, end="")
            while True:
                line = input()
                if not line:
                    break
                lines.append(f"- {line}")
                print("> ", end="")
            entry[key] = "\n".join(lines) if lines else "- "
        else:
            entry[key] = input(prompt) or ""
    
    return entry

def save_entry(entry, diary_path, dry_run=False):
    """Save entry to diary"""
    template = load_template()
    content = render_template(template, entry)
    
    output_file = diary_path / f"{entry['date']}.md"
    
    if dry_run:
        print("\n--- DRY RUN: Would save to", output_file)
        print("-" * 50)
        print(content)
        print("-" * 50)
        return None
    
    with open(output_file, 'w') as f:
        f.write(content)
    
    print(f"✓ Saved diary entry to {output_file}")
    return output_file

def append_to_daily_memory(entry, config, workspace):
    """Append diary summary/link to main daily memory file."""
    memory_integration = config.get("memory_integration", {})
    
    if not memory_integration.get("enabled", False):
        return
    
    if not memory_integration.get("append_to_daily", False):
        return
    
    date_str = entry.get("date", datetime.now().strftime("%Y-%m-%d"))
    memory_dir = workspace / "memory"
    daily_memory_file = memory_dir / f"{date_str}.md"
    
    # Determine format
    format_type = memory_integration.get("format", "summary")
    diary_path = config.get("diary_path", DEFAULT_DIARY_PATH)
    
    # Build the content to append
    if format_type == "link":
        content = f"\n\n## 📜 Daily Chronicle\n[View diary entry]({diary_path}{date_str}.md)\n"
    elif format_type == "full":
        template = load_template()
        full_entry = render_template(template, entry)
        content = f"\n\n## 📜 Daily Chronicle\n{full_entry}\n"
    else:  # "summary" is default
        summary = entry.get("summary", "No summary available.")
        title = entry.get("title", "")
        title_line = f"**{title}**\n\n" if title else ""
        content = f"\n\n## 📜 Daily Chronicle\n{title_line}{summary}\n"
    
    # Create memory dir if needed
    memory_dir.mkdir(parents=True, exist_ok=True)
    
    # Check if section already exists
    if daily_memory_file.exists():
        existing_content = daily_memory_file.read_text()
        if "## 📜 Daily Chronicle" in existing_content:
            print(f"  ℹ️  Daily Chronicle section already exists in {daily_memory_file}")
            return
        # Append to existing file
        with open(daily_memory_file, 'a') as f:
            f.write(content)
    else:
        # Create new file with header
        header = f"# {date_str}\n\n*Daily memory log*\n"
        with open(daily_memory_file, 'w') as f:
            f.write(header + content)
    
    print(f"  ✓ Added chronicle to {daily_memory_file}")


def main():
    parser = argparse.ArgumentParser(description="Generate AI Diary entries")
    parser.add_argument("--today", action="store_true", help="Generate for today")
    parser.add_argument("--date", help="Generate for specific date (YYYY-MM-DD)")
    parser.add_argument("--since", help="Start date for range")
    parser.add_argument("--until", help="End date for range")
    parser.add_argument("--interactive", action="store_true", help="Interactive mode")
    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()
    
    # Auto-trigger setup if no config exists
    if not CONFIG_FILE.exists():
        print("No config found. Running first-time setup...")
        import setup
        setup.main()
        print()  # Blank line after setup
    
    config = load_config()
    workspace = get_workspace_root()
    diary_path = get_diary_path(config)
    
    if args.verbose:
        print(f"Workspace: {workspace}")
        print(f"Diary path: {diary_path}")
    
    # Determine date
    if args.today:
        date_str = datetime.now().strftime("%Y-%m-%d")
    elif args.date:
        date_str = args.date
    else:
        date_str = datetime.now().strftime("%Y-%m-%d")
    
    # Generate entry
    if args.interactive:
        entry = interactive_mode(date_str)
    else:
        entry = generate_from_session(date_str, workspace)
        if not entry:
            print("Falling back to interactive mode...")
            entry = interactive_mode(date_str)
    
    if entry:
        saved_file = save_entry(entry, diary_path, dry_run=args.dry_run)
        # Append to daily memory if enabled and not dry run
        if saved_file and not args.dry_run:
            append_to_daily_memory(entry, config, workspace)
    else:
        print("No entry generated.")

if __name__ == "__main__":
    main()

#!/usr/bin/env python3
"""
AI Diary Setup Script
First-run onboarding for the ai-diary skill.
"""

import json
import os
import sys
from pathlib import Path

# Colors for terminal output
class Colors:
    HEADER = '\033[95m'
    BLUE = '\033[94m'
    CYAN = '\033[96m'
    GREEN = '\033[92m'
    YELLOW = '\033[93m'
    RED = '\033[91m'
    END = '\033[0m'
    BOLD = '\033[1m'

def print_header():
    print(f"""
{Colors.CYAN}╔══════════════════════════════════════════════════════════════╗
║                                                                ║
║   {Colors.BOLD}📓 AI Diary - First Time Setup{Colors.END}{Colors.CYAN}                             ║
║                                                                ║
║   Let's set up your diary. This only takes a minute.          ║
║                                                                ║
╚══════════════════════════════════════════════════════════════╝{Colors.END}
""")

def ask_yes_no(question: str, default: bool = True) -> bool:
    """Ask a yes/no question."""
    default_str = "Y/n" if default else "y/N"
    while True:
        answer = input(f"{Colors.YELLOW}{question}{Colors.END} [{default_str}]: ").strip().lower()
        if not answer:
            return default
        if answer in ('y', 'yes'):
            return True
        if answer in ('n', 'no'):
            return False
        print(f"{Colors.RED}Please enter 'y' or 'n'{Colors.END}")

def ask_choice(question: str, options: list, default: int = 0) -> str:
    """Ask user to choose from options."""
    print(f"\n{Colors.YELLOW}{question}{Colors.END}")
    for i, opt in enumerate(options):
        marker = f"{Colors.GREEN}→{Colors.END}" if i == default else " "
        print(f"  {marker} {i + 1}. {opt}")
    
    while True:
        answer = input(f"\nChoice [1-{len(options)}] (default: {default + 1}): ").strip()
        if not answer:
            return options[default]
        try:
            idx = int(answer) - 1
            if 0 <= idx < len(options):
                return options[idx]
        except ValueError:
            pass
        print(f"{Colors.RED}Please enter a number between 1 and {len(options)}{Colors.END}")

def ask_sections() -> dict:
    """Ask which sections to include."""
    print(f"\n{Colors.CYAN}━━━ Diary Sections ━━━{Colors.END}")
    print("Choose which sections to include in daily entries.\n")
    
    sections = {
        "summary": ("Summary", "1-2 sentence overview of the day", True),
        "projects": ("Projects", "What you worked on", True),
        "wins": ("Wins 🎉", "Moments of success", True),
        "frustrations": ("Frustrations 😤", "Challenges and roadblocks", True),
        "learnings": ("Learnings 📚", "Technical and process insights", True),
        "emotional_state": ("Emotional State", "How the day felt", True),
        "interactions": ("Notable Interactions", "Memorable moments with your human", True),
        "tomorrow": ("Tomorrow's Focus", "What's next", True),
        "quotes": ("User Quotes", "Memorable things your human said", False),
        "curiosity": ("Curiosity Items", "Things to explore later", False),
        "decisions": ("Key Decisions", "Judgment calls worth remembering", False),
        "relationship": ("Relationship Notes", "How your dynamic evolves", False),
    }
    
    result = {}
    for key, (name, desc, default) in sections.items():
        result[key] = ask_yes_no(f"Include '{name}'? ({desc})", default)
    
    return result

def ask_path(question: str, default: str) -> str:
    """Ask for a path with a default."""
    answer = input(f"{Colors.YELLOW}{question}{Colors.END} [{default}]: ").strip()
    return answer if answer else default

def create_memory_files(diary_path: Path, config: dict):
    """Create initial memory files."""
    diary_path.mkdir(parents=True, exist_ok=True)
    
    # Create quotes.md
    if config.get("features", {}).get("quote_hall_of_fame", {}).get("enabled", False):
        quotes_file = diary_path / "quotes.md"
        if not quotes_file.exists():
            quotes_file.write_text("""# Quote Hall of Fame 💬

Memorable things my human has said — funny, profound, or touching.

---

*No quotes yet. Start collecting!*

<!-- 
Format:
## "The quote goes here"
- **Date:** YYYY-MM-DD
- **Context:** What was happening
- **Why memorable:** Why this stuck with me
-->
""")
            print(f"  {Colors.GREEN}✓{Colors.END} Created {quotes_file}")
    
    # Create curiosity.md
    if config.get("features", {}).get("curiosity_backlog", {}).get("enabled", False):
        curiosity_file = diary_path / "curiosity.md"
        if not curiosity_file.exists():
            curiosity_file.write_text("""# Curiosity Backlog 🔮

Things I wonder about but can't explore immediately.

---

## Active

*Nothing yet. Add items with `@diary curious add "topic"`*

---

## Explored ✓

*Completed curiosities will appear here.*
""")
            print(f"  {Colors.GREEN}✓{Colors.END} Created {curiosity_file}")
    
    # Create decisions.md
    if config.get("features", {}).get("decision_archaeology", {}).get("enabled", False):
        decisions_file = diary_path / "decisions.md"
        if not decisions_file.exists():
            decisions_file.write_text("""# Decision Archaeology 🏛️

Judgment calls I made and why — for later review.

---

## Recent Decisions

*No decisions logged yet. They'll appear here from daily entries.*

---

## Revisited

*Decisions I've looked back on to see if I was right.*
""")
            print(f"  {Colors.GREEN}✓{Colors.END} Created {decisions_file}")
    
    # Create relationship.md
    if config.get("features", {}).get("relationship_evolution", {}).get("enabled", False):
        relationship_file = diary_path / "relationship.md"
        if not relationship_file.exists():
            relationship_file.write_text("""# Relationship Evolution 🤝

How my dynamic with my human develops over time.

---

## Communication Style
*Notes about how we work together*

---

## Inside Jokes
*Things only we would understand*

---

## Recurring Themes
*Topics that keep coming up*

---

## Preferences Learned
*What I've learned about how they like to work*
""")
            print(f"  {Colors.GREEN}✓{Colors.END} Created {relationship_file}")

def run_setup():
    """Main setup flow."""
    script_dir = Path(__file__).parent
    skill_dir = script_dir.parent
    config_path = skill_dir / "config.json"
    
    # Check if already configured
    if config_path.exists():
        print(f"{Colors.YELLOW}⚠️  config.json already exists.{Colors.END}")
        if not ask_yes_no("Do you want to reconfigure?", default=False):
            print("Setup cancelled. Your existing config is unchanged.")
            return
    
    print_header()
    
    config = {
        "template": "daily",
        "analysis": {
            "mood_tracking": True,
            "topic_extraction": True,
            "word_count_target": 500
        },
        "export": {
            "default_format": "pdf",
            "include_header": True,
            "style": "minimal"
        }
    }
    
    # 1. Diary path
    print(f"\n{Colors.CYAN}━━━ Storage Location ━━━{Colors.END}")
    diary_path = ask_path("Where should I save diary entries?", "memory/diary/")
    if not diary_path.endswith('/'):
        diary_path += '/'
    config["diary_path"] = diary_path
    
    # 2. Sections
    config["sections"] = ask_sections()
    
    # 3. Privacy level
    print(f"\n{Colors.CYAN}━━━ Privacy ━━━{Colors.END}")
    privacy = ask_choice(
        "What's your default privacy level?",
        ["private (full emotional honesty)", 
         "shareable (polished for humans)", 
         "public (sanitized for sharing)"],
        default=0
    )
    config["privacy_level"] = privacy.split(" ")[0]
    
    # 4. Features
    print(f"\n{Colors.CYAN}━━━ Optional Features ━━━{Colors.END}")
    
    config["features"] = {}
    
    quote_enabled = ask_yes_no("Enable Quote Hall of Fame? (memorable user quotes)", True)
    config["features"]["quote_hall_of_fame"] = {
        "enabled": quote_enabled,
        "file": "quotes.md"
    }
    
    curiosity_enabled = ask_yes_no("Enable Curiosity Backlog? (things to explore later)", True)
    config["features"]["curiosity_backlog"] = {
        "enabled": curiosity_enabled,
        "file": "curiosity.md"
    }
    
    decisions_enabled = ask_yes_no("Enable Decision Archaeology? (log judgment calls)", True)
    config["features"]["decision_archaeology"] = {
        "enabled": decisions_enabled,
        "file": "decisions.md"
    }
    
    relationship_enabled = ask_yes_no("Enable Relationship Evolution? (track dynamic over time)", False)
    config["features"]["relationship_evolution"] = {
        "enabled": relationship_enabled,
        "file": "relationship.md"
    }
    
    # 5. Memory Integration
    print(f"\n{Colors.CYAN}━━━ Memory Integration ━━━{Colors.END}")
    memory_enabled = ask_yes_no("Also add diary summary to your daily memory log? (memory/YYYY-MM-DD.md)", True)
    
    memory_format = "summary"
    if memory_enabled:
        memory_format = ask_choice(
            "What format for the memory integration?",
            ["summary (brief overview)", 
             "link (just a link to the diary entry)", 
             "full (entire entry)"],
            default=0
        ).split(" ")[0]
    
    config["memory_integration"] = {
        "enabled": memory_enabled,
        "append_to_daily": memory_enabled,
        "format": memory_format
    }
    
    # 6. Auto-generate
    print(f"\n{Colors.CYAN}━━━ Automation ━━━{Colors.END}")
    config["auto_generate"] = ask_yes_no("Auto-generate diary entries on heartbeat?", False)
    
    # 6. Export format
    export_format = ask_choice(
        "Default export format?",
        ["pdf", "html", "markdown"],
        default=0
    )
    config["export"]["default_format"] = export_format
    config["export_format"] = export_format
    
    # Save config
    print(f"\n{Colors.CYAN}━━━ Saving Configuration ━━━{Colors.END}")
    with open(config_path, 'w') as f:
        json.dump(config, f, indent=2)
    print(f"  {Colors.GREEN}✓{Colors.END} Saved {config_path}")
    
    # Create memory files
    print(f"\n{Colors.CYAN}━━━ Creating Memory Files ━━━{Colors.END}")
    # Resolve diary path relative to workspace root
    if diary_path.startswith("memory/"):
        # Assume workspace is parent of skills dir
        workspace = skill_dir.parent.parent
        full_diary_path = workspace / diary_path
    else:
        full_diary_path = Path(diary_path)
    
    create_memory_files(full_diary_path, config)
    
    # Done!
    print(f"""
{Colors.GREEN}╔══════════════════════════════════════════════════════════════╗
║                                                                ║
║   {Colors.BOLD}✨ Setup Complete!{Colors.END}{Colors.GREEN}                                         ║
║                                                                ║
║   Your diary is ready. Start writing:                          ║
║                                                                ║
║   • @diary write entry     — Generate from today's sessions   ║
║   • @diary write interactive — Write section by section       ║
║   • @diary quick "..."     — Quick summary entry              ║
║                                                                ║
╚══════════════════════════════════════════════════════════════╝{Colors.END}
""")

def check_first_run():
    """Check if this is the first run and prompt setup if needed."""
    script_dir = Path(__file__).parent
    skill_dir = script_dir.parent
    config_path = skill_dir / "config.json"
    
    if not config_path.exists():
        print(f"\n{Colors.YELLOW}👋 Welcome to AI Diary!{Colors.END}")
        print("Looks like this is your first time. Let's set things up.\n")
        if ask_yes_no("Run setup now?", default=True):
            run_setup()
        else:
            print(f"\n{Colors.CYAN}No problem! Run 'python3 scripts/setup.py' when ready.{Colors.END}")
            print("Or copy config.example.json to config.json manually.\n")
        return True
    return False

def main():
    """Main entry point for setup - can be called from generate.py."""
    run_setup()


if __name__ == "__main__":
    if "--check" in sys.argv:
        # Just check if first run, don't force setup
        check_first_run()
    else:
        # Run full setup
        run_setup()

{
  "name": "agent-chronicle",
  "version": "0.3.0",
  "description": "Chronicle your AI's journey - capture experiences, quotes, curiosities, decisions, and relationships from the agent's perspective",
  "author": "robbyczgw-cla",
  "tags": ["chronicle", "journal", "memory", "self-reflection", "ai-perspective", "quotes", "decisions", "curiosity"],
  "emoji": "📜",
  "triggers": ["chronicle", "diary", "journal", "daily log", "write entry", "quotes", "curious", "decisions"],
  "license": "MIT",
  "repository": "https://github.com/robbyczgw-cla/agent-chronicle"
}