raw-llm 1.0.0__tar.gz

raw_llm-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rodolfo Villaruz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

raw_llm-1.0.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include README.md
+include LICENSE
+include Makefile

raw_llm-1.0.0/Makefile

@@ -0,0 +1,38 @@
+SRC = .
+
+.PHONY: all format format-check lint typecheck test check
+
+all: check
+
+check: format-check lint typecheck test
+
+format:
+	isort --profile black $(SRC)
+	black --line-length 79 $(SRC)
+
+format-check:
+	isort --profile black --check-only $(SRC)
+	black --line-length 79 --check $(SRC)
+
+lint:
+	flake8 $(SRC)
+
+typecheck:
+	mypy $(SRC)
+
+test:
+	pytest $(SRC)
+
+clean:
+	find . -type f -name "*.pyc" -delete
+	find . -type d -name "__pycache__" -delete
+	rm -rf build/ dist/ *.egg-info
+
+build: clean
+	python -m build
+
+publish: build
+	twine upload dist/*
+
+publish-test: build
+	twine upload --repository testpypi dist/*

raw_llm-1.0.0/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: raw-llm
+Version: 1.0.0
+Summary: The simplest way to context engineer. Minimal streaming CLI clients for Claude and Gemini.
+Author-email: Rodolfo Villaruz <rodolfo@yes.ph>
+License: MIT
+Project-URL: Homepage, https://github.com/rodolfovillaruz/simple
+Project-URL: Bug Tracker, https://github.com/rodolfovillaruz/simple/issues
+Project-URL: Repository, https://github.com/rodolfovillaruz/simple.git
+Keywords: llm,claude,gemini,cli,streaming,context-engineering
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anthropic>=0.25.0
+Requires-Dist: google-genai>=0.3.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: pylint>=2.17.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: pytest>=7.3.0; extra == "dev"
+Requires-Dist: build>=0.10.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# Simple
+
+**The simplest way to context engineer.**
+
+Minimal, streaming CLI clients for Claude and Gemini that keep your conversations in plain JSON files.
+
+## What is this?
+
+Simple is a pair of thin Python scripts that talk to the Anthropic and Google GenAI APIs. No frameworks, no agents, no abstractions you don't need. Just a prompt, a streaming response, and a JSON file you can version, diff, edit, and pipe.
+
+The entire idea: your conversation _is_ a file. You build context by editing that file. That's it. That's the context engineering.
+
+## Features
+
+- **Streaming output** — responses print token-by-token as they arrive
+- **Conversation persistence** — every exchange is saved to a plain JSON file you own
+- **Resume any conversation** — pass the JSON file back in to continue where you left off
+- **Pipe-friendly** — reads from stdin, writes content to stdout, writes diagnostics to stderr
+- **Colored output** — reasoning in gray (stderr), content in cyan (stdout), auto-disabled when piped
+- **Conflict detection** — refuses to overwrite a conversation file modified by another process
+- **Symlink to switch models** — symlink `claude.py` as `opus` or `haiku` to change the default model
+
+## Installation
+
+```bash
+git clone https://github.com/rodolfovillaruz/simple.git
+cd simple
+pip install anthropic google-genai
+```
+
+Set your API keys:
+
+```bash
+export ANTHROPIC_API_KEY="sk-ant-..."
+export GEMINI_API_KEY="..."       # or GOOGLE_API_KEY, per google-genai docs
+```
+
+## Usage
+
+### Start a new conversation
+
+```bash
+python claude.py
+# Type your prompt, then press Ctrl+D to submit
+```
+
+```bash
+echo "Explain monads in one paragraph" | python claude.py
+```
+
+```bash
+python gemini.py
+```
+
+### Resume an existing conversation
+
+```bash
+python claude.py .prompt/some-conversation.json
+```
+
+The JSON file contains the full message history. Edit it with any text editor to reshape context before your next turn.
+
+### Pipe a file as context
+
+```bash
+cat code.py | python claude.py conversation.json
+```
+
+### Switch models
+
+```bash
+# By flag
+python claude.py -m claude-opus-4-6
+
+# By symlink
+ln -s claude.py opus
+./opus
+```
+
+| Symlink name         | Default model          |
+| -------------------- | ---------------------- |
+| `claude.py` (default)| `claude-sonnet-4-6`    |
+| `claude-opus` / `opus`| `claude-opus-4-6`     |
+| `claude-haiku` / `haiku`| `claude-haiku-4-5`  |
+| `gemini.py` (default)| `gemini-3.1-pro-preview` |
+
+### Options
+
+```
+usage: claude.py [-h] [-n] [-v] [-m MODEL] [-t MAX_TOKENS] [-i] [conversation_file]
+
+positional arguments:
+  conversation_file         JSON file to resume (omit to start fresh)
+
+options:
+  -n, --dry-run             Build the prompt but don't send it
+  -v, --verbose             Show model name and prompt preview
+  -m, --model MODEL         Override the default model
+  -t, --max-tokens TOKENS   Cap the response length
+  -i, --interactive         Interactive REPL mode
+```
+
+## Conversation format
+
+Conversations are stored as a JSON array of message objects, the same shape both APIs understand:
+
+```json
+[
+  {
+    "role": "user",
+    "content": "What is context engineering?"
+  },
+  {
+    "role": "assistant",
+    "content": "Context engineering is the practice of ..."
+  }
+]
+```
+
+You can create these files by hand, merge them, truncate them, or generate them with other tools. Simple doesn't care. It reads the array, appends your new message, streams the response, and appends that too.
+
+## Project structure
+
+```
+.
+├── claude.py       # Claude CLI client
+├── gemini.py       # Gemini CLI client
+├── common.py       # Shared utilities (streaming, I/O, conversation management)
+├── Makefile        # Formatting, linting, typing
+└── .prompt/        # Default directory for conversation files (auto-used if present)
+```
+
+## Development
+
+```bash
+make fmt      # Format with black/isort
+make lint     # Lint with pylint/flake8
+make type     # Type-check with mypy
+make all      # All of the above
+```
+
+## Why?
+
+Most LLM tools add layers between you and the model. Simple removes them. The conversation is a file. The prompt is stdin. The response is stdout. Everything else is up to you.
+
+## License
+
+MIT

raw_llm-1.0.0/README.md

@@ -0,0 +1,148 @@
+# Simple
+
+**The simplest way to context engineer.**
+
+Minimal, streaming CLI clients for Claude and Gemini that keep your conversations in plain JSON files.
+
+## What is this?
+
+Simple is a pair of thin Python scripts that talk to the Anthropic and Google GenAI APIs. No frameworks, no agents, no abstractions you don't need. Just a prompt, a streaming response, and a JSON file you can version, diff, edit, and pipe.
+
+The entire idea: your conversation _is_ a file. You build context by editing that file. That's it. That's the context engineering.
+
+## Features
+
+- **Streaming output** — responses print token-by-token as they arrive
+- **Conversation persistence** — every exchange is saved to a plain JSON file you own
+- **Resume any conversation** — pass the JSON file back in to continue where you left off
+- **Pipe-friendly** — reads from stdin, writes content to stdout, writes diagnostics to stderr
+- **Colored output** — reasoning in gray (stderr), content in cyan (stdout), auto-disabled when piped
+- **Conflict detection** — refuses to overwrite a conversation file modified by another process
+- **Symlink to switch models** — symlink `claude.py` as `opus` or `haiku` to change the default model
+
+## Installation
+
+```bash
+git clone https://github.com/rodolfovillaruz/simple.git
+cd simple
+pip install anthropic google-genai
+```
+
+Set your API keys:
+
+```bash
+export ANTHROPIC_API_KEY="sk-ant-..."
+export GEMINI_API_KEY="..."       # or GOOGLE_API_KEY, per google-genai docs
+```
+
+## Usage
+
+### Start a new conversation
+
+```bash
+python claude.py
+# Type your prompt, then press Ctrl+D to submit
+```
+
+```bash
+echo "Explain monads in one paragraph" | python claude.py
+```
+
+```bash
+python gemini.py
+```
+
+### Resume an existing conversation
+
+```bash
+python claude.py .prompt/some-conversation.json
+```
+
+The JSON file contains the full message history. Edit it with any text editor to reshape context before your next turn.
+
+### Pipe a file as context
+
+```bash
+cat code.py | python claude.py conversation.json
+```
+
+### Switch models
+
+```bash
+# By flag
+python claude.py -m claude-opus-4-6
+
+# By symlink
+ln -s claude.py opus
+./opus
+```
+
+| Symlink name         | Default model          |
+| -------------------- | ---------------------- |
+| `claude.py` (default)| `claude-sonnet-4-6`    |
+| `claude-opus` / `opus`| `claude-opus-4-6`     |
+| `claude-haiku` / `haiku`| `claude-haiku-4-5`  |
+| `gemini.py` (default)| `gemini-3.1-pro-preview` |
+
+### Options
+
+```
+usage: claude.py [-h] [-n] [-v] [-m MODEL] [-t MAX_TOKENS] [-i] [conversation_file]
+
+positional arguments:
+  conversation_file         JSON file to resume (omit to start fresh)
+
+options:
+  -n, --dry-run             Build the prompt but don't send it
+  -v, --verbose             Show model name and prompt preview
+  -m, --model MODEL         Override the default model
+  -t, --max-tokens TOKENS   Cap the response length
+  -i, --interactive         Interactive REPL mode
+```
+
+## Conversation format
+
+Conversations are stored as a JSON array of message objects, the same shape both APIs understand:
+
+```json
+[
+  {
+    "role": "user",
+    "content": "What is context engineering?"
+  },
+  {
+    "role": "assistant",
+    "content": "Context engineering is the practice of ..."
+  }
+]
+```
+
+You can create these files by hand, merge them, truncate them, or generate them with other tools. Simple doesn't care. It reads the array, appends your new message, streams the response, and appends that too.
+
+## Project structure
+
+```
+.
+├── claude.py       # Claude CLI client
+├── gemini.py       # Gemini CLI client
+├── common.py       # Shared utilities (streaming, I/O, conversation management)
+├── Makefile        # Formatting, linting, typing
+└── .prompt/        # Default directory for conversation files (auto-used if present)
+```
+
+## Development
+
+```bash
+make fmt      # Format with black/isort
+make lint     # Lint with pylint/flake8
+make type     # Type-check with mypy
+make all      # All of the above
+```
+
+## Why?
+
+Most LLM tools add layers between you and the model. Simple removes them. The conversation is a file. The prompt is stdin. The response is stdout. Everything else is up to you.
+
+## License
+
+MIT

raw_llm-1.0.0/pyproject.toml

@@ -0,0 +1,75 @@
+[build-system]
+requires = ["setuptools>=65.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "raw-llm"
+version = "1.0.0"
+description = "The simplest way to context engineer. Minimal streaming CLI clients for Claude and Gemini."
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [
+    {name = "Rodolfo Villaruz", email = "rodolfo@yes.ph"}
+]
+keywords = ["llm", "claude", "gemini", "cli", "streaming", "context-engineering"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Operating System :: OS Independent",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+
+dependencies = [
+    "anthropic>=0.25.0",
+    "google-genai>=0.3.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "black>=23.0.0",
+    "isort>=5.12.0",
+    "pylint>=2.17.0",
+    "flake8>=6.0.0",
+    "mypy>=1.0.0",
+    "pytest>=7.3.0",
+    "build>=0.10.0",
+    "twine>=4.0.0",
+]
+
+[project.scripts]
+raw-claude = "raw_llm.claude:main"
+raw-gemini = "raw_llm.gemini:main"
+
+[project.urls]
+Homepage = "https://github.com/rodolfovillaruz/simple"
+"Bug Tracker" = "https://github.com/rodolfovillaruz/simple/issues"
+Repository = "https://github.com/rodolfovillaruz/simple.git"
+
+[tool.setuptools]
+packages = ["raw_llm"]
+
+[tool.setuptools.package-dir]
+"" = "src"
+
+[tool.black]
+line-length = 88
+target-version = ["py39", "py310", "py311", "py312"]
+
+[tool.isort]
+profile = "black"
+line_length = 88
+
+[tool.mypy]
+python_version = "3.9"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = false
+
+[tool.pylint.messages_control]
+disable = ["C0111", "R0903"]

raw_llm-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

raw_llm-1.0.0/src/raw_llm/claude.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python
+"""
+Claude CLI Client.
+
+This script interacts with the Anthropic API to generate content based on
+user input or existing conversation files.
+"""
+
+import sys
+from pathlib import Path
+from typing import Iterable
+
+import anthropic
+from anthropic.types import MessageParam
+
+from common import (
+    StreamPrinter,
+    create_parser,
+    get_question,
+    load_conversation,
+    prompt_preview,
+    save_conversation_safely,
+    spinning,
+)
+
+
+def stream_claude_response(
+    client: anthropic.Anthropic,
+    model: str,
+    messages: Iterable[MessageParam],
+    max_tokens: int,
+) -> str:
+    """
+    Stream the response from the Claude API with extended thinking.
+    Returns the full assistant content.
+    """
+    printer = StreamPrinter()
+    assistant_content = []
+
+    try:
+        actual_max_tokens = int(max_tokens) if max_tokens else 20000
+        budget_tokens = max(actual_max_tokens - 1024, 1024)
+
+        with client.messages.stream(
+            max_tokens=actual_max_tokens,
+            messages=messages,
+            model=model,
+            thinking={
+                "type": "enabled",
+                "budget_tokens": budget_tokens,
+            },
+        ) as stream:
+            for event in stream:
+                if event.type == "content_block_start":
+                    if event.content_block.type == "thinking":
+                        printer.write_reasoning("")  # activate reasoning color
+                    elif event.content_block.type == "text":
+                        pass
+                elif event.type == "content_block_delta":
+                    if event.delta.type == "thinking_delta":
+                        printer.write_reasoning(event.delta.thinking)
+                    elif event.delta.type == "text_delta":
+                        printer.write_content(event.delta.text)
+                        assistant_content.append(event.delta.text)
+
+    except ConnectionError as e:
+        printer.close()
+        sys.stderr.write(f"\nError during streaming: {e}\n")
+        sys.exit(1)
+
+    printer.close()
+    return "".join(assistant_content)
+
+
+def main() -> None:
+    "Main function"
+
+    match Path(__file__).name:
+        case "claude-opus" | "opus":
+            model = "claude-opus-4-6"
+        case "claude-haiku" | "haiku":
+            model = "claude-haiku-4-5"
+        case _:
+            model = "claude-sonnet-4-6"
+
+    parser = create_parser(
+        description="Resume a conversation with Claude",
+        model=model,
+    )
+    args = parser.parse_args()
+
+    try:
+        client = anthropic.Anthropic()
+    except ConnectionError as e:
+        sys.stderr.write(f"Error initializing Claude client: {e}\n")
+        sys.stderr.write(
+            "Ensure ANTHROPIC_API_KEY environment variable is set.\n"
+        )
+        sys.exit(1)
+
+    filename, messages, file_hash = load_conversation(args.conversation_file)
+
+    if args.verbose > 0:
+        sys.stderr.write(f"Model: {args.model}\n\n")
+        sys.stderr.flush()
+
+    question = get_question()
+    if not question:
+        raise ValueError("No messages to send")
+
+    sys.stderr.write("\n")
+    sys.stderr.flush()
+
+    if args.verbose > 0:
+        prompt_preview(question)
+
+    messages.append({"role": "user", "content": question})
+
+    if args.dry_run:
+        sys.exit(0)
+
+    assistant_content = stream_claude_response(
+        client, args.model, messages, args.max_tokens
+    )
+
+    messages.append({"role": "assistant", "content": assistant_content})
+
+    sys.stderr.write("\n")
+    sys.stderr.flush()
+
+    save_conversation_safely(messages, filename, file_hash)
+
+
+if __name__ == "__main__":
+    main()

raw_llm-1.0.0/src/raw_llm/common.py

@@ -0,0 +1,287 @@
+"""Common utilities for AI conversation tools."""
+
+import argparse
+import contextlib
+import hashlib
+import itertools
+import json
+import os
+import sys
+import threading
+import time
+import uuid
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from anthropic.types import MessageParam
+
+# Try to import readline for better input line editing (Unix only)
+try:
+    import readline  # noqa: F401  # pylint: disable=unused-import
+except ImportError:
+    pass
+
+PROMPT_FOLDER = ".prompt"
+EMPTY_HASH = hashlib.sha256(b"").hexdigest()
+
+
+def spinner_task(
+    spinner_chars: itertools.cycle, done: threading.Event, label: str
+) -> None:
+    """Show a spinner animation on stderr until done event is set."""
+    start = time.perf_counter()
+    for char in spinner_chars:
+        elapsed = time.perf_counter() - start
+        sys.stderr.write(f"\r\033[K{label} {char} ({elapsed:.1f}s)")
+        sys.stderr.flush()
+        if done.wait(0.1):
+            break
+    elapsed = time.perf_counter() - start
+    sys.stderr.write(f"\r\033[K{label} done ({elapsed:.1f}s)\n")
+    sys.stderr.flush()
+
+
+@contextlib.contextmanager
+def spinning(label: str = "Working"):
+    """Context manager that displays a spinner while code executes."""
+    spinner = itertools.cycle("⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏")
+    done_flag = threading.Event()
+    thread = threading.Thread(
+        target=spinner_task, args=(spinner, done_flag, label), daemon=True
+    )
+    thread.start()
+    try:
+        yield
+    finally:
+        done_flag.set()
+        thread.join()
+
+
+def ask_yes_no(prompt: str) -> bool:
+    """Return True if the user answers 'y' or 'yes' (case-insensitive)."""
+    sys.stderr.write(f"{prompt} [y/N] ")
+    sys.stderr.flush()
+    answer = input().strip().lower()
+    return answer.startswith("y")
+
+
+def ask_filename(default: str) -> Path:
+    """
+    Ask for a filename.
+    If the file already exists the user is asked whether to overwrite it.
+    The question is repeated until a valid answer is given.
+    """
+    while True:
+        sys.stderr.write(f"\nFilename [{default}]: ")
+        sys.stderr.flush()
+        name = input().strip() or default
+
+        if not os.path.exists(name):
+            return Path(name)
+
+        sys.stderr.write(f'File "{name}" exists. Overwrite? [y/N]: ')
+        sys.stderr.flush()
+        choice = input().strip().lower()
+        if choice in {"y", "yes"}:
+            return Path(name)
+
+
+def same_hash(path: Path, old_hash: str) -> bool:
+    """True -> file still has the same sha256 we saw when we loaded it."""
+    return old_hash == hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def get_question() -> str:
+    """Read question from stdin without stripping."""
+    if sys.stdin.isatty():
+        sys.stderr.write("Press Ctrl+D to submit\n\n")
+        sys.stderr.flush()
+        lines = []
+        while True:
+            try:
+                line = input()
+                lines.append(line)
+            except EOFError:
+                break
+        return "\n".join(lines)
+
+    # Non-interactive: read entire stdin
+    return sys.stdin.read()
+
+
+def get_width() -> int:
+    """Get terminal width"""
+    try:
+        return os.get_terminal_size().columns
+    except OSError:
+        return 80
+
+
+def prompt_preview(prompt: str):
+    """Preview prompt with visual markers"""
+    width = get_width()
+    start = "[ PROMPT ] "
+    end = "[ / PROMPT ] "
+    asterisks_start = "*" * (width - len(start))
+    asterisks_end = "*" * (width - len(end))
+    sys.stderr.write(
+        "\n".join(
+            [
+                start + asterisks_start,
+                prompt.rstrip(),
+                end + asterisks_end + "\n\n",
+            ]
+        )
+    )
+    sys.stderr.flush()
+
+
+def create_parser(description: str, model: str) -> argparse.ArgumentParser:
+    """Create an argument parser with common arguments."""
+    parser = argparse.ArgumentParser(description=description)
+    parser.add_argument(
+        "conversation_file", nargs="?", default=None, help="Conversation file"
+    )
+    parser.add_argument(
+        "-n", "--dry-run", action="store_true", help="Run without submitting"
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="count",
+        default=0,
+        help="Increase output verbosity (-v = INFO, -vv = DEBUG)",
+    )
+    parser.add_argument(
+        "-m",
+        "--model",
+        type=str,
+        default=model,
+        help="Name or identifier of the model to use",
+    )
+    parser.add_argument(
+        "-t",
+        "--max-tokens",
+        type=str,
+        help="Maximum number of tokens that can be generated in the response.",
+    )
+    parser.add_argument(
+        "-i",
+        "--interactive",
+        action="store_true",
+        help="Interactive REPL mode (each line is a separate message)",
+    )
+    return parser
+
+
+def load_conversation(
+    filepath_arg: Optional[str],
+) -> Tuple[Path, List[MessageParam], str]:
+    "Load conversation from file or create new file path if it does not exist."
+
+    if not filepath_arg:
+        if os.path.isdir(PROMPT_FOLDER):
+            filename = (Path(PROMPT_FOLDER) / str(uuid.uuid1())).with_suffix(
+                ".json"
+            )
+        else:
+            filename = Path(str(uuid.uuid1())).with_suffix(".json")
+    else:
+        filename = Path(filepath_arg)
+
+    try:
+        with filename.open(encoding="utf-8") as fh:
+            content_str = fh.read()
+            json_content = json.loads(content_str)
+            file_hash = hashlib.sha256(content_str.encode("utf-8")).hexdigest()
+    except FileNotFoundError:
+        file_hash = EMPTY_HASH
+        json_content = []
+    except (json.JSONDecodeError, ValueError) as exc:
+        raise AssertionError(
+            f"Content of '{filename}' is not valid JSON: {exc}"
+        ) from exc
+
+    return filename, json_content, file_hash
+
+
+def save_to_file(messages: list[MessageParam], filename: Path) -> Path:
+    """Save messages to JSON file."""
+    with filename.open("w", encoding="utf-8") as f:
+        json.dump(messages, f, indent=2, ensure_ascii=False)
+    return filename
+
+
+def save_conversation_safely(
+    messages: List[MessageParam], filename: Path, original_hash: str
+) -> None:
+    "Save conversation to file if it hasn't been modified elsewhere."
+
+    if original_hash == EMPTY_HASH:
+        save_to_file(messages, filename)
+        sys.stderr.write(f"\nSaved to {filename}\n")
+    elif same_hash(filename, original_hash):
+        save_to_file(messages, filename)
+        sys.stderr.write(f"\nSaved to {filename}\n")
+    else:
+        sys.stderr.write(
+            f"\nError: “{filename}” has been modified by another process.\n"
+        )
+        sys.exit(2)
+
+
+def get_colors() -> Dict[str, str]:
+    """
+    Return color escape sequences for reasoning and content output,
+    empty strings if the corresponding stream is not a terminal.
+    """
+    colors = {}
+    if sys.stderr.isatty():
+        colors["reasoning"] = "\033[90m"
+        colors["reasoning_reset"] = "\033[0m"
+    else:
+        colors["reasoning"] = colors["reasoning_reset"] = ""
+    if sys.stdout.isatty():
+        colors["content"] = "\033[36m"
+        colors["content_reset"] = "\033[0m"
+    else:
+        colors["content"] = colors["content_reset"] = ""
+    return colors
+
+
+class StreamPrinter:
+    """Handles colored output of reasoning and content streams."""
+
+    def __init__(self):
+        self.colors = get_colors()
+        self.reasoning_active = False
+        self.content_active = False
+
+    def write_reasoning(self, text: str) -> None:
+        """Write reasoning text to stderr with appropriate coloring."""
+        if not self.reasoning_active:
+            sys.stderr.write(self.colors["reasoning"])
+            self.reasoning_active = True
+        sys.stderr.write(text)
+        sys.stderr.flush()
+
+    def write_content(self, text: str) -> None:
+        """Write content text to stdout with appropriate coloring."""
+        if self.reasoning_active:
+            sys.stderr.write(self.colors["reasoning_reset"])
+            sys.stderr.flush()
+            self.reasoning_active = False
+        if not self.content_active:
+            sys.stdout.write(self.colors["content"])
+            self.content_active = True
+        sys.stdout.write(text)
+        sys.stdout.flush()
+
+    def close(self) -> None:
+        """Reset colors if any were active."""
+        if self.reasoning_active:
+            sys.stderr.write(self.colors["reasoning_reset"])
+            sys.stderr.flush()
+        if self.content_active:
+            sys.stdout.write(self.colors["content_reset"])
+            sys.stdout.flush()

raw_llm-1.0.0/src/raw_llm/gemini.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python
+"""
+Gemini CLI Client.
+
+This script interacts with the Google GenAI API to generate content based on
+user input or existing conversation files.
+"""
+
+import sys
+from typing import Any, Dict, List
+
+from google import genai
+from google.genai.types import (
+    Content,
+    GenerateContentConfig,
+    Part,
+    ThinkingConfig,
+    ThinkingLevel,
+)
+
+from common import (
+    StreamPrinter,
+    create_parser,
+    get_question,
+    load_conversation,
+    prompt_preview,
+    save_conversation_safely,
+)
+
+
+def stream_gemini_response(
+    client: genai.Client,
+    model: str,
+    contents: list[Content],  # Changed from Sequence[Content]
+    config: GenerateContentConfig,
+) -> str:
+    """
+    Stream the response from the Gemini API, printing reasoning to stderr
+    and content to stdout. Returns the full assistant content.
+    """
+    printer = StreamPrinter()
+    assistant_parts = []
+
+    try:
+        stream = client.models.generate_content_stream(
+            contents=contents,  # type: ignore[arg-type]
+            model=model,
+            config=config,
+        )
+
+        for chunk in stream:
+            if not chunk.candidates:
+                continue
+            for candidate in chunk.candidates:
+                if not candidate.content or not candidate.content.parts:
+                    continue
+                for part in candidate.content.parts:
+                    text = part.text
+                    if not text:
+                        continue
+                    # Gemini marks reasoning with the 'thought' attribute
+                    if getattr(part, "thought", False):
+                        printer.write_reasoning(text)
+                    else:
+                        printer.write_content(text)
+                        assistant_parts.append(text)
+
+    except ConnectionError as e:
+        printer.close()
+        sys.stderr.write(f"\nError during streaming: {e}\n")
+        sys.exit(1)
+
+    printer.close()
+    return "".join(assistant_parts)
+
+
+def main() -> None:
+    "Main function"
+
+    parser = create_parser(
+        description="Resume a file specified filename",
+        model="gemini-3.1-pro-preview",
+    )
+    args = parser.parse_args()
+
+    # Initialize Gemini client
+    client = genai.Client()
+
+    filename, messages, file_hash = load_conversation(args.conversation_file)
+
+    if args.verbose > 0:
+        sys.stderr.write(f"Model: {args.model}\n\n")
+        sys.stderr.flush()
+
+    question = get_question()
+    if not question:
+        raise ValueError("No messages to send")
+
+    sys.stderr.write("\n")
+    sys.stderr.flush()
+
+    if args.verbose > 0:
+        prompt_preview(question)
+
+    messages.append({"role": "user", "content": question})
+
+    if args.dry_run:
+        sys.exit(0)
+
+    # Build Gemini Content objects
+    contents: List[Content] = []
+    for msg in messages:
+        role_str: str = "model" if msg["role"] == "assistant" else msg["role"]
+
+        content = msg["content"]
+        if isinstance(content, str):
+            text_content = content
+        else:
+            text_content = str(content)
+
+        part = Part.from_text(text=text_content)
+        contents.append(Content(role=role_str, parts=[part]))
+
+    config_kwargs: Dict[str, Any] = {
+        "thinking_config": ThinkingConfig(
+            thinking_level=ThinkingLevel.HIGH,
+            include_thoughts=True,
+        )
+    }
+    if args.max_tokens:
+        config_kwargs["max_output_tokens"] = int(args.max_tokens)
+
+    config = GenerateContentConfig(**config_kwargs)
+
+    assistant_content = stream_gemini_response(
+        client, args.model, contents, config
+    )
+
+    messages.append({"role": "assistant", "content": assistant_content})
+
+    sys.stderr.write("\n")
+    sys.stderr.flush()
+
+    save_conversation_safely(messages, filename, file_hash)
+
+
+if __name__ == "__main__":
+    main()

raw_llm-1.0.0/src/raw_llm.egg-info/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: raw-llm
+Version: 1.0.0
+Summary: The simplest way to context engineer. Minimal streaming CLI clients for Claude and Gemini.
+Author-email: Rodolfo Villaruz <rodolfo@yes.ph>
+License: MIT
+Project-URL: Homepage, https://github.com/rodolfovillaruz/simple
+Project-URL: Bug Tracker, https://github.com/rodolfovillaruz/simple/issues
+Project-URL: Repository, https://github.com/rodolfovillaruz/simple.git
+Keywords: llm,claude,gemini,cli,streaming,context-engineering
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anthropic>=0.25.0
+Requires-Dist: google-genai>=0.3.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: isort>=5.12.0; extra == "dev"
+Requires-Dist: pylint>=2.17.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: pytest>=7.3.0; extra == "dev"
+Requires-Dist: build>=0.10.0; extra == "dev"
+Requires-Dist: twine>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# Simple
+
+**The simplest way to context engineer.**
+
+Minimal, streaming CLI clients for Claude and Gemini that keep your conversations in plain JSON files.
+
+## What is this?
+
+Simple is a pair of thin Python scripts that talk to the Anthropic and Google GenAI APIs. No frameworks, no agents, no abstractions you don't need. Just a prompt, a streaming response, and a JSON file you can version, diff, edit, and pipe.
+
+The entire idea: your conversation _is_ a file. You build context by editing that file. That's it. That's the context engineering.
+
+## Features
+
+- **Streaming output** — responses print token-by-token as they arrive
+- **Conversation persistence** — every exchange is saved to a plain JSON file you own
+- **Resume any conversation** — pass the JSON file back in to continue where you left off
+- **Pipe-friendly** — reads from stdin, writes content to stdout, writes diagnostics to stderr
+- **Colored output** — reasoning in gray (stderr), content in cyan (stdout), auto-disabled when piped
+- **Conflict detection** — refuses to overwrite a conversation file modified by another process
+- **Symlink to switch models** — symlink `claude.py` as `opus` or `haiku` to change the default model
+
+## Installation
+
+```bash
+git clone https://github.com/rodolfovillaruz/simple.git
+cd simple
+pip install anthropic google-genai
+```
+
+Set your API keys:
+
+```bash
+export ANTHROPIC_API_KEY="sk-ant-..."
+export GEMINI_API_KEY="..."       # or GOOGLE_API_KEY, per google-genai docs
+```
+
+## Usage
+
+### Start a new conversation
+
+```bash
+python claude.py
+# Type your prompt, then press Ctrl+D to submit
+```
+
+```bash
+echo "Explain monads in one paragraph" | python claude.py
+```
+
+```bash
+python gemini.py
+```
+
+### Resume an existing conversation
+
+```bash
+python claude.py .prompt/some-conversation.json
+```
+
+The JSON file contains the full message history. Edit it with any text editor to reshape context before your next turn.
+
+### Pipe a file as context
+
+```bash
+cat code.py | python claude.py conversation.json
+```
+
+### Switch models
+
+```bash
+# By flag
+python claude.py -m claude-opus-4-6
+
+# By symlink
+ln -s claude.py opus
+./opus
+```
+
+| Symlink name         | Default model          |
+| -------------------- | ---------------------- |
+| `claude.py` (default)| `claude-sonnet-4-6`    |
+| `claude-opus` / `opus`| `claude-opus-4-6`     |
+| `claude-haiku` / `haiku`| `claude-haiku-4-5`  |
+| `gemini.py` (default)| `gemini-3.1-pro-preview` |
+
+### Options
+
+```
+usage: claude.py [-h] [-n] [-v] [-m MODEL] [-t MAX_TOKENS] [-i] [conversation_file]
+
+positional arguments:
+  conversation_file         JSON file to resume (omit to start fresh)
+
+options:
+  -n, --dry-run             Build the prompt but don't send it
+  -v, --verbose             Show model name and prompt preview
+  -m, --model MODEL         Override the default model
+  -t, --max-tokens TOKENS   Cap the response length
+  -i, --interactive         Interactive REPL mode
+```
+
+## Conversation format
+
+Conversations are stored as a JSON array of message objects, the same shape both APIs understand:
+
+```json
+[
+  {
+    "role": "user",
+    "content": "What is context engineering?"
+  },
+  {
+    "role": "assistant",
+    "content": "Context engineering is the practice of ..."
+  }
+]
+```
+
+You can create these files by hand, merge them, truncate them, or generate them with other tools. Simple doesn't care. It reads the array, appends your new message, streams the response, and appends that too.
+
+## Project structure
+
+```
+.
+├── claude.py       # Claude CLI client
+├── gemini.py       # Gemini CLI client
+├── common.py       # Shared utilities (streaming, I/O, conversation management)
+├── Makefile        # Formatting, linting, typing
+└── .prompt/        # Default directory for conversation files (auto-used if present)
+```
+
+## Development
+
+```bash
+make fmt      # Format with black/isort
+make lint     # Lint with pylint/flake8
+make type     # Type-check with mypy
+make all      # All of the above
+```
+
+## Why?
+
+Most LLM tools add layers between you and the model. Simple removes them. The conversation is a file. The prompt is stdin. The response is stdout. Everything else is up to you.
+
+## License
+
+MIT

raw_llm-1.0.0/src/raw_llm.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+MANIFEST.in
+Makefile
+README.md
+pyproject.toml
+src/raw_llm/__init__.py
+src/raw_llm/claude.py
+src/raw_llm/common.py
+src/raw_llm/gemini.py
+src/raw_llm.egg-info/PKG-INFO
+src/raw_llm.egg-info/SOURCES.txt
+src/raw_llm.egg-info/dependency_links.txt
+src/raw_llm.egg-info/entry_points.txt
+src/raw_llm.egg-info/requires.txt
+src/raw_llm.egg-info/top_level.txt

raw_llm-1.0.0/src/raw_llm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

raw_llm-1.0.0/src/raw_llm.egg-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+raw-claude = raw_llm.claude:main
+raw-gemini = raw_llm.gemini:main

raw_llm-1.0.0/src/raw_llm.egg-info/requires.txt

@@ -0,0 +1,12 @@
+anthropic>=0.25.0
+google-genai>=0.3.0
+
+[dev]
+black>=23.0.0
+isort>=5.12.0
+pylint>=2.17.0
+flake8>=6.0.0
+mypy>=1.0.0
+pytest>=7.3.0
+build>=0.10.0
+twine>=4.0.0

raw_llm-1.0.0/src/raw_llm.egg-info/top_level.txt

@@ -0,0 +1 @@
+raw_llm