semvec/pypi-packages huggingface dataset:
cursor-dungeon-master 0.4.1
Context-tracking pre-commit tool for Cursor integration with comprehensive documentation enforcement
Requires Python: >=3.8
Keywords: documentation, git, pre-commit, context, tracking, cursor, ai

# 🏰 Dungeon Master

**A context-tracking pre-commit tool for Cursor integration.**

Blocks commits until meaningful documentation exists. Creates structured templates that Cursor fills with intelligent content. Enforces quality through automated validation.

```bash
pip install cursor-dungeon-master
dm init
```

---

## 🚀 Quick Start

```bash
# Install
pip install cursor-dungeon-master

# Initialize in your repository
dm init

# Mark files for tracking by adding a comment
echo '# track_lore("my_feature.md")' >> src/my_feature.py

# Commit triggers the workflow
git add . && git commit -m "Add new feature"
```

That's it! Dungeon Master will create documentation templates and block commits until they're complete.

---

## 🗡️ Commands

| Command          | Purpose                                   |
| ---------------- | ----------------------------------------- |
| `dm init`        | Initialize Dungeon Master in repository   |
| `dm create-lore` | Create/update templates for tracked files |
| `dm review`      | Show all tracked files and their status   |
| `dm validate`    | Check what would block commits            |
| `dm map`         | Generate repository structure map         |

---

## ⚔️ How It Works

1. **Track Files**: Add `# track_lore("filename.md")` comments to important files
2. **Commit**: When you commit, templates are created in `.lore/` directory
3. **Complete**: Use Cursor to fill template placeholders
4. **Validate**: Commits are blocked until documentation is complete

### Example Template

```markdown
# my_feature.py - Context Documentation

## Overview

[PLEASE FILL OUT: Overview]

## Key Functions/Components

[PLEASE FILL OUT: Functions/Components]

## Dependencies

[PLEASE FILL OUT: Dependencies]
```

---

## 🛡️ Validation

Commits are blocked when:

- Documentation templates are missing
- Templates contain `[PLEASE FILL OUT: ...]` placeholders
- Significant code changes haven't been reviewed

---

## 🌟 Why Use This?

- **Enforced Documentation**: No more outdated or missing docs
- **AI-Friendly Structure**: Templates work perfectly with Cursor
- **Pre-commit Integration**: Automatic validation before commits
- **Language Support**: Python, JavaScript, TypeScript, and more

---

## 📄 License

MIT License - see [LICENSE](LICENSE) for details.

---

🏰 _"In the dungeon of development, proper documentation is your most powerful spell."_
memochain 0.1.1
A lightweight library to add memory to stateless LLM APIs
Requires Python: >=3.8

# MemoChain

**MemoChain** is a lightweight Python library for adding memory to stateless LLM APIs. It allows developers to easily store and retrieve conversation history across sessions with minimal setup.

Key features:
- Supports any LLM API (OpenAI, DeepSeek, Claude, Mistral, etc.)
- Built-in Groq integration
- Local JSON-based storage (no external DB or backend)
- Session-based memory tracking
- Clean, modular design for easy use in any project

---

## Installation

```bash
pip install memochain
```

---

## Quickstart

### Use with your own LLM (e.g. OpenAI)

```python
from memochain.memory_store import load_context, append_to_history
import openai

openai.api_key = "your-openai-api-key"
session_id = "demo-session"

append_to_history(session_id, "user", "Tell me a joke.")
history = load_context(session_id)

response = openai.ChatCompletion.create(
    model="gpt-3.5-turbo",
    messages=history
)

assistant_msg = response["choices"][0]["message"]["content"]
append_to_history(session_id, "assistant", assistant_msg)

print("Assistant:", assistant_msg)
```

---

### Use with built-in Groq support

```python
from memochain.groq_client import GroqLLMClient
from memochain.memory_store import append_to_history, get_session_history

session_id = "groq-session"
client = GroqLLMClient()

append_to_history(session_id, "user", "Who won the World Cup in 2022?")
history = get_session_history(session_id)
response = client.chat(history)

append_to_history(session_id, "assistant", response)
print("Assistant:", response)
```

---

## How It Works

MemoChain stores all message history locally in:
- `.memochain_history.json` — stores conversation history per session
- `.memochain_sessions.json` — tracks active session IDs

This allows memory persistence across runs without a backend or database.

---

## Example Scripts

See the `examples/` folder:
- `custom_llm_openai_example.py` — OpenAI API usage
- `groq_chat_example.py` — Chat example using Groq integration

To test locally:

```bash
python examples/groq_chat_example.py
```

---

## License

MIT

---

## Author

Yash Thapliyal – [GitHub](https://github.com/YashDThapliyal)
app-use 0.0.3
Make mobile apps accessible for AI agents
Requires Python: <4.0,>=3.11
Keywords: agent, ai, android, app-use, appium, automation, browser-use, ios, mobile, mobile-use, ui-automation


![Whisk_storyboard7ea3db2beb6746db94891e4e (1)](https://github.com/user-attachments/assets/293c7ccb-62c6-40b9-9ff5-eeacaeb34aaa)


<h1 align="center">Enable AI to control your mobile apps 🤖</h1>


[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/erickjtorres/app-use)
[![Twitter Follow](https://img.shields.io/twitter/follow/Erick?style=social)](https://x.com/itsericktorres)
[![Discord](https://img.shields.io/discord/1381129368847384597?color=7289DA&label=Discord&logo=discord&logoColor=white)](https://discord.gg/V9mW8UJ6tx)


📱 App Use is the easiest way to connect AI agents with mobile applications.

Our goal is to provide a powerful yet simple interface for AI agent app automation.

## Quick start

With pip (Python>=3.11):

```bash
pip install app-use
```

For memory functionality (requires Python<3.13 due to PyTorch compatibility):  

```bash
pip install "app-use[memory]"
```

Install the necessary drivers and software: Check out our [environment setup](https://github.com/erickjtorres/app-use/blob/main/docs/env-setup.md) docs for more info!

Or feel free to try out our cli for a seamless setup:
```bash
pip install "app-use[cli]"

#install dependencies
app-use setup

# to check dependencies where installed correctly
app-use doctor
```

Define the app and mobile device you want to target:

```python
    app = App(
        platform_name="ios",
        device_name='Your Device Name',
        bundle_id="com.apple.calculator",
        appium_server_url='http://localhost:4723',
    )
```

Spin up your agent:

```python
import asyncio
from dotenv import load_dotenv
load_dotenv()
from app_use import Agent
from langchain_openai import ChatOpenAI

async def main():
    agent = Agent(
        task="What is 2+2?",
        llm=ChatOpenAI(model="gpt-4o"),
        app=app

    )
    await agent.run()

asyncio.run(main())
```


Add your API keys for the provider you want to use to your .env file.

```
OPENAI_API_KEY=
ANTHROPIC_API_KEY=
AZURE_OPENAI_ENDPOINT=
AZURE_OPENAI_KEY=
GOOGLE_API_KEY=
DEEPSEEK_API_KEY=
GROK_API_KEY=
NOVITA_API_KEY=
```

## DEMOS

<table>
<tr>
<td width="15%">

**Ordering Shorts from the Lululemon App (iOS)**

![agent_history](https://github.com/user-attachments/assets/f6130f2e-48c6-4130-8146-1bd141ea101a)

</td>
<td width="15%">

**Ordering some tacos and a drink on DoorDash (IOS)**

![uber_eats_orders](https://github.com/user-attachments/assets/70789f61-ca55-4888-a87e-2dbba964cfc5)


</td>
</tr>
</table>


## Community & Support

Contributions are welcome! Please feel free to submit a Pull Request.

App Use is actively maintained and designed to make mobile app control as simple and reliable as possible.

        
<div align="center">
Made with ❤️ by Erick Torres
 </div>