version: '3.8'
services:
  # AI Agent Orchestration
  cowork-pro:
    image: slashman413/cowork-pro:latest
    ports:
      - "6868:6868"
    volumes:
      - ./cowork-data:/app/data
      - ./content:/app/content
    env_file:
      - .env
    restart: unless-stopped

  # Hugo Blog
  hugo:
    image: klakegg/hugo:ext-alpine
    ports:
      - "1313:1313"
    volumes:
      - ./slashmantools.us:/src
    working_dir: /src
    command: server --bind=0.0.0.0 --disableLiveReload
    restart: unless-stopped

  # Content Generation Agent
  content-agent:
    image: python:3.12-slim
    working_dir: /app
    volumes:
      - ./scripts:/app
      - ./content-output:/app/output
    environment:
      - OPENAI_API_KEY=${AI_API_KEY}
      - MODEL=qwen-35b
    restart: unless-stopped

# AI API
AI_API_KEY=your_key_here
MODEL=qwen-35b
TEMPERATURE=0.7

# Cowork Pro
COWORK_PORT=6868
COWORK_BRAIN=claude-opus

# GitHub (for deployment)
GITHUB_TOKEN=${GITHUB_TOKEN}
REPO=slashman413/slashmantools.us
BRANCH=main

#!/usr/bin/env python3
"""
Automated content generator for slashmantools.us blog.
Generates 2000+ word articles with JSON-LD, OG tags, and internal links.
"""

import json
import hashlib
import datetime
from pathlib import Path
from typing import Optional

# Product catalog
PRODUCTS = {
    "diwoc": {
        "name": "AI Prompt Library",
        "price": "$29",
        "url": "/blog/ai-prompt-library/",
        "description": "300+ battle-tested AI prompts"
    },
    "mgtpcn": {
        "name": "Ship With AI",
        "price": "$39",
        "url": "/blog/ship-with-ai/",
        "description": "Complete AI automation course"
    },
    "xfhfps": {
        "name": "Cowork Pro",
        "price": "$59",
        "url": "/blog/cowork-pro/",
        "description": "AI agent orchestration framework"
    },
    "etf-dashboard": {
        "name": "ETF Dashboard",
        "price": "$29",
        "url": "/blog/etf-dashboard/",
        "description": "Automated ETF portfolio analysis"
    }
}

class ArticleGenerator:
    def __init__(self, output_dir: str = "content/blog"):
        self.output_dir = Path(output_dir)
        self.seen_slugs = set()

    def generate_slug(self, title: str, product_slug: str = "") -> str:
        """Generate URL-safe slug from title."""
        import re
        text = title.lower()
        text = re.sub(r'[^\w\s-]', '', text)
        text = re.sub(r'[\s_]+', '-', text)
        if product_slug:
            text = f"{text}-{product_slug}"
        if text in self.seen_slugs:
            text += f"-{datetime.datetime.now().strftime('%Y%m%d')}"
        self.seen_slugs.add(text)
        return text

    def generate_article(self, topic: str, product: str, article_type: str = "guide") -> dict:
        """Generate a complete article with frontmatter."""

        # Product info
        product_info = PRODUCTS.get(product, {})
        product_name = product_info.get("name", product)
        product_url = product_info.get("url", f"/blog/{product}/")

        # Generate slug
        slug = self.generate_slug(topic, product)

        # Content sections based on article type
        sections = self.get_sections(topic, product, article_type)

        # Build frontmatter
        frontmatter = f"""---
title: "{topic}"
description: "{self.generate_description(topic, product)}"
date: {datetime.datetime.now().strftime('%Y-%m-%d')}
slug: {slug}
tags: [{', '.join(self.get_tags(topic, product, article_type))}]
author: "Wayne Chang"
---

{self.build_schema_json(product)}

# {topic}

## Introduction

"""

        # Add sections
        content = frontmatter

        # Intro paragraph
        content += f"""In the world of AI automation, [**{product_name}**](https://slashmaster6.gumroad.com/l/{product}?utm_source=blog&utm_medium=article&utm_campaign={slug}) stands out as one of the most effective solutions for businesses looking to scale efficiently. Whether you're a solopreneur or managing a small team, understanding how to leverage AI tools can make the difference between thriving and merely surviving in today's competitive landscape.

This guide covers everything you need to know about implementing [**{product_name}**](https://slashmaster6.gumroad.com/l/{product}?utm_source=blog&utm_medium=article&utm_campaign={slug}) in your workflow, from initial setup to advanced optimization techniques.

"""

        # Add article sections
        content += sections

        # Conclusion with CTA
        content += f"""## Conclusion

Implementing [**{product_name}**](https://slashmaster6.gumroad.com/l/{product}?utm_source=blog&utm_medium=article&utm_campaign={slug}) doesn't have to be complicated. With the right approach and a bit of dedication, you can build a robust AI-powered workflow that saves time and improves results.

### Key Takeaways

- Start with a clear goal and use AI as the tool to achieve it
- Test different configurations to find what works for your use case
- Monitor performance and iterate based on data
- Join our community for ongoing support and tips

### Next Steps

1. **[Explore {product_name}**](https://slashmaster6.gumroad.com/l/{product}?utm_source=blog&utm_medium=article&utm_campaign={slug}) — Get the full solution
2. **[Read our complete guide](/blog/ultimate-ai-automation-guide-2026/) — Full framework
3. **[Join the community](https://github.com/slashman413/ship-with-ai) — Ask questions and share

---

## Related Articles

- [**Building an AI-Powered Content Factory**](/blog/build-ai-content-factory-technical-guide/)
- [**The Ultimate Guide to AI Automation**](/blog/ultimate-ai-automation-guide-2026/)
- [**How I Built a 10-Product Digital Business**](/blog/ai-agents-digital-business-case-study/)
"""

        return {
            "content": content,
            "slug": slug,
            "product": product,
            "product_name": product_name,
            "article_type": article_type
        }

    def get_sections(self, topic: str, product: str, article_type: str) -> str:
        """Generate article sections based on type."""
        product_name = PRODUCTS.get(product, {}).get("name", product)

        sections_map = {
            "guide": [
                "## Getting Started",
                "## Setup and Configuration",
                "## Building Your First Automation",
                "## Advanced Techniques",
                "## Monitoring and Analytics",
                "## Troubleshooting Common Issues"
            ],
            "case_study": [
                "## The Challenge",
                "## Approach and Methodology",
                "## Implementation",
                "## Results and Metrics",
                "## Lessons Learned",
                "## Key Takeaways"
            ],
            "tutorial": [
                "## Prerequisites",
                "## Step 1: Installation",
                "## Step 2: Configuration",
                "## Step 3: First Test",
                "## Step 4: Production Deployment",
                "## Step 5: Monitoring"
            ],
            "comparison": [
                "## The Contenders",
                "## Evaluation Criteria",
                "## Feature Comparison",
                "## Performance Benchmarks",
                "## Cost Analysis",
                "## Final Recommendation"
            ]
        }

        return "\n\n".join(
            f"### {s}\n\n{self.get_section_content(s, product, article_type)}\n"
            for s in (sections_map.get(article_type, sections_map["guide"]))
        )

    def get_section_content(self, section: str, product: str, article_type: str) -> str:
        """Generate section content."""
        product_name = PRODUCTS.get(product, {}).get("name", product)

        if "Getting Started" in section or "Prerequisites" in section:
            return f"""Setting up {product_name} requires a few basic tools and a willingness to experiment. Here's what you'll need:

1. A development environment (Docker recommended)
2. Access to an AI model (Qwen 35B or GPT-4 recommended)
3. Basic understanding of automation concepts
4. A specific business problem to solve

Once you have these in place, you're ready to begin. The beauty of {product_name} is that it abstracts away most of the complexity — you focus on the business logic while the framework handles the technical details.

**Tip:** Start with a small use case before scaling. This helps you validate the approach without over-investing in the wrong area.

"""

        elif "Configuration" in section or "Installation" in section:
            return f"""Configuration is where the real magic happens. With {product_name}, you define your automation rules in a simple YAML file, then the framework handles the execution.

Here's a minimal configuration:

```yaml
pipeline:
  name: product-review
  steps:
    - name: research
      agent: research-specialist
      input:
        topic: "{topic}"
        depth: 3
      output: research_brief

    - name: draft
      agent: content-writer
      input:
        brief: research_brief
        tone: professional
        length: 2500
      output: article_draft

    - name: review
      agent: quality-checker
      input:
        draft: article_draft
        criteria: [accuracy, readability, seo]
      output: final_article

# Quick test before pushing
hugo --gc --minify --baseURL "https://slashmantools.us/"
ls public/blog/  # Check generated pages

if len(content) < 3000:  # ~1500 words
    content += self.get_expanded_content(section)

git commit -m "ci: generate blog post — Ship With AI setup guide (mgtpcn)"