mint.py

#!/usr/bin/env python3
"""
mint-cli - Project scaffolding tool

Suggests project names, creates the directory, initializes git,
and opens WHY.md for you to document your vision and intent.
"""

import os
import sys
import subprocess
from datetime import date
from dotenv import load_dotenv
from config import BASE_PATH, EDITOR, NUM_SUGGESTIONS

# Load env vars from .env if present
load_dotenv()

# Optional: OpenAI client for name suggestions
client = None
api_key = os.getenv("DIGITAL_OCEAN_MODEL_ACCESS_KEY")
if api_key:
    try:
        from openai import OpenAI
        client = OpenAI(
            base_url="https://inference.do-ai.run/v1/",
            api_key=api_key,
        )
    except ImportError:
        pass


def suggest_names(description: str) -> list[str] | None:
    """Call DO inference API and return list of name suggestions. Returns None if unavailable."""
    if not client:
        return None

    try:
        prompt = f"""
I am starting a new side project.

What I'm trying to build:
{description}

Suggest {NUM_SUGGESTIONS} short, memorable project names.
Guidelines:
- Prefer 1–2 words
- Always lowercase with hyphens (e.g., book-shelf, read-track, quick-note)
- Easy to type
- No explanations, just the names
- One name per line
"""

        resp = client.chat.completions.create(
            model="llama3-8b-instruct",
            messages=[
                {
                    "role": "system",
                    "content": "You help developers come up with good project names."
                },
                {
                    "role": "user",
                    "content": prompt
                }
            ],
            temperature=0.9,
        )

        # Parse response into list of names
        raw = resp.choices[0].message.content.strip()
        names = []
        for line in raw.split("\n"):
            # Clean up numbering like "1. Name" or "1) Name" or just "Name"
            line = line.strip()
            if not line:
                continue
            # Remove leading numbers and punctuation
            if line[0].isdigit():
                # Skip past number and any following punctuation/space
                i = 0
                while i < len(line) and (line[i].isdigit() or line[i] in ".)- "):
                    i += 1
                line = line[i:].strip()
            if line:
                names.append(line)

        return names if names else None
    except Exception:
        return None


def select_name(names: list[str]) -> str | None:
    """Display numbered list, get user selection or custom name. Returns None to regenerate."""
    print("\nProject name ideas:\n")
    print("  r. [Regenerate names]")
    print("  0. [Type your own name]")
    for i, name in enumerate(names, 1):
        print(f"  {i}. {name}")

    while True:
        choice = input("\nPick a number (r to regenerate, 0 to type your own): ").strip().lower()

        if choice == "r":
            return None  # Signal to regenerate

        if choice == "0":
            custom = input("Enter your project name: ").strip()
            if custom:
                return custom
            print("Name cannot be empty.")
            continue

        try:
            idx = int(choice)
            if 1 <= idx <= len(names):
                return names[idx - 1]
            print(f"Please enter a number between 0 and {len(names)}.")
        except ValueError:
            # User typed a name directly instead of a number
            if choice:
                return choice
            print("Please enter a valid choice.")


def create_project(name: str) -> str:
    """Create directory, git init, create WHY.md and DECISIONS.md. Return path."""
    project_path = os.path.join(BASE_PATH, name)

    # Check if directory already exists
    if os.path.exists(project_path):
        print(f"\nError: Directory already exists: {project_path}")
        raise SystemExit(1)

    # Create directory
    os.makedirs(project_path)

    # Git init
    subprocess.run(["git", "init"], cwd=project_path, capture_output=True)

    # Create docs directory
    docs_path = os.path.join(project_path, "docs")
    os.makedirs(docs_path)

    # Create WHY.md
    today = date.today().strftime("%Y-%m-%d")
    why_content = f"""# {name}

> Document your vision and intent before writing code.
> Created {today} with [mint-cli](https://github.com/ajotwani/mint-cli)

## I'm building this because:
-

## I'm intentionally not solving:
-

## This will be done when:
-
"""
    why_path = os.path.join(docs_path, "WHY.md")
    with open(why_path, "w") as f:
        f.write(why_content)

    # Create DECISIONS.md
    decisions_content = f"""# {name} - Decisions

> Log the decisions you make as you build.
> Created {today} with [mint-cli](https://github.com/ajotwani/mint-cli)

---

"""
    decisions_path = os.path.join(docs_path, "DECISIONS.md")
    with open(decisions_path, "w") as f:
        f.write(decisions_content)

    # Print summary
    print(f"\n✅ Created {project_path}")
    print("✅ Initialized git repository")
    print("✅ Created docs/WHY.md")
    print("✅ Created docs/DECISIONS.md")

    return project_path


def open_in_editor(filepath: str):
    """Open file in configured editor."""
    print(f"\nOpening in {EDITOR}...")
    subprocess.run([EDITOR, filepath])


def main():
    print("\n✨ mint-cli - Project Scaffolding\n")

    # Check if project name was passed as argument
    if len(sys.argv) > 1:
        name = sys.argv[1]
        full_path = os.path.join(BASE_PATH, name)
        confirm = input(f"Create '{full_path}'? (y/n): ").strip().lower()
        if confirm != 'y':
            print("Cancelled.")
            return
        selected = name
    else:
        description = input("What are you trying to build?\n> ").strip()

        if not description:
            print("Please describe what you're building.")
            return

        # Try to generate name suggestions
        selected = None
        print("\nGenerating name ideas...")
        names = suggest_names(description)

        if names:
            # Got suggestions, let user pick
            while selected is None:
                selected = select_name(names)
                if selected is None:
                    # User wants to regenerate
                    print("\nRegenerating...")
                    names = suggest_names(description)
                    if not names:
                        print("Could not regenerate. Enter a name manually.")
                        selected = input("Project name: ").strip()
                        if not selected:
                            print("Name cannot be empty.")
                            return
        else:
            # No API available, ask for name directly
            print("(Name suggestions unavailable)")
            selected = input("Project name: ").strip()
            if not selected:
                print("Name cannot be empty.")
                return

    project_path = create_project(selected)

    why_file = os.path.join(project_path, "docs", "WHY.md")
    open_in_editor(why_file)

    # Write path to temp file for shell wrapper to read
    mint_dir = os.path.dirname(os.path.abspath(__file__))
    with open(os.path.join(mint_dir, ".last_project"), "w") as f:
        f.write(project_path)


if __name__ == "__main__":
    main()