Metadata-Version: 2.4
Name: promptpro
Version: 0.1.0
Classifier: Development Status :: 3 - Alpha
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.8
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: Topic :: Software Development :: Libraries :: Python Modules
Classifier: Topic :: Utilities
License-File: LICENSE
Summary: PromptPro - A prompt versioning and management system with Python bindings
Keywords: ai,prompt-engineering,versioning,management,python-bindings
Home-Page: https://github.com/lucasjinreal/promptpro
Author-email: jinfagang <jinfagang@163.com>
License: GPL-3.0-only
Requires-Python: >=3.8
Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
Project-URL: Homepage, https://github.com/lucasjinreal/promptpro
Project-URL: Repository, https://github.com/lucasjinreal/promptpro
Project-URL: Documentation, https://docs.rs/promptpro

# PromptPro: Advanced Prompt Manage and Versioning System


**Promptpro** is a powerful, flexible, and developer-friendly prompt management system that revolutionizes how you manage, version, and organize your AI prompts. With built-in versioning, tagging, encryption, and a beautiful TUI interface, ppro is the ultimate tool for prompt engineers, AI developers, and anyone serious about prompt management.


**Promptpro** can be installed via python `pip install promptpro`, while underneath build with Rust 🦀, providing extremly fast speed. You can using any of your prompt in any language, any project, by simply given a unique key, and every single time you edit your prompt, there will be automatically version store, you never need multi files / messed up json yamls cross different agent projects.

Promptpro support both python and rust out of box!


## ✨ Key Features

- 🔐 **Secure Vault**: Optional password-encrypted vault dumps for sensitive prompt data
- 📦 **Complete Backup**: Full vault export/import functionality with binary format
- 🔄 **Automatic Versioning**: Every prompt change is automatically versioned
- 🏷️ **Smart Tagging**: Tag versions with "dev", "stable", "release", and custom tags
- 💻 **Beautiful TUI**: Intuitive terminal user interface for easy navigation
- 📝 **Rich History**: Track all changes with timestamps and optional messages
- ⚡ **Blazing Fast Performance**: Optimized storage with efficient retrieval (powered by Rust)
- 🛠️ **Developer Friendly**: Comprehensive CLI and library API

## 🚀 Quick Start

### Installation

Python:

```shell
pip install promptpro
```

Rust:

```shell
cargo install promptpro
```

Install from source:

```bash
# Clone the repository
git clone https://github.com/lucasjinreal/promptpro
cd promptpro

./install.sh
```

### Basic Usage

`ppro` is the short form of `promptpro`. after `install.sh` it will available in your path.

```bash
# Add a new prompt
echo "Write a poem about technology" | ppro add

# Add with a key
ppro add "You are a helpful AI assistant"

# Update an existing prompt
ppro update my-prompt "You are a super helpful AI assistant"

# Get the latest version
ppro get my-prompt

# Get a specific version or tag
ppro get my-prompt 2
ppro get my-prompt stable

# Tag a version
ppro tag my-prompt stable 1

# Show history
ppro history my-prompt

# Open the TUI interface
ppro tui
```

## 📦 Backup & Restore

### Export Your Vault

```bash
# Export without encryption (unencrypted binary)
ppro dump prompts.vault

# Export with password encryption
ppro dump prompts.vault --password "your-secret-password"
```

### Import Your Vault

```bash
# Import unencrypted vault
ppro resume prompts.vault

# Import encrypted vault
ppro resume prompts.vault --password "your-secret-password"
```

## 🎮 TUI Interface

Navigate your prompts with the intuitive terminal interface:

- **Arrow Keys / hjkl**: Navigate between panels and items
- **← →**: Switch between the 4 columns (Keys, Versions, Content, Tags)
- **Enter / x**: Apply or toggle tags on selected versions
- **e**: Edit content in the current panel
- **o**: Open external editor (like vim, nano)
- **q**: Quit the application
- **Ctrl+S**: Save when in edit mode

## 🔧 Advanced CLI Commands

### Tag Management

```bash
# Tag a specific version
ppro tag my-prompt stable 1

# Promote a tag to the latest version
ppro promote my-prompt stable

# The 'dev' tag is automatically promoted to latest version on updates
```

### History & Retrieval

```bash
# Show full history for a prompt
ppro history my-prompt

# Get prompt to a file
ppro get my-prompt --output my-file.txt

# Get specific version
ppro get my-prompt 3

# Get by tag
ppro get my-prompt stable
```

## 🛠️ Programmatic API Usage

ppro can be easily integrated into both Rust and Python applications.

### Rust API

#### Add to Cargo.toml

```toml
[dependencies]
promptpro = { path = "path/to/promptpro" }  # or git source
```

#### Basic Rust API Example

High level, write a PromptManager singleton:

```rust
use anyhow::Result;
use once_cell::sync::Lazy;
use promptpro::{PromptVault, VersionSelector};
use std::sync::Arc;
use tokio::sync::RwLock;

// Our global PromptManager singleton
pub struct PromptManager {
    vault: Arc<RwLock<PromptVault>>,
}

// Static global instance
static MANAGER: Lazy<PromptManager> = Lazy::new(|| {
    let vault = PromptVault::restore_or_default("./promptpro.vault", None)
        .expect("Failed to open PromptPro default vault");
    PromptManager {
        vault: Arc::new(RwLock::new(vault)),
    }
});

impl PromptManager {
    pub fn get() -> &'static Self {
        &MANAGER
    }

    pub async fn get_prompt(&self, key: &str, selector: VersionSelector<'_>) -> Result<String> {
        let vault = self.vault.read().await;
        Ok(vault.get(key, selector)?)
    }

    pub async fn latest(&self, key: &str) -> Result<String> {
        self.get_prompt(key, VersionSelector::Latest).await
    }
}

// Use

let pm = PromptManager::get();
let prompt = pm
    .get_prompt("pc_operator_v2", VersionSelector::Tag("dev"))
    .await
    .map_err(|e| AgentBuildError::PromptError(e.to_string()))?;
```

Low level API:

```rust
use ppro::{PromptVault, VersionSelector};

// Open the default vault
let vault = PromptVault::open_default()?;

// Add a new prompt
vault.add("greeting", "Hello, World!")?;

// Update an existing prompt
vault.update("greeting", "Hi there!", Some("Updated greeting".to_string()))?;

// Get latest version
let content = vault.get("greeting", VersionSelector::Latest)?;

// Tag a version
vault.tag("greeting", "stable", 1)?;

// Get by tag
let stable_content = vault.get("greeting", VersionSelector::Tag("stable"))?;

// Get history
let history = vault.history("greeting")?;
```

#### Backup & Restore API (Rust)

```rust
use ppro::PromptVault;

// Dump vault to binary file (with optional encryption)
let vault = PromptVault::open_default()?;
vault.dump("backup.vault", Some("my_password"))?;

// Or without encryption
vault.dump("backup.vault", None)?;

// Restore from binary file
let restored_vault = PromptVault::restore("backup.vault", Some("my_password"))?;
```

#### Complete Rust Example Program

```rust
use ppro::{PromptVault, VersionSelector};
use anyhow::Result;

#[tokio::main]
async fn main() -> Result<()> {
    let vault = PromptVault::open_default()?;

    // Add a prompt
    vault.add("summarization", "Summarize the following text concisely...")?;
    
    // Update with improvements
    vault.update("summarization", 
        "Provide a concise summary of the following text. Focus on key points and maintain context.",
        Some("Improved summarization prompt".to_string()))?;
    
    // Tag as stable
    vault.tag("summarization", "stable", 1)?;
    
    // Get the latest version
    let latest = vault.get("summarization", VersionSelector::Latest)?;
    println!("Latest prompt: {}", latest);
    
    // Get the stable version
    let stable = vault.get("summarization", VersionSelector::Tag("stable"))?;
    println!("Stable prompt: {}", stable);
    
    // Show history
    let history = vault.history("summarization")?;
    for version in history {
        println!("Version {}: ({}) {:?}",
            version.version, 
            version.timestamp.format("%Y-%m-%d %H:%M"),
            version.tags
        );
    }

    // Backup the vault
    vault.dump("backup.vault", Some("secure_password"))?;
    println!("Vault backed up successfully!");
    
    Ok(())
}
```

## 🐍 Python Bindings

ppro also provides Python bindings built with PyO3, making it easy to integrate prompt management into Python applications.

### Installation

The Python package can be built and installed using Maturin:

```bash
pip install promptpro
```

Or if building from source:

```bash
cd promptpro
maturin build --features python
pip install target/wheels/promptpro-*.whl
```

### Basic Python Usage

```python
from promptpro import PromptManager

pm = PromptManager.get_singleton("promptpro.vault", "")
a = pm.get_prompt("pc_operator_v2", "dev")
print(a)
```


## 🎯 Why Choose ppro?

### For Prompt Engineers

- **Version Control**: Track every iteration of your prompts
- **A/B Testing**: Maintain multiple versions and compare effectiveness
- **Rollback Capability**: Instantly return to previous versions
- **Tag Management**: Organize prompts by stability, project, or context

### For AI Developers

- **API Integration**: Easy programmatic access to your prompts
- **Environment Management**: Different tags for dev/staging/prod
- **Team Collaboration**: Share and sync prompt collections
- **Performance**: Fast retrieval and minimal overhead

### For Security-Conscious Teams

- **Encryption**: Optional password protection for sensitive prompts
- **Binary Format**: Secure, tamper-resistant backup format
- **Local Storage**: Full control over your prompt data
- **Audit Trail**: Complete history with timestamps

## 🏷️ Tagging System

### Special Tags

- **`dev`**: Automatically points to the latest version on updates
- **`stable`**: Manually set for production-ready versions  
- **`release`**: For major releases or milestones

### Custom Tags

You can create any custom tag names to organize your prompts:

```bash
# Create custom tags
ppro tag my-prompt experimental 2
ppro tag my-prompt production-ready 3
ppro tag my-prompt "v2.0" 4
```

## 📊 Use Cases

### AI Model Development

- Track prompt evolution during model training
- A/B test different prompt variations
- Maintain production vs. experimental prompts

### Content Generation

- Template management for marketing campaigns
- Document generation prompts
- Personalized content creation

### Research & Experimentation  

- Maintain experiment logs with associated prompts
- Compare prompt effectiveness across models
- Share prompts within research teams

## 🤝 Contributing

We welcome contributions! Feel free to:

- 🐛 Report bugs and issues
- 💡 Suggest new features
- 🔧 Submit pull requests
- 📖 Improve documentation

## 📄 License

This project is licensed under the GNU General Public License v3.0 (GPL-3.0).

**GPL-3.0 License**:

- You can **freely** use, study, share, and modify this software
- You must **distribute** source code when sharing
- You must **license** derivative works under the same terms
- You must **preserve** the original copyright notice and license

For more details, see the [LICENSE](./LICENSE) file.

---

**ppro** - Taking prompt management to the next level! 🚀

Made with ❤️ for the AI development community.
