promptpro 0.1.0

PromptPro - A prompt versioning and management system with Python bindings

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:

pip install promptpro

Rust:

cargo install promptpro

Install from source:

# 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.

# 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

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

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

Import Your Vault

# 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

# 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

# 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

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

Basic Rust API Example

High level, write a PromptManager singleton:

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:

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)

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

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:

pip install promptpro

Or if building from source:

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

Basic Python Usage

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:

# 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 file.

---

ppro - Taking prompt management to the next level! 🚀

Made with ❤️ for the AI development community.