rapt0r-cli 1.0.0__py3-none-any.whl

rapt0r/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

rapt0r/__main__.py

@@ -0,0 +1,4 @@
+from rapt0r.main import main
+
+if __name__ == "__main__":
+    main()

rapt0r/core/builder.py

@@ -0,0 +1,20 @@
+import logging
+from jinja2 import Environment, BaseLoader, DebugUndefined
+
+from rapt0r.core.utils import DEFAULT_BODY
+from rapt0r.core.context_vars import extract_context_vars, resolve_context_vars
+
+logger = logging.getLogger(__name__)
+
+_env = Environment(loader=BaseLoader(), undefined=DebugUndefined, keep_trailing_newline=True)
+
+
+def build_prompt(bodies, answers, body_key=None):
+    key = body_key if body_key and body_key in bodies else DEFAULT_BODY
+    if key not in bodies:
+        logger.warning(f"Body section {key!r} not found, using first available")
+        key = next(iter(bodies))
+    vars_ = {k: v for k, v in answers.items() if not k.startswith("__")}
+    body, pending = extract_context_vars(bodies[key])
+    result = _env.from_string(body).render(**vars_)
+    return resolve_context_vars(result, pending)

rapt0r/core/context_vars.py

@@ -0,0 +1,97 @@
+"""Dynamic context variables: {{git_diff}}, {{tree}}, {{tree:path}}, {{file:path}}.
+
+The colon forms are not valid Jinja2 syntax, and injected content may itself
+contain ``{{``, so these tokens are swapped for opaque sentinels before the
+Jinja2 render and resolved afterwards (see builder.build_prompt).
+"""
+
+import os
+import re
+import subprocess
+
+MAX_BYTES = 30000
+MAX_TREE_ENTRIES = 500
+SKIP_DIRS = {"__pycache__", "node_modules", "venv", ".venv"}
+
+CONTEXT_VAR_NAMES = {"git_diff", "tree", "file"}
+
+_PATTERN = re.compile(r"\{\{\s*(git_diff|tree|file)(?::([^}]+))?\s*\}\}")
+
+
+def _truncate(text):
+    if len(text) > MAX_BYTES:
+        return text[:MAX_BYTES] + "\n... [truncated]"
+    return text
+
+
+def _git_diff():
+    try:
+        out = subprocess.run(
+            ["git", "diff", "HEAD"], capture_output=True, text=True, timeout=10
+        )
+    except (OSError, subprocess.TimeoutExpired):
+        return "[git diff unavailable]"
+    if out.returncode != 0:
+        return "[git diff unavailable: not a git repository?]"
+    return _truncate(out.stdout.strip()) or "[no uncommitted changes]"
+
+
+def _tree(root):
+    root = (root or ".").strip() or "."
+    if not os.path.isdir(root):
+        return f"[directory not found: {root}]"
+    lines = []
+    for dirpath, dirnames, filenames in os.walk(root):
+        dirnames[:] = sorted(
+            d for d in dirnames if not d.startswith(".") and d not in SKIP_DIRS
+        )
+        for f in sorted(filenames):
+            lines.append(os.path.relpath(os.path.join(dirpath, f), root))
+            if len(lines) >= MAX_TREE_ENTRIES:
+                lines.append("... [truncated]")
+                return "\n".join(lines)
+    return "\n".join(lines) or "[empty directory]"
+
+
+def _file(path):
+    path = (path or "").strip()
+    try:
+        with open(path, "r", encoding="utf-8", errors="replace") as f:
+            return _truncate(f.read())
+    except OSError as e:
+        return f"[could not read {path}: {e}]"
+
+
+def _resolve(kind, arg):
+    if kind == "git_diff":
+        return _git_diff()
+    if kind == "tree":
+        return _tree(arg)
+    if kind == "file":
+        return _file(arg)
+    return ""
+
+
+def extract_context_vars(text):
+    """Replace context tokens with sentinels safe to pass through Jinja2."""
+    pending = {}
+
+    def repl(m):
+        token = f"\x00CTX{len(pending)}\x00"
+        pending[token] = (m.group(1), m.group(2))
+        return token
+
+    return _PATTERN.sub(repl, text), pending
+
+
+def resolve_context_vars(text, pending):
+    """Substitute sentinels with their resolved content after the render."""
+    for token, (kind, arg) in pending.items():
+        text = text.replace(token, _resolve(kind, arg))
+    return text
+
+
+def expand_context_vars(text):
+    """One-shot expansion (extract + resolve), used directly in tests."""
+    extracted, pending = extract_context_vars(text)
+    return resolve_context_vars(extracted, pending)

rapt0r/core/llm.py

@@ -0,0 +1,123 @@
+"""Stream a built prompt to an LLM over raw HTTP (no SDK dependencies).
+
+Providers are detected from environment variables:
+  ANTHROPIC_API_KEY -> Anthropic Messages API
+  OPENAI_API_KEY    -> OpenAI Chat Completions API
+
+Model overrides: RAPT0R_ANTHROPIC_MODEL, RAPT0R_OPENAI_MODEL.
+"""
+
+import json
+import os
+import urllib.error
+import urllib.request
+
+ANTHROPIC_URL = "https://api.anthropic.com/v1/messages"
+OPENAI_URL = "https://api.openai.com/v1/chat/completions"
+
+DEFAULT_ANTHROPIC_MODEL = "claude-opus-4-8"
+DEFAULT_OPENAI_MODEL = "gpt-5-codex"
+
+TIMEOUT = 600
+
+
+class LLMError(Exception):
+    pass
+
+
+def available_providers():
+    providers = []
+    if os.environ.get("ANTHROPIC_API_KEY"):
+        providers.append("anthropic")
+    if os.environ.get("OPENAI_API_KEY"):
+        providers.append("openai")
+    return providers
+
+
+def iter_sse_data(lines):
+    """Yield parsed JSON payloads from an iterable of raw SSE byte lines."""
+    for raw in lines:
+        line = raw.decode("utf-8", errors="replace").strip()
+        if not line.startswith("data:"):
+            continue
+        data = line[len("data:"):].strip()
+        if data == "[DONE]":
+            return
+        try:
+            yield json.loads(data)
+        except json.JSONDecodeError:
+            continue
+
+
+def _post_stream(url, headers, body):
+    req = urllib.request.Request(
+        url, data=json.dumps(body).encode("utf-8"), headers=headers, method="POST"
+    )
+    try:
+        return urllib.request.urlopen(req, timeout=TIMEOUT)
+    except urllib.error.HTTPError as e:
+        detail = e.read().decode("utf-8", errors="replace")[:500]
+        raise LLMError(f"HTTP {e.code}: {detail}") from e
+    except urllib.error.URLError as e:
+        raise LLMError(f"Network error: {e.reason}") from e
+
+
+def _stream_anthropic(prompt):
+    model = os.environ.get("RAPT0R_ANTHROPIC_MODEL", DEFAULT_ANTHROPIC_MODEL)
+    resp = _post_stream(
+        ANTHROPIC_URL,
+        {
+            "x-api-key": os.environ["ANTHROPIC_API_KEY"],
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        },
+        {
+            "model": model,
+            "max_tokens": 64000,
+            "stream": True,
+            "thinking": {"type": "adaptive"},
+            "messages": [{"role": "user", "content": prompt}],
+        },
+    )
+    with resp:
+        for event in iter_sse_data(resp):
+            etype = event.get("type")
+            if etype == "content_block_delta":
+                delta = event.get("delta", {})
+                if delta.get("type") == "text_delta":
+                    yield delta.get("text", "")
+            elif etype == "error":
+                raise LLMError(event.get("error", {}).get("message", "stream error"))
+
+
+def _stream_openai(prompt):
+    model = os.environ.get("RAPT0R_OPENAI_MODEL", DEFAULT_OPENAI_MODEL)
+    resp = _post_stream(
+        OPENAI_URL,
+        {
+            "Authorization": f"Bearer {os.environ['OPENAI_API_KEY']}",
+            "content-type": "application/json",
+        },
+        {
+            "model": model,
+            "stream": True,
+            "messages": [{"role": "user", "content": prompt}],
+        },
+    )
+    with resp:
+        for event in iter_sse_data(resp):
+            choices = event.get("choices") or []
+            if choices:
+                text = choices[0].get("delta", {}).get("content")
+                if text:
+                    yield text
+
+
+def stream_completion(prompt, provider):
+    """Yield response text chunks from the given provider."""
+    if provider == "anthropic":
+        yield from _stream_anthropic(prompt)
+    elif provider == "openai":
+        yield from _stream_openai(prompt)
+    else:
+        raise LLMError(f"Unknown provider: {provider}")

rapt0r/core/loader.py

@@ -0,0 +1,137 @@
+import os
+import re
+import shutil
+import yaml
+import logging
+
+from rapt0r.core.context_vars import CONTEXT_VAR_NAMES
+
+logger = logging.getLogger(__name__)
+
+BUNDLED_TEMPLATES_DIR = os.path.join(os.path.dirname(__file__), "..", "templates")
+USER_TEMPLATES_DIR = os.path.expanduser(os.path.join("~", ".rapt0r", "templates"))
+
+
+def _resolve_templates_dir():
+    env = os.environ.get("RAPT0R_TEMPLATES_DIR")
+    if env:
+        return env
+    # Running from a writable checkout (dev mode) — use bundled dir directly.
+    if os.access(BUNDLED_TEMPLATES_DIR, os.W_OK):
+        return BUNDLED_TEMPLATES_DIR
+    # Installed package: seed user dir from bundled templates on first run.
+    if not os.path.isdir(USER_TEMPLATES_DIR):
+        try:
+            shutil.copytree(BUNDLED_TEMPLATES_DIR, USER_TEMPLATES_DIR)
+        except OSError as e:
+            logger.warning(f"Could not create {USER_TEMPLATES_DIR}: {e}")
+            return BUNDLED_TEMPLATES_DIR
+    return USER_TEMPLATES_DIR
+
+
+TEMPLATES_DIR = _resolve_templates_dir()
+
+
+def load_templates(templates_dir=None):
+    templates_dir = templates_dir or TEMPLATES_DIR
+    templates = []
+    seen_names = {}
+
+    def _load_dir(dirpath, category):
+        for filename in sorted(os.listdir(dirpath)):
+            filepath = os.path.join(dirpath, filename)
+            if not os.path.isfile(filepath) or not filename.endswith(".md"):
+                continue
+            try:
+                with open(filepath, "r", encoding="utf-8") as f:
+                    raw = f.read()
+            except OSError as e:
+                logger.warning(f"Could not read {filename}: {e}")
+                continue
+
+            meta, bodies = parse_template(raw, filename)
+            if not meta:
+                continue
+
+            _validate_template(meta, bodies, filename)
+
+            name = meta.get("name", filename)
+            if name in seen_names:
+                logger.warning(
+                    f"Duplicate name '{name}' in {filename} and {seen_names[name]}"
+                )
+            seen_names[name] = filename
+
+            templates.append({
+                "filename": filename,
+                "filepath": filepath,
+                "category": category,
+                "meta": meta,
+                "body": bodies,
+            })
+
+    # Root templates first (e.g. generate-template.md)
+    _load_dir(templates_dir, None)
+
+    # Category subdirectories
+    for dirname in sorted(os.listdir(templates_dir)):
+        dirpath = os.path.join(templates_dir, dirname)
+        if os.path.isdir(dirpath):
+            _load_dir(dirpath, dirname)
+
+    return templates
+
+
+def parse_template(content, filename="?"):
+    match = re.match(r"^---\n(.*?)\n---\n(.*)$", content, re.DOTALL)
+    if not match:
+        return None, content
+
+    try:
+        meta = yaml.safe_load(match.group(1))
+    except yaml.YAMLError as e:
+        logger.warning(f"YAML error in {filename}: {e}")
+        return None, content
+
+    if not isinstance(meta, dict):
+        logger.warning(f"Invalid frontmatter in {filename}")
+        return None, content
+
+    body_raw = match.group(2).strip()
+    bodies = {}
+    parts = re.split(r"---body:(\w+)---", body_raw)
+
+    if len(parts) == 1:
+        bodies["default"] = parts[0].strip()
+    else:
+        for i in range(1, len(parts), 2):
+            if i + 1 < len(parts):
+                bodies[parts[i]] = parts[i + 1].strip()
+            else:
+                logger.warning(f"Empty body section body:{parts[i]} in {filename}")
+
+    return meta, bodies
+
+
+def _validate_template(meta, bodies, filename):
+    branch = meta.get("branch")
+    if branch:
+        for side in ("y", "n"):
+            if side not in branch:
+                logger.warning(f"Branch '{side}' missing in {filename}")
+
+    # Collect all declared question keys
+    question_keys = set(meta.get("questions", {}).keys())
+    if branch:
+        for side in ("y", "n"):
+            branch_data = branch.get(side, {})
+            question_keys.update(branch_data.get("questions", {}).keys())
+
+    # Check for {{key}} in body that have no matching question
+    for body_name, body_text in bodies.items():
+        clean = re.sub(r"```.*?```", "", body_text, flags=re.DOTALL)
+        clean = re.sub(r"`[^`]+`", "", clean)
+        used_vars = set(re.findall(r"\{\{(\w+)\}\}", clean))
+        missing = used_vars - question_keys - CONTEXT_VAR_NAMES
+        if missing:
+            logger.warning(f"{filename}: variables without a question: {missing}")

rapt0r/core/output.py

@@ -0,0 +1,62 @@
+import os
+import pyperclip
+from datetime import datetime
+from rich.console import Console
+from rich.markdown import Markdown
+from rapt0r.core.utils import clear
+
+_REPO_ROOT = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+_REPO_OUTPUT = os.path.join(_REPO_ROOT, "prompts", "temp")
+_USER_OUTPUT = os.path.expanduser(os.path.join("~", ".rapt0r", "prompts"))
+
+
+def _resolve_output_dir():
+    env = os.environ.get("RAPT0R_OUTPUT_DIR")
+    if env:
+        return env
+    # Dev checkout keeps its prompt history next to the code.
+    if os.path.isdir(os.path.join(_REPO_ROOT, "prompts")):
+        return _REPO_OUTPUT
+    return _USER_OUTPUT
+
+
+OUTPUT_DIR = _resolve_output_dir()
+console = Console()
+SEP = "[bold #d8b4e2]" + "─" * 50 + "[/]"
+
+
+def show_preview(prompt, context_file=None):
+    clear()
+    console.print("[bold #FFFDD0]PROMPT READY:[/]")
+    if context_file:
+        console.print(f"[bold #d8b4e2]project context attached: {context_file}[/]")
+    console.print(SEP)
+    console.print(Markdown(prompt))
+    console.print(SEP)
+
+
+def save_prompt(prompt, name):
+    try:
+        os.makedirs(OUTPUT_DIR, exist_ok=True)
+        timestamp = datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
+        slug = name.lower().replace(" ", "-").replace("/", "-").strip("-")
+        base = f"{timestamp}-{slug}"
+        filepath = os.path.join(OUTPUT_DIR, f"{base}.md")
+        counter = 2
+        while os.path.exists(filepath):
+            filepath = os.path.join(OUTPUT_DIR, f"{base}-{counter}.md")
+            counter += 1
+        with open(filepath, "w", encoding="utf-8") as f:
+            f.write(prompt)
+        return filepath
+    except OSError as e:
+        console.print(f"[bold red]Save error:[/] {e}")
+        return None
+
+
+def copy_to_clipboard(text):
+    try:
+        pyperclip.copy(text)
+        return True, None
+    except Exception as e:
+        return False, str(e)

rapt0r/core/utils.py

@@ -0,0 +1,54 @@
+import os
+import sys
+import subprocess
+
+BRANCH_KEY = "__branch__"
+DEFAULT_BODY = "default"
+PROJECT_CONTEXT_FILE = ".rapt0r"
+
+
+def clear():
+    os.system("cls" if os.name == "nt" else "clear")
+
+
+def pick(value, max_val):
+    if value.isdigit() and 0 <= int(value) <= max_val:
+        return int(value)
+    return None
+
+
+def open_file(path):
+    if sys.platform == "darwin":
+        subprocess.run(["open", path])
+    elif sys.platform == "win32":
+        os.startfile(path)
+    else:
+        subprocess.run(["xdg-open", path])
+
+
+def find_project_context(start_dir=None):
+    """Walk up from start_dir looking for a .rapt0r file.
+
+    Returns (filepath, content) or (None, None)."""
+    current = os.path.abspath(start_dir or os.getcwd())
+    while True:
+        candidate = os.path.join(current, PROJECT_CONTEXT_FILE)
+        if os.path.isfile(candidate):
+            try:
+                with open(candidate, "r", encoding="utf-8") as f:
+                    content = f.read().strip()
+                if content:
+                    return candidate, content
+                return None, None
+            except OSError:
+                return None, None
+        parent = os.path.dirname(current)
+        if parent == current:
+            return None, None
+        current = parent
+
+
+def apply_project_context(prompt, context):
+    if not context:
+        return prompt
+    return f"{prompt}\n\n## Project context\n\n{context}"