letter-init

Letter Init Skill

This skill sets up the complete "Letter to Blog" pipeline that automatically converts your .memory/ session letters into polished blog posts using GitHub Actions and the Anthropic API.

When to Use

Invoke this skill when:

• User types /letter-init
• User wants to set up blog post generation from memory files
• User is setting up the repository for the first time

What It Does

Creates the complete CI/CD infrastructure:

1. .memory/ folder (if not exists)
2. drafts/ folder for generated blog posts
3. .github/scripts/blog_gen.py - Python script using Anthropic API
4. .github/scripts/vibe_requirements.txt - Dependencies
5. .github/workflows/vibe_publisher.yml - GitHub Action workflow

Execution Steps

1. Create Required Directories

mkdir -p .memory
mkdir -p drafts
mkdir -p .github/scripts
mkdir -p .github/workflows

2. Create the Blog Generator Script

Write the file .github/scripts/blog_gen.py with the following content:

#!/usr/bin/env python3
"""
Blog Generator for Letter to Blog Pipeline
Converts .memory/*.md files into polished blog posts using Anthropic API
"""

import os
import sys
import json
from pathlib import Path
from datetime import datetime
import anthropic
from dotenv import load_dotenv

# Load environment variables
load_dotenv()

# Config paths
GLOBAL_CONFIG = Path.home() / ".config" / "letter-for-my-future-self" / "config.json"
PROJECT_CONFIG = Path(".letter-config.json")

def get_api_key():
    """Get API key from environment, project config, or global config (in that order)"""
    # 1. Environment variable (highest priority)
    api_key = os.getenv('ANTHROPIC_API_KEY')
    if api_key:
        print("  Using API key from environment variable")
        return api_key

    # 2. Project-level config
    if PROJECT_CONFIG.exists():
        try:
            config = json.loads(PROJECT_CONFIG.read_text())
            api_key = config.get('anthropic_api_key')
            if api_key:
                print("  Using API key from project config")
                return api_key
        except (json.JSONDecodeError, IOError):
            pass

    # 3. Global config (fallback)
    if GLOBAL_CONFIG.exists():
        try:
            config = json.loads(GLOBAL_CONFIG.read_text())
            api_key = config.get('anthropic_api_key')
            if api_key:
                print("  Using API key from global config")
                return api_key
        except (json.JSONDecodeError, IOError):
            pass

    return None

def get_latest_memory_file():
    """Find the most recent letter file in .memory/"""
    memory_dir = Path(os.path.abspath('.memory'))

    if not memory_dir.exists():
        print("❌ .memory/ directory not found")
        sys.exit(1)

    # Find all letter_*.md files
    letter_files = sorted(memory_dir.glob('letter_*.md'), reverse=True)

    if not letter_files:
        print("❌ No letter files found in .memory/")
        sys.exit(1)

    return letter_files[0]

def generate_blog_post(memory_content: str) -> str:
    """Use Anthropic API to convert memory file to blog post"""
    api_key = get_api_key()

    if not api_key:
        print("❌ No API key found. Set ANTHROPIC_API_KEY or run --setup")
        sys.exit(1)

    client = anthropic.Anthropic(api_key=api_key)

    prompt = f"""You are a technical blog writer. Convert this development session memory into an engaging, public-ready blog post.

INPUT (Session Memory):
{memory_content}

REQUIREMENTS:
1. Transform technical decisions into narrative insights
2. Keep the "Pain Log" as "Lessons Learned" or "Challenges"
3. Make it readable for a general developer audience
4. Add markdown frontmatter with: title, date, tags, excerpt
5. Use proper markdown formatting with headers, code blocks, lists
6. Maintain technical accuracy but improve readability

OUTPUT FORMAT:
---
title: "[Engaging Title]"
date: {datetime.now().strftime('%Y-%m-%d')}
tags: [relevant, tags, here]
excerpt: "Brief summary of the post"
---

[Blog post content in markdown]

Generate the blog post now:"""

    message = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4096,
        messages=[
            {"role": "user", "content": prompt}
        ]
    )

    return message.content[0].text

def save_blog_post(content: str, source_file: Path):
    """Save generated blog post to drafts/"""
    drafts_dir = Path(os.path.abspath('drafts'))
    drafts_dir.mkdir(exist_ok=True)

    # Generate filename based on source
    timestamp = datetime.now().strftime('%Y-%m-%d')
    output_file = drafts_dir / f"blog_{timestamp}_{source_file.stem}.md"

    output_file.write_text(content, encoding='utf-8')
    print(f"✅ Blog post generated: {output_file}")
    return output_file

def main():
    """Main execution flow"""
    print("🎨 Letter to Blog: Generating blog post...")

    # Get latest memory file
    memory_file = get_latest_memory_file()
    print(f"📖 Reading: {memory_file}")

    # Read content
    memory_content = memory_file.read_text(encoding='utf-8')

    # Generate blog post
    print("🤖 Calling Anthropic API...")
    blog_content = generate_blog_post(memory_content)

    # Save to drafts
    output_file = save_blog_post(blog_content, memory_file)

    print(f"✅ Success! Blog post saved to: {output_file}")
    print("🚀 Ready for review and publishing!")

if __name__ == "__main__":
    main()