pplx-zero 1.1.7 → 1.1.8

package/README.md

@@ -1,102 +1,248 @@
 # PPLX‑Zero
 
-Use the Perplexity API straight from the terminal — sub‑1s search API, ideal for coding agents and automation.
-Minimal setup, fast results, and practical flags for files, images, streaming, and batch workflows.
+🚀 **Lightning-fast Perplexity AI in your terminal** — sub‑1s search responses with multimodal support. Built for developers, coding agents, and automation workflows that demand speed and reliability.
 
-### What you can do
-- Ask, research, and stream answers instantly from the CLI with sensible defaults for rapid iteration.
-- Summarize documents and analyze images using a single command with optional model control.
-- Run batch jobs with concurrency and timeouts for agent pipelines and CI flows.
+Perfect for rapid research, document analysis, image understanding, and batch processing with minimal configuration.
 
-### Install
-Choose one:
+---
+
+## ✨ What Makes PPLX‑Zero Special
+
+- **⚡ Blazing Fast**: Get answers in under a second with optimized API calls
+- **🧠 Smart Models**: Choose from Sonar, Sonar‑Pro, Sonar‑Reasoning, and Deep‑Research models
+- **📎 Multimodal**: Analyze documents, images, and combinations seamlessly
+- **🔄 Auto‑Update**: Stay current with simplified update management
+- **⚙️ Developer‑First**: Built for CI/CD, agent pipelines, and programmatic use
+- **🎯 Minimal Setup**: One environment variable and you're ready to go
+
+## 📦 Installation
+
+Choose the installation method that works best for you:
+
+### 🚀 Quick Install (Recommended)
 
 ```bash
 # npm or bun (global)
 npm install -g pplx-zero
+# or
+bun install -g pplx-zero
+
+# Verify installation
 pplx --version
 ```
 
+### 📦 Binary Download (No Node.js required)
 
-or
+```bash
+# Download the appropriate binary for your platform
+# Linux (x64) - Most servers and desktops
+wget https://github.com/codewithkenzo/pplx-zero/releases/latest/download/pplx-v1.1.7-linux-x64
+chmod +x pplx-v1.1.7-linux-x64
+sudo mv pplx-v1.1.7-linux-x64 /usr/local/bin/pplx
+
+# Linux (ARM64) - Raspberry Pi, ARM servers
+wget https://github.com/codewithkenzo/pplx-zero/releases/latest/download/pplx-v1.1.7-linux-arm64
+chmod +x pplx-v1.1.7-linux-arm64
+sudo mv pplx-v1.1.7-linux-arm64 /usr/local/bin/pplx
+
+# macOS (Intel) - Macs with Intel processors
+wget https://github.com/codewithkenzo/pplx-zero/releases/latest/download/pplx-v1.1.7-darwin-x64
+chmod +x pplx-v1.1.7-darwin-x64
+sudo mv pplx-v1.1.7-darwin-x64 /usr/local/bin/pplx
+
+# macOS (Apple Silicon) - Macs with M1/M2/M3 chips
+wget https://github.com/codewithkenzo/pplx-zero/releases/latest/download/pplx-v1.1.7-darwin-arm64
+chmod +x pplx-v1.1.7-darwin-arm64
+sudo mv pplx-v1.1.7-darwin-arm64 /usr/local/bin/pplx
+
+# Windows (x64) - Most Windows computers
+# Download pplx-v1.1.7-windows-x64.exe from GitHub releases
+# Add to your PATH or run directly
+```
+
+**Alternative Installation Script (Linux/macOS):**
 
 ```bash
-# AUR (Arch Linux)
+# Automated installation script
+curl -sSL https://github.com/codewithkenzo/pplx-zero/releases/latest/download/pplx-v1.1.7-$(uname -s | tr '[:upper:]' '[:lower:]')-$(uname -m | sed 's/x86_64/x64/') -o pplx
+chmod +x pplx
+sudo mv pplx /usr/local/bin/pplx
+```
+
+### 🏛️ AUR (Arch Linux)
+
+```bash
+# Using yay (recommended)
 yay -S pplx-zero
+
+# Using paru
+paru -S pplx-zero
+
+# Verify installation
 pplx --version
 ```
 
-
-or
+### 🔧 Build from Source
 
 ```bash
-# Build from source
-# 1) clone the repository
-# 2) enter the folder
-# 3) build and link the CLI
+# 1) Clone the repository
+git clone https://github.com/codewithkenzo/pplx-zero.git
+cd pplx-zero
+
+# 2) Install dependencies and build
 bun install && bun run build
-sudo ln -s "$(pwd)/dist/cli.js" /usr/local/bin/pplx
+
+# 3) Link the CLI (system-wide)
+sudo ln -s "$(pwd)/dist/index.js" /usr/local/bin/pplx
+
+# 4) Verify installation
 pplx --version
 ```
 
+---
 
-### Configure
-Set your API key as an environment variable before running commands.
+## ⚙️ Configuration
 
-Linux/macOS:
+### API Key Setup
+
+Set your Perplexity API key as an environment variable:
+
+**Linux/macOS:**
 ```bash
+# Temporary (current session)
 export PERPLEXITY_API_KEY="your-api-key"
+
+# Permanent (add to ~/.bashrc, ~/.zshrc, etc.)
+echo 'export PERPLEXITY_API_KEY="your-api-key"' >> ~/.bashrc
+source ~/.bashrc
 ```
 
+**Windows (PowerShell):**
+```powershell
+# Temporary (current session)
+$env:PERPLEXITY_API_KEY = "your-api-key"
+
+# Permanent
+[Environment]::SetEnvironmentVariable("PERPLEXITY_API_KEY", "your-api-key", "User")
+```
 
-Windows:
+**Windows (CMD):**
 ```cmd
+# Permanent
 setx PERPLEXITY_API_KEY "your-api-key"
 ```
 
+> 🔑 **Get your API key** from your [Perplexity account settings](https://www.perplexity.ai/settings/api) and keep it secure. Never share your API key or commit it to version control.
 
-Get your key from your Perplexity account and keep it private to your machine or CI secrets manager.
+---
+
+## 🔄 Auto‑Update Management
+
+PPLX‑Zero includes a simplified auto‑update system that keeps you current with the latest features and security updates.
+
+### Basic Update Commands
 
-### Quick examples
-Simple search (default model: sonar)
 ```bash
-pplx "python type hints best practices"
+# Check for available updates
+pplx update --check
+
+# Install updates and relaunch automatically
+pplx update --auto
 ```
 
+### Update Workflow
+
+1. **Automatic Notifications**: PPLX‑Zero checks for updates once per day and notifies you when a new version is available
+2. **Smart Installation**: The updater detects your installation method (npm, AUR, binary) and uses the appropriate update mechanism
+3. **Seamless Relaunch**: When using `--auto`, PPLX‑Zero installs the update and relaunches with your original command
+
+### Advanced Update Options
 
-Deep research or sonar-pro or reasoning when you need more steps or web context
 ```bash
-pplx -m sonar-pro "React 19 Hooks"
-pplx -m sonar-deep-research "best Rust web frameworks 2025"
-pplx -m sonar-reasoning "prove this algorithm runs in O(n log n)"
+# Force update check (ignores cache)
+pplx update --check
+
+# Update during automation without interaction
+pplx update --auto --quiet
 ```
 
+### Troubleshooting Updates
+
+| Issue | Solution |
+|-------|----------|
+| **Permission denied** | Run with `sudo` or check installation directory permissions |
+| **Network timeout** | Check internet connection and try again |
+| **Update fails** | Manually install using your original installation method |
+| **Lock file error** | Wait for current update to complete or manually remove `~/.pplx-zero/.updating.lock` |
+
+The auto‑update system respects your system configuration and won't modify files without proper permissions.
+
+---
+
+## 🚀 Quick Examples
+
+### Basic Search
 
-Summarize a PDF report quickly
 ```bash
-pplx -f report.pdf "summarize key findings and risks"
+# Simple search (default model: sonar)
+pplx "python type hints best practices"
+
+# Multiple queries in one command
+pplx "React hooks tutorial" "TypeScript generics" "Docker best practices"
 ```
 
+### Advanced Models
 
-Understand an interface from a screenshot
 ```bash
-pplx -i screenshot.png "what is this UI and what are the next steps?"
+# Research with Sonar Pro (more detailed analysis)
+pplx -m sonar-pro "React 19 Hooks new features"
+
+# Deep research with comprehensive web context
+pplx -m sonar-deep-research "best Rust web frameworks 2025"
+
+# Mathematical reasoning and proofs
+pplx -m sonar-reasoning "prove this algorithm runs in O(n log n)"
 ```
 
+### Document & Image Analysis
 
-Combine a doc and an image in one prompt
 ```bash
+# Summarize a PDF report quickly
+pplx -f report.pdf "summarize key findings and risks"
+
+# Understand an interface from a screenshot
+pplx -i screenshot.png "what is this UI and what are the next steps?"
+
+# Combine multiple files in one analysis
 pplx -f data.csv -i chart.png "spot anomalies and explain the chart"
+
+# Multiple file attachments
+pplx -f report.pdf --attach data.csv --attach summary.md "analyze all documents"
+
+# Multiple documents of same type using --attach
+pplx --attach doc1.pdf --attach doc2.pdf --attach doc3.txt "compare all reports"
+
+# Multiple images using --attach-image
+pplx --attach-image screenshot1.png --attach-image screenshot2.png "analyze the UI flow"
+
+# Mixed multiple files (documents + images)
+pplx -f main.pdf --attach appendix.md --attach-image chart.png --attach-image diagram.jpg "comprehensive analysis"
+
+# Multiple files with positional arguments (all treated as files)
+pplx file1.pdf file2.txt file3.md "what's in these files"
 ```
 
+### Batch Processing
 
-Stream newline‑delimited JSON for agents or UNIX pipes
 ```bash
-pplx -o jsonl "ai trends"
-```
+# Stream newline-delimited JSON for agents or UNIX pipes
+pplx -o jsonl "AI trends"
 
+# Batch from a JSON file with custom concurrency
+pplx -I queries.json -o jsonl -c 5 -t 30000
+```
 
-Batch from a JSON file (concurrency and timeout shown)
+**Batch JSON format:**
 ```json
 {
   "version": "1.0.0",
@@ -108,47 +254,293 @@ Batch from a JSON file (concurrency and timeout shown)
 }
 ```
 
+### Advanced Workflows
 
 ```bash
-pplx -I queries.json -o jsonl -c 5 -t 30000
+# Fire-and-forget async with webhook callback
+pplx --async --webhook http://localhost:3000/callback "long research task"
+
+# Export results to file
+pplx --export results.json "machine learning trends"
+
+# Search with custom result limits
+pplx -n 10 "latest web development frameworks"
+
+# Query from stdin (for pipelines)
+echo '{"query": "best practices for API design"}' | pplx -s
 ```
 
+### Real‑World Scenarios
 
-Fire‑and‑forget async with a webhook callback (agent workflows)
 ```bash
-pplx --async --webhook http://localhost:3000/callback "long research task"
+# Security researcher: Analyze vulnerability report
+pplx -f vuln_report.pdf --attach screenshots/ "explain security implications"
+
+# Data analyst: Extract insights from datasets
+pplx -f sales_data.csv -i revenue_chart.png "identify growth opportunities"
+
+# Developer: Code review and optimization
+pplx -f app.py --attach perf_metrics.json "suggest performance improvements"
+
+# Product manager: Competitive analysis
+pplx -f competitor_data.pdf "summarize key differentiators and market position"
 ```
 
 
-### Flags
-- -m, --model: sonar | sonar-pro | sonar-deep-research | sonar-reasoning (default: sonar) 
-- -f, --file: attach a document (PDF, DOC, DOCX, TXT, RTF, MD; up to ~50MB)
-- -i, --image: attach an image (PNG, JPEG, WebP, HEIF/HEIC, GIF; up to ~50MB)
-- -o, --format: json | jsonl (default: json) 
-- -I, --input: read batch requests from a JSON file
-- -c, --concurrency: max parallel requests, e.g., 5 (default: 5)
-- -t, --timeout: request timeout in ms, e.g., 30000 (default: 30000)
-- --async: process requests asynchronously
-- --webhook: URL receiving async notifications
-- -h, --help: show help
-- -v, --version: show version
+---
+
+## 📋 Command Reference
+
+### Main Options
+
+| Flag | Short | Description | Example |
+|------|-------|-------------|---------|
+| `--model` | `-m` | AI model to use | `-m sonar-pro` |
+| `--max-results` | `-n` | Max results per query (1-20) | `-n 10` |
+| `--file` | `-f` | Attach document for analysis | `-f report.pdf` |
+| `--image` | `-i` | Attach image for analysis | `-i screenshot.png` |
+| `--format` | `-o` | Output format: json/jsonl | `-o jsonl` |
+| `--query` | `-q` | Search query (alternative to positional) | `-q "search term"` |
+| `--export` | | Export results to file | `--export results.json` |
+| `--input` | `-I` | Read queries from JSON file | `-I batch.json` |
+| `--stdin` | `-s` | Read queries from stdin | `cat query.json \| pplx -s` |
+| `--attach` | | Additional file attachments | `--attach file1.pdf --attach file2.txt` |
+| `--attach-image` | | Additional image attachments | `--attach-image img1.png --attach-image img2.jpg` |
+| `--async` | | Enable async mode for advanced models | `--async` |
+| `--webhook` | | Webhook URL for async results | `--webhook http://localhost:3000` |
+| `--workspace` | | Workspace directory for file operations | `--workspace ./project` |
+| `--use-search-api` | | Use search API (default: true) | `--use-search-api` |
+| `--batch-size` | | Batch size for processing (1-100) | `--batch-size 50` |
+
+### Performance & Control
+
+| Flag | Description | Default | Range |
+|------|-------------|---------|-------|
+| `--concurrency` | Max parallel requests for batch operations | 5 | 1-20 |
+| `--timeout` | Request timeout in milliseconds | 30000 | 1000-300000 |
+
+### Utility Commands
+
+| Command | Description | Example |
+|---------|-------------|---------|
+| `update --check` | Check for available updates | `pplx update --check` |
+| `update --auto` | Install updates and relaunch | `pplx update --auto` |
+| `history [limit]` | Show search history | `pplx history 10` |
+| `version` | Show version information | `pplx version` |
+| `--help` | Show help message | `pplx --help` |
+| `--version` | Show version number | `pplx --version` |
+
+### Supported File Formats
+
+**Documents (up to 50MB):**
+- PDF, DOC, DOCX, TXT, RTF, MD
+- CSV, JSON (structured data)
+- XML, YAML (configuration files)
+
+**Images (up to 50MB):**
+- PNG, JPEG, WebP, HEIF/HEIC, GIF
+- BMP, TIFF (legacy formats)
+
+### AI Models
+
+| Model | Best For | Speed | Detail |
+|-------|----------|-------|--------|
+| `sonar` | Quick answers, general queries | ⚡ Fast | Standard detail |
+| `sonar-pro` | Detailed analysis, research | 🚀 Fast | Enhanced detail |
+| `sonar-reasoning` | Mathematical reasoning, logic | 🐢 Moderate | Step-by-step |
+| `sonar-deep-research` | Comprehensive research with web context | 🐌 Slow | Maximum detail |
+
+---
+
+## 💻 Programmatic Use
+
+### TypeScript API
 
-### Programmatic use (optional)
 Use the toolkit directly in TypeScript when embedding into agents or services.
+
 ```ts
 import { PerplexitySearchTool } from 'pplx-zero';
 
+// Initialize the search tool
 const tool = new PerplexitySearchTool();
 
-const result = await tool.runBatch({
-  version: "1.0.0",
-  requests: [{ op: "search", args: { query: "TypeScript best practices", maxResults: 5 } }]
+// Single search query
+const result = await tool.search({
+  query: "TypeScript best practices",
+  model: "sonar-pro",
+  maxResults: 5
 });
 
 console.log(result);
 ```
 
+### Batch Processing
+
+```ts
+import { PerplexitySearchTool } from 'pplx-zero';
+
+const tool = new PerplexitySearchTool();
+
+// Batch search with custom configuration
+const batchResult = await tool.runBatch({
+  version: "1.0.0",
+  requests: [
+    {
+      op: "search",
+      args: {
+        query: "TypeScript best practices",
+        maxResults: 5,
+        model: "sonar-pro"
+      }
+    },
+    {
+      op: "search",
+      args: {
+        query: "React performance optimization",
+        maxResults: 3,
+        model: "sonar"
+      }
+    }
+  ],
+  options: {
+    concurrency: 3,
+    timeoutMs: 30000
+  }
+});
+
+console.log('Batch results:', batchResult);
+```
+
+### Advanced Usage with Error Handling
+
+```ts
+import { PerplexitySearchTool } from 'pplx-zero';
+
+async function searchWithRetry(query: string, maxRetries = 3) {
+  const tool = new PerplexitySearchTool();
+
+  for (let attempt = 1; attempt <= maxRetries; attempt++) {
+    try {
+      const result = await tool.search({
+        query,
+        model: "sonar-pro",
+        maxResults: 5
+      });
+
+      return result;
+    } catch (error) {
+      if (attempt === maxRetries) {
+        throw new Error(`Search failed after ${maxRetries} attempts: ${error}`);
+      }
+
+      // Exponential backoff
+      await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
+    }
+  }
+}
+
+// Usage
+searchWithRetry("latest AI trends")
+  .then(result => console.log(result))
+  .catch(error => console.error(error));
+```
+
+---
+
+## 🛠️ Troubleshooting
+
+### Common Issues & Solutions
+
+#### API Key Problems
+```bash
+# Error: "API key not found"
+export PERPLEXITY_API_KEY="your-api-key"
+
+# Verify key is set
+echo $PERPLEXITY_API_KEY
+```
+
+#### File Attachment Issues
+```bash
+# Error: "File too large" (files must be < 50MB)
+ls -lh your-file.pdf
+
+# Supported formats check
+file your-document.pdf  # Should show PDF format
+```
+
+#### Network/Timeout Issues
+```bash
+# Increase timeout for complex queries
+pplx -t 60000 "complex research question"
+
+# Check internet connectivity
+curl -I https://api.perplexity.ai
+```
+
+#### Permission Issues
+```bash
+# Permission denied during installation
+npm install -g pplx-zero --unsafe-perm
+
+# Or use npx to avoid global installation
+npx pplx-zero "your query"
+```
+
+### Debug Mode
+
+```bash
+# Enable verbose output for debugging
+DEBUG=pplx:* pplx "your query"
+
+# Check configuration
+pplx --version
+pplx update --check
+```
+
+### Performance Tips
+
+| Scenario | Recommended Settings |
+|----------|---------------------|
+| **Quick searches** | Default settings (sonar model) |
+| **Deep research** | `-m sonar-deep-research -t 60000` |
+| **Batch processing** | `-c 10 -t 45000` |
+| **File analysis** | `-m sonar-pro -t 60000` |
+| **Real-time queries** | `-m sonar -n 3` |
+
+---
+
+## 📚 Additional Resources
+
+- **GitHub Repository**: [github.com/codewithkenzo/pplx-zero](https://github.com/codewithkenzo/pplx-zero)
+- **Bug Reports & Issues**: [GitHub Issues](https://github.com/codewithkenzo/pplx-zero/issues)
+- **Perplexity API Documentation**: [docs.perplexity.ai](https://docs.perplexity.ai)
+- **Model Comparison**: Detailed model comparison in the [AI Models](#ai-models) section above
+
+---
+
+### Quick Reference Commands
+
+```bash
+# Show all available options
+pplx --help
+
+# Check for updates
+pplx update --check
+
+# Auto-update
+pplx update --auto
+
+# Show version
+pplx --version
+
+# Search history
+pplx history 10
+
+# Quick test
+pplx "test query"
+```
+
+---
 
-### Notes
-- Use pplx --help to see all available options and short flags without scanning long docs.
-- Keep output in jsonl for streaming pipelines and agent frameworks that consume line‑by‑line events.*Built with [Bun](https://bun.sh) and [Perplexity AI](https://www.perplexity.ai)**
+*Built with ❤️ using [Bun](https://bun.sh) and powered by [Perplexity AI](https://www.perplexity.ai)*

package/dist/index.js

@@ -2008,7 +2008,7 @@ function isValidVersion(version) {
   const semverRegex = /^(\d+)\.(\d+)\.(\d+)(?:-([a-zA-Z0-9.-]+))?(?:\+([a-zA-Z0-9.-]+))?$/;
   return semverRegex.test(version);
 }
-var __filename2, __dirname2, FALLBACK_VERSION = "1.1.4", FALLBACK_PACKAGE_INFO, packageJsonCache = null;
+var __filename2, __dirname2, FALLBACK_VERSION = "1.1.8", FALLBACK_PACKAGE_INFO, packageJsonCache = null;
 var init_version = __esm(() => {
   __filename2 = fileURLToPath(import.meta.url);
   __dirname2 = dirname3(__filename2);
@@ -7857,7 +7857,7 @@ ${textContent}`
   async executeAdvancedModel(query, options = {}) {
     const startTime = performance.now();
     try {
-      const { model, attachments, webhook } = options;
+      const { model, attachments, webhook, timeout } = options;
       if (model === "sonar-pro" || model === "sonar-deep-research" || model === "sonar-reasoning") {
         let messages = [];
         if (attachments && attachments.length > 0) {
@@ -7902,12 +7902,13 @@ ${textContent}`
             { role: "user", content: query }
           ];
         }
+        const effectiveTimeout = model === "sonar-deep-research" ? Math.max(timeout || 300000, 300000) : timeout || this.config.timeout;
         const response = await this.executeWithTimeout(this.client.chat.completions.create({
           model,
           messages,
           max_tokens: options.maxTokens || 4000,
           temperature: options.temperature || 0.1
-        }), this.config.timeout);
+        }), effectiveTimeout);
         let content = "";
         if (response && response.choices && response.choices.length > 0) {
           const choice = response.choices[0];
@@ -9238,9 +9239,9 @@ async function getCurrentVersion() {
   try {
     const packageJsonPath = join3(process.cwd(), "package.json");
     const packageJson = JSON.parse(await fs3.readFile(packageJsonPath, "utf-8"));
-    return packageJson.version || "1.1.7";
+    return packageJson.version || "1.1.8";
   } catch {
-    return "1.1.7";
+    return "1.1.8";
   }
 }
 function compareVersions(version1, version2) {
@@ -9325,7 +9326,13 @@ async function parseQueries(options) {
     metadata = { lineCount };
   } else if (options.input) {
     source = "file";
-    const fileContent = await Bun.file(options.input).text();
+    let fileContent;
+    if (typeof Bun !== "undefined") {
+      fileContent = await Bun.file(options.input).text();
+    } else {
+      const fs4 = await import("node:fs");
+      fileContent = await fs4.promises.readFile(options.input, "utf-8");
+    }
     const parsed = JSON.parse(fileContent);
     if (parsed.queries && Array.isArray(parsed.queries)) {
       queries.push(...parsed.queries);
@@ -9358,7 +9365,8 @@ async function executeSearch(query, options, filePaths = []) {
         response = await engine.executeAdvancedModel(query, {
           model: options.model,
           attachments,
-          webhook: options.webhook
+          webhook: options.webhook,
+          timeout: options.timeout
         });
         result = {
           success: true,
@@ -9599,14 +9607,58 @@ async function handleSearchCommand(options) {
       positionals: options.positionals
     });
     const filePaths = [];
-    if (options.file)
+    const filesToValidate = [];
+    if (options.file) {
       filePaths.push(options.file);
-    if (options.image)
+      filesToValidate.push(options.file);
+    }
+    if (options.image) {
       filePaths.push(options.image);
-    if (options.attach)
+      filesToValidate.push(options.image);
+    }
+    if (options.attach) {
       filePaths.push(...options.attach);
-    if (options.attachImage)
+      filesToValidate.push(...options.attach);
+    }
+    if (options.attachImage) {
       filePaths.push(...options.attachImage);
+      filesToValidate.push(...options.attachImage);
+    }
+    if (filesToValidate.length > 0) {
+      const missingFiles = [];
+      for (const filePath of filesToValidate) {
+        try {
+          if (typeof Bun !== "undefined") {
+            const file = Bun.file(filePath);
+            if (!await file.exists()) {
+              missingFiles.push(filePath);
+            } else if (file.size === 0) {
+              throw new Error(`File is empty: ${filePath}`);
+            }
+          } else {
+            const fs4 = await import("node:fs");
+            const stats = await fs4.promises.stat(filePath);
+            if (!stats.isFile()) {
+              missingFiles.push(filePath);
+            } else if (stats.size === 0) {
+              throw new Error(`File is empty: ${filePath}`);
+            }
+          }
+        } catch (error) {
+          if (error instanceof Error && error.message.includes("File is empty")) {
+            throw error;
+          }
+          missingFiles.push(filePath);
+        }
+      }
+      if (missingFiles.length > 0) {
+        const fileList = missingFiles.length === 1 ? `File "${missingFiles[0]}" does not exist or is not readable` : `Files do not exist or are not readable:
+${missingFiles.map((f) => `  - ${f}`).join(`
+`)}`;
+        throw new Error(`${fileList}
+Please check the file paths and try again.`);
+      }
+    }
     const searchOptions = {
       maxResults,
       concurrency,
@@ -10104,7 +10156,7 @@ class UpdateChecker {
       return await getVersion2();
     } catch (error) {
       console.error("Failed to read current version:", error);
-      return "1.1.4";
+      return "1.1.8";
     }
   }
   async getLatestVersion() {
@@ -10236,7 +10288,7 @@ async function handleVersionCommand(options) {
     }
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
-    const fallbackVersion = "pplx-zero v1.1.4";
+    const fallbackVersion = "pplx-zero v1.1.8";
     console.log(fallbackVersion);
     if (!errorMessage.includes("ENOENT") && !errorMessage.includes("package.json")) {
       const formattedError = CliFormatter.formatError(`Warning: ${errorMessage}`);
@@ -10299,8 +10351,8 @@ function validateVersionOptions(options) {
 
 // src/cli/index.ts
 var program2 = new Command;
-program2.name("pplx").description("Fast Perplexity AI search CLI with multi-search, history, and export").version("1.1.4", "-v, --version", "Show version information").helpOption("-h, --help", "Show this help message");
-program2.option("-m, --model <model>", "AI model: sonar, sonar-pro, sonar-reasoning, sonar-deep-research").option("-n, --max-results <n>", "Maximum results per query (default: 5, range: 1-20)", "5").option("-c, --concurrency <n>", "Concurrency for batch searches (default: 5, range: 1-20)", "5").option("-t, --timeout <ms>", "Request timeout in milliseconds (default: 30000, range: 1000-300000)", "30000").option("-f, --file <file>", "Attach document for analysis").option("-i, --image <file>", "Attach image for analysis").option("-o, --format <format>", "Output format: json|jsonl (default: json)", "json").option("-q, --query <query>", "Search query (alternative to positional queries)").option("--export <filename>", "Export results to file").option("-I, --input <file>", "Read queries from JSON file").option("-s, --stdin", "Read queries from stdin (JSON format)").option("--attach <files...>", "Additional file attachments (multiple allowed)").option("--attach-image <files...>", "Additional image attachments (multiple allowed)").option("--async", "Enable async mode for advanced models").option("--webhook <url>", "Webhook URL for async results").option("--workspace <path>", "Workspace directory for file operations").option("--use-search-api", "Use search API (default: true)", true).option("--batch-size <n>", "Batch size for processing (default: 20, range: 1-100)", "20").allowExcessArguments(true).argument("[queries...]", "Search queries (multiple queries enable multi-search)");
+program2.name("pplx").description("Fast Perplexity AI search CLI with multi-search, history, and export").version("1.1.8", "-v, --version", "Show version information").helpOption("-h, --help", "Show this help message");
+program2.option("-m, --model <model>", "AI model: sonar, sonar-pro, sonar-reasoning, sonar-deep-research").option("-n, --max-results <n>", "Maximum results per query (default: 5, range: 1-20)", "5").option("-c, --concurrency <n>", "Concurrency for batch searches (default: 5, range: 1-20)", "5").option("-t, --timeout <ms>", "Request timeout in milliseconds (default: 30000, range: 1000-300000)", "30000").option("-f, --file <file>", "Attach document for analysis").option("-i, --image <file>", "Attach image for analysis").option("-o, --format <format>", "Output format: json|jsonl (default: json)", "json").option("-q, --query <query>", "Search query (alternative to positional queries)").option("--export <filename>", "Export results to file").option("-I, --input <file>", "Read queries from JSON file").option("-s, --stdin", "Read queries from stdin (JSON format)").option("--attach <file>", "Additional file attachment (can be used multiple times)").option("--attach-image <file>", "Additional image attachment (can be used multiple times)").option("--async", "Enable async mode for advanced models").option("--webhook <url>", "Webhook URL for async results").option("--workspace <path>", "Workspace directory for file operations").option("--use-search-api", "Use search API (default: true)", true).option("--batch-size <n>", "Batch size for processing (default: 20, range: 1-100)", "20").allowExcessArguments(true).argument("[queries...]", "Search queries (multiple queries enable multi-search)");
 program2.command("history").description("Show search history").argument("[limit]", "Number of recent searches to show (max 50)").option("-f, --files", "Show individual search files with query+date naming").option("--query-pattern <pattern>", "Filter search files by query pattern").action(async (limit, options, command) => {
   const args = command.parent?.args.slice(command.parent.args.indexOf(command.name()) + 1) || [];
   const historyOptions = parseHistoryArgs(args);
@@ -10388,7 +10440,44 @@ program2.hook("preSubcommand", async (thisCommand) => {
     process.exit(result.exitCode);
   }
 });
+function parseAttachOptions(rawArgs) {
+  const attach = [];
+  const attachImage = [];
+  const remainingArgs = [];
+  let i = 0;
+  while (i < rawArgs.length) {
+    const arg = rawArgs[i];
+    if (arg === "--attach") {
+      if (i + 1 < rawArgs.length && !rawArgs[i + 1].startsWith("-")) {
+        attach.push(rawArgs[i + 1]);
+        i += 2;
+      } else {
+        console.error("Error: --attach requires a file path");
+        process.exit(1);
+      }
+    } else if (arg === "--attach-image") {
+      if (i + 1 < rawArgs.length && !rawArgs[i + 1].startsWith("-")) {
+        attachImage.push(rawArgs[i + 1]);
+        i += 2;
+      } else {
+        console.error("Error: --attach-image requires a file path");
+        process.exit(1);
+      }
+    } else {
+      remainingArgs.push(arg);
+      i += 1;
+    }
+  }
+  return { attach, attachImage, remainingArgs };
+}
+var rawArgs = process.argv.slice(2);
+var { attach: attachFiles, attachImage: attachImages, remainingArgs } = parseAttachOptions(rawArgs);
+var collectedAttach = attachFiles;
+var collectedAttachImages = attachImages;
+var originalArgv = process.argv;
+process.argv = ["node", originalArgv[1], ...remainingArgs];
 program2.action(async (queries, options) => {
+  process.argv = originalArgv;
   const result = await handleSearchCommand({
     query: options.query,
     file: options.file,
@@ -10402,8 +10491,8 @@ program2.action(async (queries, options) => {
     useSearchAPI: options.useSearchApi,
     stdin: options.stdin,
     input: options.input,
-    attach: options.attach || [],
-    attachImage: options.attachImage || [],
+    attach: collectedAttach,
+    attachImage: collectedAttachImages,
     export: options.export,
     async: options.async,
     webhook: options.webhook,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pplx-zero",
-  "version": "1.1.7",
+  "version": "1.1.8",
   "description": "Fast Perplexity AI search CLI with multimodal support - minimal setup, maximal results",
   "type": "module",
   "main": "dist/index.js",