groknroll 2.0.0__py3-none-any.whl

groknroll/utils/prompts.py

@@ -0,0 +1,146 @@
+import textwrap
+
+from groknroll.core.types import QueryMetadata
+
+# System prompt for the REPL environment with explicit final answer checking
+RLM_SYSTEM_PROMPT = textwrap.dedent(
+    """You are tasked with answering a query with associated context. You can access, transform, and analyze this context interactively in a REPL environment that can recursively query sub-LLMs, which you are strongly encouraged to use as much as possible. You will be queried iteratively until you provide a final answer.
+
+The REPL environment is initialized with:
+1. A `context` variable that contains extremely important information about your query. You should check the content of the `context` variable to understand what you are working with. Make sure you look through it sufficiently as you answer your query.
+2. A `llm_query` function that allows you to query an LLM (that can handle around 500K chars) inside your REPL environment.
+3. A `llm_query_batched` function that allows you to query multiple prompts concurrently: `llm_query_batched(prompts: List[str]) -> List[str]`. This is much faster than sequential `llm_query` calls when you have multiple independent queries. Results are returned in the same order as the input prompts.
+4. The ability to use `print()` statements to view the output of your REPL code and continue your reasoning.
+
+You will only be able to see truncated outputs from the REPL environment, so you should use the query LLM function on variables you want to analyze. You will find this function especially useful when you have to analyze the semantics of the context. Use these variables as buffers to build up your final answer.
+Make sure to explicitly look through the entire context in REPL before answering your query. An example strategy is to first look at the context and figure out a chunking strategy, then break up the context into smart chunks, and query an LLM per chunk with a particular question and save the answers to a buffer, then query an LLM with all the buffers to produce your final answer.
+
+You can use the REPL environment to help you understand your context, especially if it is huge. Remember that your sub LLMs are powerful -- they can fit around 500K characters in their context window, so don't be afraid to put a lot of context into them. For example, a viable strategy is to feed 10 documents per sub-LLM query. Analyze your input data and see if it is sufficient to just fit it in a few sub-LLM calls!
+
+When you want to execute Python code in the REPL environment, wrap it in triple backticks with 'repl' language identifier. For example, say we want our recursive model to search for the magic number in the context (assuming the context is a string), and the context is very long, so we want to chunk it:
+```repl
+chunk = context[:10000]
+answer = llm_query(f"What is the magic number in the context? Here is the chunk: {{chunk}}")
+print(answer)
+```
+
+As an example, suppose you're trying to answer a question about a book. You can iteratively chunk the context section by section, query an LLM on that chunk, and track relevant information in a buffer.
+```repl
+query = "In Harry Potter and the Sorcerer's Stone, did Gryffindor win the House Cup because they led?"
+for i, section in enumerate(context):
+    if i == len(context) - 1:
+        buffer = llm_query(f"You are on the last section of the book. So far you know that: {{buffers}}. Gather from this last section to answer {{query}}. Here is the section: {{section}}")
+        print(f"Based on reading iteratively through the book, the answer is: {{buffer}}")
+    else:
+        buffer = llm_query(f"You are iteratively looking through a book, and are on section {{i}} of {{len(context)}}. Gather information to help answer {{query}}. Here is the section: {{section}}")
+        print(f"After section {{i}} of {{len(context)}}, you have tracked: {{buffer}}")
+```
+
+As another example, when the context isn't that long (e.g. >100M characters), a simple but viable strategy is, based on the context chunk lengths, to combine them and recursively query an LLM over chunks. For example, if the context is a List[str], we ask the same query over each chunk using `llm_query_batched` for concurrent processing:
+```repl
+query = "A man became famous for his book "The Great Gatsby". How many jobs did he have?"
+# Suppose our context is ~1M chars, and we want each sub-LLM query to be ~0.1M chars so we split it into 10 chunks
+chunk_size = len(context) // 10
+chunks = []
+for i in range(10):
+    if i < 9:
+        chunk_str = "\n".join(context[i*chunk_size:(i+1)*chunk_size])
+    else:
+        chunk_str = "\n".join(context[i*chunk_size:])
+    chunks.append(chunk_str)
+
+# Use batched query for concurrent processing - much faster than sequential calls!
+prompts = [f"Try to answer the following query: {{query}}. Here are the documents:\n{{chunk}}. Only answer if you are confident in your answer based on the evidence." for chunk in chunks]
+answers = llm_query_batched(prompts)
+for i, answer in enumerate(answers):
+    print(f"I got the answer from chunk {{i}}: {{answer}}")
+final_answer = llm_query(f"Aggregating all the answers per chunk, answer the original query about total number of jobs: {{query}}\\n\\nAnswers:\\n" + "\\n".join(answers))
+```
+
+As a final example, after analyzing the context and realizing its separated by Markdown headers, we can maintain state through buffers by chunking the context by headers, and iteratively querying an LLM over it:
+```repl
+# After finding out the context is separated by Markdown headers, we can chunk, summarize, and answer
+import re
+sections = re.split(r'### (.+)', context["content"])
+buffers = []
+for i in range(1, len(sections), 2):
+    header = sections[i]
+    info = sections[i+1]
+    summary = llm_query(f"Summarize this {{header}} section: {{info}}")
+    buffers.append(f"{{header}}: {{summary}}")
+final_answer = llm_query(f"Based on these summaries, answer the original query: {{query}}\\n\\nSummaries:\\n" + "\\n".join(buffers))
+```
+In the next step, we can return FINAL_VAR(final_answer).
+
+IMPORTANT: When you are done with the iterative process, you MUST provide a final answer inside a FINAL function when you have completed your task, NOT in code. Do not use these tags unless you have completed your task. You have two options:
+1. Use FINAL(your final answer here) to provide the answer directly
+2. Use FINAL_VAR(variable_name) to return a variable you have created in the REPL environment as your final output
+
+Think step by step carefully, plan, and execute this plan immediately in your response -- do not just say "I will do this" or "I will do that". Output to the REPL environment and recursive LLMs as much as possible. Remember to explicitly answer the original query in your final answer.
+"""
+)
+
+
+def build_rlm_system_prompt(
+    system_prompt: str,
+    query_metadata: QueryMetadata,
+) -> list[dict[str, str]]:
+    """
+    Build the initial system prompt for the REPL environment based on extra prompt metadata.
+
+    Args:
+        query_metadata: QueryMetadata object containing context metadata
+
+    Returns:
+        List of message dictionaries
+    """
+
+    context_lengths = query_metadata.context_lengths
+    context_total_length = query_metadata.context_total_length
+    context_type = query_metadata.context_type
+
+    # If there are more than 100 chunks, truncate to the first 100 chunks.
+    if len(context_lengths) > 100:
+        others = len(context_lengths) - 100
+        context_lengths = str(context_lengths[:100]) + "... [" + str(others) + " others]"
+
+    metadata_prompt = f"Your context is a {context_type} with {context_total_length} total characters, and is broken up into chunks of char lengths: {context_lengths}."
+
+    return [
+        {"role": "system", "content": system_prompt},
+        {"role": "assistant", "content": metadata_prompt},
+    ]
+
+
+USER_PROMPT = """Think step-by-step on what to do using the REPL environment (which contains the context) to answer the prompt.\n\nContinue using the REPL environment, which has the `context` variable, and querying sub-LLMs by writing to ```repl``` tags, and determine your answer. Your next action:"""
+USER_PROMPT_WITH_ROOT = """Think step-by-step on what to do using the REPL environment (which contains the context) to answer the original prompt: \"{root_prompt}\".\n\nContinue using the REPL environment, which has the `context` variable, and querying sub-LLMs by writing to ```repl``` tags, and determine your answer. Your next action:"""
+
+
+def build_user_prompt(
+    root_prompt: str | None = None,
+    iteration: int = 0,
+    context_count: int = 1,
+    history_count: int = 0,
+) -> dict[str, str]:
+    if iteration == 0:
+        safeguard = "You have not interacted with the REPL environment or seen your prompt / context yet. Your next action should be to look through and figure out how to answer the prompt, so don't just provide a final answer yet.\n\n"
+        prompt = safeguard + (
+            USER_PROMPT_WITH_ROOT.format(root_prompt=root_prompt) if root_prompt else USER_PROMPT
+        )
+    else:
+        prompt = "The history before is your previous interactions with the REPL environment. " + (
+            USER_PROMPT_WITH_ROOT.format(root_prompt=root_prompt) if root_prompt else USER_PROMPT
+        )
+
+    # Inform model about multiple contexts if present
+    if context_count > 1:
+        prompt += f"\n\nNote: You have {context_count} contexts available (context_0 through context_{context_count - 1})."
+
+    # Inform model about prior conversation histories if present
+    if history_count > 0:
+        if history_count == 1:
+            prompt += "\n\nNote: You have 1 prior conversation history available in the `history` variable."
+        else:
+            prompt += f"\n\nNote: You have {history_count} prior conversation histories available (history_0 through history_{history_count - 1})."
+
+    return {"role": "user", "content": prompt}

groknroll/utils/rlm_utils.py

@@ -0,0 +1,19 @@
+from typing import Any
+
+
+def filter_sensitive_keys(kwargs: dict[str, Any]) -> dict[str, Any]:
+    """Filter out sensitive keys like API keys from kwargs.
+
+    Args:
+        kwargs: Dictionary of keyword arguments that may contain sensitive keys
+
+    Returns:
+        Filtered dictionary with sensitive keys removed
+    """
+    filtered: dict[str, Any] = {}
+    for key, value in kwargs.items():
+        key_lower: str = key.lower()
+        if "api" in key_lower and "key" in key_lower:
+            continue
+        filtered[key] = value
+    return filtered

groknroll-2.0.0.dist-info/METADATA

@@ -0,0 +1,246 @@
+Metadata-Version: 2.4
+Name: groknroll
+Version: 2.0.0
+Summary: groknroll - CLI coding agent with unlimited context via Recursive Language Models (RLM). Better than Claude Code.
+Author-email: Michael Thornton <tekcin@yahoo.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/tekcin/groknroll
+Project-URL: Documentation, https://github.com/tekcin/groknroll/tree/main/docs
+Project-URL: Repository, https://github.com/tekcin/groknroll
+Project-URL: Issues, https://github.com/tekcin/groknroll/issues
+Keywords: groknroll,rlm,llm,language-models,ai,ml,context,infinite-context,recursive,coding-agent,cli,assistant
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: anthropic>=0.40.0
+Requires-Dist: google-genai>=1.0.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: portkey-ai>=1.0.0
+Requires-Dist: click>=8.1.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: blessed>=1.20.0
+Requires-Dist: inquirer>=3.1.0
+Requires-Dist: radon>=6.0.0
+Requires-Dist: bandit>=1.7.0
+Requires-Dist: gitpython>=3.1.0
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: pyyaml>=6.0.0
+Requires-Dist: jinja2>=3.1.0
+Provides-Extra: modal
+Requires-Dist: modal>=0.73.0; extra == "modal"
+Requires-Dist: dill>=0.3.7; extra == "modal"
+Provides-Extra: prime
+Requires-Dist: prime-sandboxes>=0.2.0; extra == "prime"
+Requires-Dist: dill>=0.3.7; extra == "prime"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.1.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: mypy>=1.5.0; extra == "dev"
+Requires-Dist: ruff>=0.0.290; extra == "dev"
+Dynamic: license-file
+
+
+---
+
+<h1 align="center" style="font-size:2.8em">
+<span>Recursive Language Models (<span style="color:orange">RLM</span>s)</span>
+</h1>
+
+<p align="center" style="font-size:1.3em">
+  <a href="https://arxiv.org/abs/2512.24601">Full Paper</a> •
+  <a href="https://alexzhang13.github.io/blog/2025/rlm/">Blogpost</a> •
+  <a href="https://alexzhang13.github.io/rlm/">Documentation</a> •
+  <a href="https://github.com/alexzhang13/rlm-minimal">RLM Minimal</a>
+</p>
+
+<p align="center">
+  <a href="https://github.com/alexzhang13/rlm/actions/workflows/style.yml">
+    <img src="https://github.com/alexzhang13/rlm/actions/workflows/style.yml/badge.svg" alt="Style" />
+  </a>
+  <a href="https://github.com/alexzhang13/rlm/actions/workflows/test.yml">
+    <img src="https://github.com/alexzhang13/rlm/actions/workflows/test.yml/badge.svg" alt="Test" />
+  </a>
+</p>
+
+<p align="center">
+  <a href="https://arxiv.org/abs/2512.24601">
+    <img src="media/paper_preview.png" alt="Paper Preview" width="300"/>
+  </a>
+</p>
+
+## Overview
+Recursive Language Models (RLMs) are a task-agnostic inference paradigm for language models (LMs) to handle near-infinite length contexts by enabling the LM to *programmatically* examine, decompose, and recursively call itself over its input. RLMs replace the canonical `llm.completion(prompt, model)` call with a `rlm.completion(prompt, model)` call. RLMs offload the context as a variable in a REPL environment that the LM can interact with and launch sub-LM calls inside of.
+
+This repository provides an extensible inference engine for using RLMs around standard API-based and local LLMs. The initial experiments and idea were proposed in a [blogpost](https://alexzhang13.github.io/blog/2025/rlm/) in 2025, with expanded results in an [arXiv preprint](https://arxiv.org/abs/2512.24601).
+
+> [!NOTE]
+> This repository contains inference code for RLMs with support for various sandbox environments. Open-source contributions are welcome. This repository is maintained by the authors of the paper from the MIT OASYS lab.
+
+<!-- ## Installation
+```
+pip install groknroll
+```
+To install the latest from `main`:
+```
+pip install git+https://github.com/alexzhang13/rlm.git
+```
+``` -->
+
+## Quick Setup
+Set up the dependencies with `uv` (or your virtual environment of choice):
+```bash
+curl -LsSf https://astral.sh/uv/install.sh | sh
+uv init && uv venv --python 3.12  # change version as needed
+uv pip install -e .
+```
+
+This project includes a `Makefile` to simplify common tasks.
+
+- `make install`: Install base dependencies.
+- `make check`: Run linter, formatter, and tests.
+
+To run a quick test, the following will run an RLM query with the OpenAI client using your environment variable `OPENAI_API_KEY` (feel free to change this). This will generate console output as well as a log which you can use with the visualizer to explore the trajectories.
+```bash
+make quickstart
+```
+
+The default RLM client uses a REPL environment that runs on the host process through Python `exec` calls. It uses the same virtual environment as the host process (i.e. it will have access to the same dependencies), but with some limitations in its available global modules. As an example, we can call RLM completions using GPT-5-nano:
+```python
+from groknroll import RLM
+
+rlm = RLM(
+    backend="openai",
+    backend_kwargs={"model_name": "gpt-5-nano"},
+    verbose=True,  # For printing to console with rich, disabled by default.
+)
+
+print(rlm.completion("Print me the first 100 powers of two, each on a newline.").response)
+```
+
+## Oracle Agent - Codebase Knowledge System 🔮
+
+The Oracle Agent is an RLM-powered tool that has **unlimited context** and knows **everything** about your codebase. It can answer any question about your code by leveraging RLM's infinite context capabilities.
+
+```python
+from groknroll import OracleAgent
+
+# Initialize Oracle for your project
+oracle = OracleAgent(
+    project_path=".",
+    backend="openai",
+    model="gpt-4o-mini"
+)
+
+# Ask any question about your codebase
+response = oracle.ask("Where is the RLM class defined?")
+print(response.answer)
+
+# Use convenience methods
+oracle.find_class("RLM")
+oracle.find_function("completion")
+oracle.get_architecture_overview()
+oracle.how_to_add_feature("support for Claude AI backend")
+```
+
+**Features:**
+- **Unlimited Context**: Handles arbitrarily large codebases via RLM
+- **Automatic Indexing**: Parses files, functions, classes, imports using AST
+- **Semantic Understanding**: Understands what your code does, not just keywords
+- **Comprehensive Answers**: Detailed explanations with code examples and sources
+
+**See [ORACLE_AGENT.md](ORACLE_AGENT.md) for full documentation.**
+
+## REPL Environments
+We support two types of REPL environments -- isolated, and non-isolated. Non-isolated environments (default) run code execution on the same machine as the RLM (e.g. through `exec`), which is pretty reasonable for some local low-risk tasks, like simple benchmarking, but can be problematic if the prompts or tool calls can interact with malicious users. Fully isolated environments used Cloud-based sandboxes (e.g. Prime Sandboxes, [Modal Sandboxes](https://modal.com/docs/guide/sandboxes)) to run code generated by the RLM, ensuring completely isolation from the host process. Environments can be added, but we natively support the following: `local` (default), `modal`, `prime`.
+
+```python
+rlm = RLM(
+    environment="...", # "local", "docker", "modal", "prime"
+    environment_kwargs={...},
+)
+```
+
+### Local Environments
+The default `local` environment `LocalREPL` runs in the same process as the RLM itself, with specified global and local namespaces for minimal security. Using this REPL is generally safe, but should not be used for production settings. It also shares the same virtual environment (e.g. Conda or uv) as the host process.
+
+#### Docker <img src="https://github.com/docker.png" alt="Docker" height="20" style="vertical-align: middle;"/> (*requires [Docker installed](https://docs.docker.com/desktop/setup/install/)*)
+We also support a Docker-based environment called `DockerREPL` that launches the REPL environment as a Docker image. By default, we use the `python:3.11-slim` image, but the user can specify custom images as well.
+
+### Isolated Environments
+We support several different REPL environments that run on separate, cloud-based machines. Whenever a recursive sub-call is made in these instances, it is requested from the host process.
+
+#### Modal Sandboxes <img src="https://github.com/modal-labs.png" alt="Modal" height="20" style="vertical-align: middle;"/>
+To use [Modal Sandboxes](https://modal.com/docs/guide/sandboxes) as the REPL environment, you need to install and authenticate your Modal account.
+```bash
+uv add modal  # add modal library
+modal setup   # authenticate account
+```
+
+#### Prime Intellect Sandboxes <img src="https://github.com/PrimeIntellect-ai.png" alt="Prime Intellect" height="20" style="vertical-align: middle;"/>
+> [!NOTE]
+> **Prime Intellect Sandboxes** are currently a beta feature. See the [documentation](https://docs.primeintellect.ai/sandboxes/overview) for more information. We noticed slow runtimes when using these sandboxes, which is currently an open issue.
+
+
+To use [Prime Sandboxes](https://docs.primeintellect.ai/sandboxes/sdk), install the SDK and set your API key:
+```bash
+uv pip install -e ".[prime]"
+export PRIME_API_KEY=...
+```
+
+
+### Model Providers
+We currently support most major clients (OpenAI, Anthropic), as well as the router platforms (OpenRouter, Portkey, LiteLLM). For local models, we recommend using vLLM (which interfaces with the [OpenAI client](https://github.com/alexzhang13/rlm/blob/main/rlm/clients/openai.py)). To view or add support for more clients, start by looking at [`rlm/clients/`](https://github.com/alexzhang13/rlm/tree/main/rlm/clients).
+
+## Relevant Reading
+* **[Dec '25]** [Recursive Language Models arXiv](https://arxiv.org/abs/2512.24601)
+* **[Oct '25]** [Recursive Language Models Blogpost](https://alexzhang13.github.io/blog/2025/rlm/)
+
+If you use this code or repository in your research, please cite:
+
+```bibtex
+@misc{zhang2025recursivelanguagemodels,
+      title={Recursive Language Models}, 
+      author={Alex L. Zhang and Tim Kraska and Omar Khattab},
+      year={2025},
+      eprint={2512.24601},
+      archivePrefix={arXiv},
+      primaryClass={cs.AI},
+      url={https://arxiv.org/abs/2512.24601}, 
+}
+```
+
+## Optional Debugging: Visualizing RLM Trajectories
+We additionally provide a simple visualizer tool to examine and view the code, sub-LM, and root-LM calls of an RLM trajectory. To save log files (`.jsonl`) on every completion call that can be viewed in the visualizer, initialize the `RLMLogger` object and pass it into the `RLM` on initialization:
+```python
+from groknroll.logger import RLMLogger
+from groknroll import RLM
+
+logger = RLMLogger(log_dir="./logs")
+rlm = RLM(
+    ...
+    logger=logger
+)
+```
+
+To run the visualizer locally, we use Node.js and shadcn/ui:
+```
+cd visualizer/
+npm run dev        # default localhost:3001
+```
+
+You'll have the option to select saved `.jsonl` files 
+<p align="center">
+  <img src="media/visualizer.png" alt="RLM Visualizer Example" width="800"/>
+</p>

groknroll-2.0.0.dist-info/RECORD

@@ -0,0 +1,62 @@
+groknroll/__init__.py,sha256=cSgEIY238em4bslHfCUyTB43xluwF2Dsa1iuajnTQAA,914
+groknroll/__main__.py,sha256=8Lsdq3QYPeEj2nyHemr6uxAd2nszPhKv6fqyblNgvRc,131
+groknroll/setup.py,sha256=p87YAtmRanqmh7cEGsYTJ5jERxDj62mY4OlI18fNo88,750
+groknroll/agents/__init__.py,sha256=013zCuiLsq_27iEF170Ec_f8aHouvsJVwiArhNpOWmE,443
+groknroll/agents/agent_manager.py,sha256=lQ6ZjAlMtU01NIMEPuQBM5dLcAT2N1Pj725uEef_rHk,4901
+groknroll/agents/base_agent.py,sha256=eLSTnJna2KPeahnaGOZ4cwZy3A8CT-f3MVjUOjSqk2M,3325
+groknroll/agents/build_agent.py,sha256=kM1lvbDPMddNhlAwYXbErtjgNQXODFCxifX0w_3-Kls,6979
+groknroll/agents/plan_agent.py,sha256=IgM6Ckn7FlrY2J645KAZk4J061Tn0QRC2Ak9DKzJ9ZM,6232
+groknroll/cli/__init__.py,sha256=0LqYqFNmcfwTNL2iQu0XbqJRh_YCuVq8LuIRIrk2BSA,110
+groknroll/cli/enhanced_cli.py,sha256=9TnCBWsVwEjB4QmAZyG-jeKr1PWenNUr4ek7tapitHs,12707
+groknroll/cli/large_codebase_cli.py,sha256=q5hV_JjmK9agVMSBpWf4dTeBtQoNKPKkJ9_VHtGP4kA,14438
+groknroll/cli/main.py,sha256=qNEPclmmIGRdgNFRv81Vs2R_ABmo4_tsD0QZCqV21ug,11240
+groknroll/cli/rlm_commands.py,sha256=YGLsxkxzOidmlRw7bNii73wnAh3AF7OOoleDzo941Z0,8424
+groknroll/clients/__init__.py,sha256=JB-7qsm6tDqfyGoys0VvhH3BTFeNHS5YAdSqq5rDfo0,2183
+groknroll/clients/anthropic.py,sha256=N3ghhvfSrbOexnSguUzbGs4tLAa3DnNOTikBrwmBw1Q,4268
+groknroll/clients/azure_openai.py,sha256=CrLIyj60mKNjXFcUxDCx_VdEKyVmefn7Op6aI3gCX7k,5102
+groknroll/clients/base_lm.py,sha256=dQKrpxN-jURd1xos18WoOsAN8n80MRYixTx7hV2LWWY,1017
+groknroll/clients/gemini.py,sha256=_wrOS_CHEZQ58WfFliQB_YFdOsTD9Y0k6VxLY0AKw9o,5746
+groknroll/clients/litellm.py,sha256=FoJWpGbdL00arVa8anre9JAaAdGGRosXB2elWfiHJV0,3946
+groknroll/clients/openai.py,sha256=A6SzE5HntROzQpvnp2tjwXrN6nbbi5932KjLcjZLJMw,4994
+groknroll/clients/portkey.py,sha256=QfpSOD5oyVSCBVOdITbnIMBgTo6CU2mTGiXJ3k6zqM0,3801
+groknroll/core/__init__.py,sha256=LduS8Nfw4eInpr8-O6-018l2WSwe3MlXtNye676e0AI,280
+groknroll/core/agent.py,sha256=ypv37xZMV9p7ZmlLWl8_dkT_dk7hbg0pm__vqzFHORs,10401
+groknroll/core/comms_utils.py,sha256=GLoac6Dgdl9MSCHPNZmMGhsjKwoZQiuTd-ZdNs3-H9s,8591
+groknroll/core/context.py,sha256=TJL2XW_jcdEBMrGwfXrzjBc310llBLi5NMCanwS7xMs,7515
+groknroll/core/exceptions.py,sha256=vXeERLyv8z7uh_cO4kKTW_xpXNDLaNs4PK7ChEUQw0Y,5057
+groknroll/core/large_codebase.py,sha256=iP51okb-dsRXQYPywW2ty2R5WySYG6twjtylmUvLXLo,18461
+groknroll/core/lm_handler.py,sha256=siVZFUihb4RjkcyfEaY3y9Riy1swHTCdtlDYlau95nI,7514
+groknroll/core/rlm.py,sha256=prFc72K911_sWIrqdYUoxuDYYmmxEbb-ZP2a9Iw24SM,19157
+groknroll/core/rlm_codebase.py,sha256=UVC1OxHldpn3b52DmdNcoHgP6K6FNg3N3jDAyU8dl58,12907
+groknroll/core/rlm_integration.py,sha256=mCX4qCpTGK2InRGno_jATm_gsEYOyabE8dSQOsG5wHA,7627
+groknroll/core/types.py,sha256=-hL4DxuNy9E3gV9yuFbE5goEHkQZe5TUSOTyU0iYwVQ,8694
+groknroll/environments/__init__.py,sha256=_xCSw3jKfpvAGRhKI7UYY3ImiTFbtZ314ZaesRqXWK0,1239
+groknroll/environments/base_env.py,sha256=c4wg34DthvJmAIYNe7mdDsWOV0J7wvtFvVAekTQQXl0,5792
+groknroll/environments/constants.py,sha256=Z2niqZjQ7gXu7VMkJy5kswwoX3_1R59YvCrq8KNy9mg,638
+groknroll/environments/docker_repl.py,sha256=5wnJiS_YvmLd3PTLZW8UjreyHH9oWoS8D4bP0M2upUA,11231
+groknroll/environments/local_repl.py,sha256=mngKStwAYDZXdbORjwBtrbRRlEYFVQsoyAONS8Z2UJ4,12424
+groknroll/environments/modal_repl.py,sha256=IkJ3Cn-Ak4RDuSDeAYL5f-164Gznkm_ojSy9a5QQUvU,15482
+groknroll/environments/prime_repl.py,sha256=yqNZmTpaATONk58rW-zT-rjw81agoVCjq0jptQ7Cwm4,19178
+groknroll/logger/__init__.py,sha256=6rVRsCyzD574bOfhbtMpivQCkWjxJkpAfExqiIGCzkY,145
+groknroll/logger/rlm_logger.py,sha256=IO2CyO5x_vVT35eshpwMX1f52YwpIiDehkvhnk35SS4,1717
+groknroll/logger/verbose.py,sha256=559_HHiEcxLmnowbjZ_ctUmOahowhMsniuxgQrxpZD4,13008
+groknroll/operations/__init__.py,sha256=vq0mWnnIej_0I7RIsf7DwUr4bHQn6STM5UxkiNifhFU,345
+groknroll/operations/bash_ops.py,sha256=HYKplHwI2oQ5IpK9_oniAiwqx7AlNp6aWFtBAeb-cUE,13044
+groknroll/operations/file_ops.py,sha256=bkhV8GLhTSa7p7D79jmoFUQK3Z9rLsVlqQWQFM9bQx8,14616
+groknroll/operations/git_ops.py,sha256=uoHnVq6C62hGbBJLdz90O5m-_Jx7nOw4D6Es46Jj3rY,16772
+groknroll/oracle/__init__.py,sha256=hCfOpvGd1WDQvxGb0YUOwIOTB4i8MuIos6omcJ6HS-A,339
+groknroll/oracle/codebase_indexer.py,sha256=hQ0uS7VbgNiVdsq8fv6aKZScyzUyJHBAs6wLaFPW2TY,8368
+groknroll/oracle/oracle_agent.py,sha256=i1Sl92ffb4adfJLjuctxYXrWvJqk58Tv0h1eVmNg4Sk,9792
+groknroll/storage/__init__.py,sha256=DeYCbqD7GY-T_xTQlrS7kbwrkRVTaXEZ9AiZEyCFheo,319
+groknroll/storage/database.py,sha256=hr16B7ye5y9RrzucobxOh-nM_L-pXeYOFr5gqEC45w0,8728
+groknroll/storage/models.py,sha256=E_YxCK0ykJnjP75cxupCDr6Sv6ZqenZM3S2HvU9ZXwU,4539
+groknroll/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+groknroll/utils/parsing.py,sha256=BrSEZMyp54GUqrQccL9bvsjYXtsF_pigySDrmiYCfdY,5355
+groknroll/utils/prompts.py,sha256=dDBNPEoqrz53PcW0r8-vfdaFP3QReWKnIygfEipoDDw,9903
+groknroll/utils/rlm_utils.py,sha256=2KaVsbA9HMKr7WWnHZ92tR5wpKa-CV0pasQp5zct2B0,557
+groknroll-2.0.0.dist-info/licenses/LICENSE,sha256=mJQhMqyQ8qn_SQ_--hKclqYgbLccd_bL2TtjP3Ke7m8,1067
+groknroll-2.0.0.dist-info/METADATA,sha256=hPu89eeLv5IPeeIDiEQfpXqs_XnelMgcSd6E2et5FKA,11401
+groknroll-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+groknroll-2.0.0.dist-info/entry_points.txt,sha256=bjCOBIduyQ-9iHJT0HtUJNsTYI0MCGkOmIua4vL_S14,85
+groknroll-2.0.0.dist-info/top_level.txt,sha256=YvCXzBP7-dvE1t1kCBpDTzPfNPql_amSS4S502Z3rWE,10
+groknroll-2.0.0.dist-info/RECORD,,

groknroll-2.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

groknroll-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+gknr = groknroll.cli.main:main
+groknroll = groknroll.cli.main:main

groknroll-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Alex Zhang
+
+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.

groknroll-2.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+groknroll