inpip 0.1.0

Intelligent pip package installer using AI to resolve package names

ipip - Intelligent Pip Package Installer

ipip is an intelligent pip package installer that uses AI to understand what you want and automatically handles package resolution, file organization, and project management. Just install and go - no configuration needed!

Features

🧠 Intelligent Package Resolution: Uses LLM to understand what package you actually want

• ipip blender → installs bpy
• ipip pil → installs pillow
• ipip opencv → installs opencv-python

🔍 Smart Package Discovery: Find packages by describing what you need

• ipip vision recognition → shows computer vision packages
• ipip machine learning → shows ML libraries
• ipip web scraping → shows web scraping tools

📁 Intelligent File Operations: AI-powered file management and organization

• ipip "move all test files to tests folder" → analyzes and organizes files
• ipip "create project structure" → sets up proper folder hierarchy
• ipip "delete temporary files" → safely removes build artifacts
• ipip "list installer files" → finds and displays files intelligently
• ipip "move files to scripts folder" → works with files from previous context

🧠 Conversational File Context: Remembers your previous file operations

• List files, then move them: ipip "list installer files" → ipip "move files to folder"
• AI remembers active files between commands for seamless workflow
• Context-aware operations: files from previous lists are automatically included

🛡️ Advanced Safety Features: Protects your system and project files

• Smart Exclusions: Automatically excludes environments, system files, .git, node_modules
• Emergency Undo: Comprehensive logging and rollback of file operations
• Safety Confirmations: Warns before destructive operations
• AI File Matching: Uses complete file hierarchy for intelligent pattern recognition

📝 Dynamic Requirements Management: Automatically manage your project dependencies

• ipip create requirements → generates requirements.txt from your project
• ipip update requirements → updates existing requirements file

🚀 Natural Language Commands: Commands are dynamic and LLM-based

• ipip requirements file
• ipip create requirements file
• ipip organize python files

All work the same way!

Installation

🚀 One-Line Install (Recommended)

From PyPI (Recommended):

pip install ipip

One-Line Installers:

Windows:

curl -o install.bat https://raw.githubusercontent.com/codyreign/ipip/main/install.bat && install.bat

Unix/Linux/macOS:

curl -sSL https://raw.githubusercontent.com/codyreign/ipip/main/install.sh | bash

✨ What happens automatically:

• ✅ Installs ipip and dependencies
• ✅ Detects/installs Ollama (local AI)
• ✅ Downloads AI model (llama3.2)
• ✅ Tests everything works
• ✅ Ready to use immediately!

Alternative Methods

From GitHub (Development):

pip install git+https://github.com/codyreign/ipip.git
ipip --setup  # Run first-time setup

Usage

Basic Package Installation

# Install packages using common names
ipip blender          # Installs bpy for Blender Python API
ipip pil             # Installs pillow for image processing
ipip opencv          # Installs opencv-python
ipip sklearn         # Installs scikit-learn

Package Discovery

# Find packages for specific domains
ipip vision recognition        # Shows computer vision packages
ipip machine learning         # Shows ML libraries
ipip web development api      # Shows API frameworks
ipip database tools          # Shows database libraries

File Operations

# List and discover files intelligently
ipip "list installer files"                    # Finds all files with install/installer patterns
ipip "list all python files"                   # Lists Python source files
ipip "list config files"                       # Shows configuration files
ipip "list files with 'test' in name"         # Custom pattern matching

# Organize files intelligently
ipip "move all test files to tests folder"     # Moves test files to tests/
ipip "create project structure with docs and config folders"  # Creates folder structure
ipip "organize python files by type"          # Organizes by file purpose

# Conversational workflow (files remembered between commands)
ipip "list installer files"                   # Lists files and remembers them
ipip "move files to scripts folder"           # Moves the previously listed files

# Create files and folders
ipip "create README.md with project description"  # Creates file with content
ipip "create folders for tests, docs, and config"  # Creates multiple folders

# Clean up safely (with confirmations)
ipip "delete temporary files"                  # Safely removes temp files
ipip "remove build artifacts"                  # Cleans build outputs

File Context Management

# Show current file context
ipip --context                                 # Shows active files from previous operations
ipip --clear-context                          # Clears current file context

# File operations work with context
ipip "list config files"                      # Step 1: List files
ipip "move files to config folder"            # Step 2: Move the listed files
ipip "copy files to backup"                   # Step 3: Copy the same files

Requirements Management

# Generate requirements.txt from your project
ipip create requirements
ipip generate requirements file
ipip requirements

# Update existing requirements.txt
ipip update requirements
ipip refresh requirements file

Advanced Options

# Dry run (see what would be installed)
ipip --dry-run blender

# Verbose output
ipip --verbose opencv

# Use different LLM model
ipip --model openai package-name

# File context options
ipip --context                                 # Show current file context
ipip --clear-context                          # Clear current file context

# Emergency file operations
ipip undo                                      # Undo last 10 file operations
ipip undo --count 5                           # Undo last 5 operations

Configuration

ipip can be configured using a config file or environment variables.

Config File

The config file is located at:

• Linux/macOS: ~/.config/ipip/config.json
• Windows: %APPDATA%/ipip/config.json

Example configuration:

{
  "llm": {
    "model": "local",
    "api_key": "",
    "api_url": "",
    "timeout": 30,
    "max_retries": 3,
    "temperature": 0.1
  },
  "verbose": false,
  "dry_run_default": false,
  "auto_confirm": false,
  "requirements_filename": "requirements.txt",
  "exclude_system_packages": true,
  "package_search_limit": 10
}

Environment Variables

• IPIP_MODEL: Override the LLM model
• IPIP_API_KEY: Set API key for remote models
• IPIP_API_URL: Set API URL for remote models
• IPIP_TIMEOUT: Set request timeout

Local LLM Setup

ipip works best with a local LLM like Ollama:

1. Install Ollama
2. Pull a model: ollama pull llama3.2
3. ipip will automatically use the local model

How it Works

Package Installation

1. Intent Parsing: ipip uses LLM to understand what you want to do
2. Package Resolution: Combines LLM intelligence with curated mappings
3. Smart Installation: Installs the correct packages with proper error handling
4. Project Analysis: For requirements generation, scans your code for imports

File Operations

1. AI Analysis: Analyzes your entire project structure and file purposes
2. Context Memory: Remembers files from previous operations for conversational workflow
3. Safety First: Automatically excludes system files, environments, and critical project files
4. Smart Matching: Uses AI to understand file patterns and relationships
5. Operation Preview: Shows what will happen before executing destructive operations
6. Emergency Recovery: Logs all operations with full undo capabilities

Safety Exclusions

ipip automatically protects these critical files and directories:

• Hidden files: .git, .vscode, .idea, .env*
• Virtual environments: venv, env, node_modules, __pycache__
• System files: Thumbs.db, .DS_Store, desktop.ini
• Critical project files: setup.py, requirements.txt, package.json
• Build artifacts: dist/, build/, target/, *.pyc
• Large binaries: *.exe, *.dll, *.so, *.dmg

Examples

Install Computer Vision Stack

ipip computer vision
# Installs: opencv-python, pillow, scikit-image

Install Machine Learning Environment

ipip machine learning
# Installs: scikit-learn, pandas, numpy, matplotlib

Install Web Development Tools

ipip web api development
# Shows: fastapi, flask, django-rest-framework

Project Requirements

# In your project directory
ipip create requirements
# Analyzes your code and creates requirements.txt

File Organization Examples

# Organize a messy project
ipip "list all files"                          # See what's in your project
ipip "create folders for tests, docs, scripts" # Set up structure
ipip "move test files to tests"               # Organize test files
ipip "move documentation to docs"             # Organize docs
ipip "move installer files to scripts"        # Move installer scripts

# Clean up after development
ipip "list temporary files"                   # See what can be cleaned
ipip "delete build artifacts"                 # Remove compiled files
ipip "remove temp files"                      # Clean temporary files

Conversational Workflow Example

# Step 1: Discover files
ipip "list installer files"
# Output: Found 3 files: install.bat, install.sh, quick_install.bat

# Step 2: Work with those files (they're remembered)
ipip "move files to scripts folder"
# Moves the 3 installer files to scripts/

# Step 3: Continue working with same files
ipip "copy files to backup"
# Copies the same 3 files to backup/

# Step 4: Check what happened
ipip --context
# Shows the current active files and operations

Development

Setup Development Environment

# Clone the repository
git clone https://github.com/codyreign/ipip.git
cd ipip

# Install in development mode
make install-dev

# Or manually
pip install -e .

Available Make Commands

make help           # Show all available commands
make install        # Install ipip system-wide
make install-dev    # Install in development mode
make build          # Build package
make clean          # Clean build artifacts
make test           # Run tests
make lint           # Run linting
make format         # Format code
make uninstall      # Uninstall ipip

Running Tests

make test
# Or manually:
pytest tests/

Code Quality

make format         # Format code
make lint          # Run linting

# Or manually:
black ipip/ tests/
flake8 ipip/ tests/

Contributing

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

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Troubleshooting

Common Issues

File operations not working:

• Check if you're in the correct directory
• Use ipip --verbose to see detailed output
• Verify Ollama is running: ollama list

AI not understanding queries:

• Try different wording: "list installer files" vs "show files with install"
• Use ipip --verbose to see AI analysis
• Check if you have a suitable LLM model installed

Undo not working:

• Emergency undo only works for recent operations
• Use ipip undo --count 20 to undo more operations
• Check operation logs in your config directory

Package resolution issues:

• Some packages may need specific models (avoid LLaVA for text queries)
• Try ipip --model llama3.2 for better text understanding
• Use ipip --dry-run to preview without installing

Getting Help

ipip --help                    # Show all available options
ipip --verbose "your command"  # Debug mode with detailed output

Roadmap

• Support for more LLM providers (OpenAI, Anthropic, etc.)
• Package similarity detection
• Integration with virtual environment managers
• Web interface for package discovery
• Package recommendation based on project analysis
• Support for conda packages
• Plugin system for custom resolvers
• Advanced file operation patterns and templates
• Project-specific safety rule customization
• Batch operations and operation scheduling

Acknowledgments

• Inspired by the need for smarter package management
• Built with Click for CLI
• Uses Rich for beautiful terminal output
• LLM integration supports Ollama for local inference