pplx-zero 1.1.5 → 1.1.7

package/README.md

@@ -1,404 +1,154 @@
-# PPLX-Zero
+# PPLX‑Zero
 
-> Fast Perplexity AI search CLI - minimal setup, maximal results
+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.
 
-<p align="center">
-  <a href="https://badge.fury.io/js/pplx-zero"><img src="https://badge.fury.io/js/pplx-zero.svg" alt="npm version"></a>
-  <a href="https://aur.archlinux.org/packages/pplx-zero"><img src="https://img.shields.io/aur/version/pplx-zero?style=flat-square" alt="AUR package"></a>
-  <a href="https://www.typescriptlang.org/"><img src="https://img.shields.io/badge/TypeScript-007ACC?logo=typescript&logoColor=white" alt="TypeScript"></a>
-  <a href="https://bun.sh"><img src="https://img.shields.io/badge/Bun-black?logo=bun&logoColor=white" alt="Bun"></a>
-  <a href="https://opensource.org/licenses/MIT"><img src="https://img.shields.io/badge/License-MIT-yellow.svg" alt="License: MIT"></a>
-</p>
+### 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.
 
-A fast TypeScript CLI for Perplexity AI search with multimodal support. Built with Bun runtime for performance and reliability.
-
-## Features
-
-- **⚡ Fast Search** - Concurrent queries with intelligent rate limiting
-- **🎯 Simple Setup** - Works with just an API key, no configuration required
-- **📦 Batch Processing** - Handle multiple searches simultaneously
-- **🔄 Real-time Updates** - JSONL streaming progress events
-- **🖼️ File Analysis** - Process documents and images with AI models
-- **🤖 AI Models** - Sonar, Sonar Pro, Sonar Deep Research, Sonar Reasoning
-- **🛡️ Type Safe** - Full Zod validation and TypeScript support
-- **🌍 Cross-Platform** - Native Bun runtime support
-- **🔄 Auto-Update** - Background update checking to stay current
-
-## Quick Start
-
-### 1️⃣ Install
-
-**📦 Package Manager Installation (Recommended)**
-
-<p align="center">
-  <a href="https://badge.fury.io/js/pplx-zero"><img src="https://badge.fury.io/js/pplx-zero.svg" alt="npm version"></a>
-  <a href="https://aur.archlinux.org/packages/pplx-zero"><img src="https://img.shields.io/aur/version/pplx-zero?style=flat-square" alt="AUR package"></a>
-</p>
+### Install
+Choose one:
 
 ```bash
-# npm (Node.js package manager) - Global installation
+# npm or bun (global)
 npm install -g pplx-zero
+pplx --version
+```
 
-# AUR (Arch Linux) - Binary package
-yay -S pplx-zero
 
-# AUR (Arch Linux) - Manual build
-git clone https://aur.archlinux.org/pplx-zero.git
-cd pplx-zero
-makepkg -si
+or
 
-# Verify installation
+```bash
+# AUR (Arch Linux)
+yay -S pplx-zero
 pplx --version
 ```
 
-**🔨 Manual Installation**
+
+or
 
 ```bash
-# Clone and build locally
-git clone https://github.com/codewithkenzo/pplx-zero.git
-cd pplx-zero
+# Build from source
+# 1) clone the repository
+# 2) enter the folder
+# 3) build and link the CLI
 bun install && bun run build
-
-# Add to PATH
 sudo ln -s "$(pwd)/dist/cli.js" /usr/local/bin/pplx
-
-# Verify installation
 pplx --version
 ```
 
-### 2️⃣ Setup API Key
 
-**Linux/macOS:**
+### Configure
+Set your API key as an environment variable before running commands.
+
+Linux/macOS:
 ```bash
 export PERPLEXITY_API_KEY="your-api-key"
 ```
 
-**Windows:**
+
+Windows:
 ```cmd
 setx PERPLEXITY_API_KEY "your-api-key"
 ```
 
-**Get your API key:** https://www.perplexity.ai/account/api/keys
 
-### 3️⃣ Start Searching
+Get your key from your Perplexity account and keep it private to your machine or CI secrets manager.
 
+### Quick examples
+Simple search (default model: sonar)
 ```bash
-# Simple search
-pplx "latest AI developments"
-
-# Choose model for detailed analysis
-pplx --model sonar-pro "Explain quantum computing"
-
-# Analyze document
-pplx --file report.pdf "Summarize this document"
-
-# Analyze image
-pplx --image screenshot.png "What does this interface do?"
-
-# Document + image analysis
-pplx --file data.csv --image chart.png "Analyze this data"
-
-# Advanced AI models
-pplx --model sonar-reasoning "Solve this math problem"
-pplx --model sonar-deep-research "History of artificial intelligence"
-
-# See basic help
-pplx --help
+pplx "python type hints best practices"
 ```
 
-## Auto-Update
-
-PPLX-Zero includes intelligent auto-update functionality that runs in the background to keep your CLI current.
-
-### How It Works
-
-- **Background Checking**: Automatically checks for updates every 24 hours when you run searches
-- **Non-Blocking**: Never slows down your search queries - updates happen in the background
-- **Smart Caching**: Uses intelligent caching to avoid unnecessary network requests
-- **Silent by Default**: Runs quietly without interrupting your workflow
-
-### Update Commands
 
+Deep research or sonar-pro or reasoning when you need more steps or web context
 ```bash
-# Check for updates manually
-pplx update --check
-
-# Install available updates automatically
-pplx update --auto
-
-# Show version information
-pplx version
-
-# Check updates with version command
-pplx version --check-updates
+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)"
 ```
 
-### Update Methods
-
-The auto-update system tries multiple package managers in order of preference:
-
-1. **npm global** (`npm update -g pplx-zero`)
-2. **bun global** (`bun update -g pplx-zero`)
-3. **yarn global** (`yarn global upgrade pplx-zero`)
-4. **pnpm global** (`pnpm update -g pplx-zero`)
-
-If automatic updates fail, you'll get helpful instructions to update manually.
-
-### Configuration
-
-Auto-update settings are stored in `~/.pplx-zero/update-cache.json`:
-
-- **Check Interval**: 24 hours by default
-- **Quiet Mode**: Silent operation to not interrupt workflow
-- **Auto Install**: Disabled by default for safety
-
-### Privacy & Performance
 
-- **Minimal Network**: Only checks npm registry for version information
-- **No Data Collection**: Never sends search queries or personal data
-- **Fast Performance**: Cached results prevent repeated network requests
-- **Local Only**: All update logic runs locally on your machine
-
-## Usage Guide
-
-### Command Line Options
-
-**Quick Reference:**
+Summarize a PDF report quickly
 ```bash
-# Basic search
-pplx "latest AI developments"
-
-# File analysis (simplified)
-pplx -f document.pdf "Summarize this"
+pplx -f report.pdf "summarize key findings and risks"
+```
 
-# Advanced batch processing
-pplx --input queries.json -c 10 -t 60000
 
-# See all options
-pplx --help
+Understand an interface from a screenshot
+```bash
+pplx -i screenshot.png "what is this UI and what are the next steps?"
 ```
 
-**Essential Commands:**
-```bash
-# Model selection
-pplx -m sonar-pro "Detailed analysis"
 
-# File + image
-pplx -f doc.md -i chart.png "Analyze both"
+Combine a doc and an image in one prompt
+```bash
+pplx -f data.csv -i chart.png "spot anomalies and explain the chart"
+```
 
-# Output format
-pplx -o jsonl "Get streaming output"
 
-# Async with webhook
-pplx --async --webhook https://api.example.com "Long task"
+Stream newline‑delimited JSON for agents or UNIX pipes
+```bash
+pplx -o jsonl "ai trends"
 ```
 
-### Batch Processing
-
-Create `queries.json`:
 
+Batch from a JSON file (concurrency and timeout shown)
 ```json
 {
   "version": "1.0.0",
   "requests": [
-    {"op": "search", "args": {"query": "AI trends", "maxResults": 5}},
-    {"op": "search", "args": {"query": "TypeScript patterns", "maxResults": 3}},
-    {"op": "search", "args": {"query": "Bun performance", "maxResults": 3}}
+    { "op": "search", "args": { "query": "AI trends", "maxResults": 5 } },
+    { "op": "search", "args": { "query": "TypeScript patterns", "maxResults": 3 } }
   ],
-  "options": {
-    "concurrency": 5,
-    "timeoutMs": 30000
-  }
+  "options": { "concurrency": 5, "timeoutMs": 30000 }
 }
 ```
 
-Process with:
 
 ```bash
-pplx --input queries.json --format jsonl
+pplx -I queries.json -o jsonl -c 5 -t 30000
 ```
 
-### File Attachments
-
-Supported file formats for analysis:
 
-**Documents (max 50MB):**
-- PDF, DOC, DOCX, TXT, RTF, MD
-
-**Images (max 50MB):**
-- PNG, JPEG, WebP, HEIF, HEIC, GIF
-
-**Examples:**
+Fire‑and‑forget async with a webhook callback (agent workflows)
 ```bash
-# Document analysis
-pplx --attach report.pdf "Summarize this document"
-
-# Image analysis
-pplx --attach-image screenshot.png "Analyze this interface"
-
-# Multiple files
-pplx --attach document.txt --attach-image chart.png "Analyze this data"
-```
-
-### Programmatic Usage
-
-```typescript
+pplx --async --webhook http://localhost:3000/callback "long research task"
+```
+
+
+### 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
+
+### Programmatic use (optional)
+Use the toolkit directly in TypeScript when embedding into agents or services.
+```ts
 import { PerplexitySearchTool } from 'pplx-zero';
 
 const tool = new PerplexitySearchTool();
 
 const result = await tool.runBatch({
   version: "1.0.0",
-  requests: [{
-    op: "search",
-    args: { query: "TypeScript best practices", maxResults: 5 }
-  }]
+  requests: [{ op: "search", args: { query: "TypeScript best practices", maxResults: 5 } }]
 });
 
 console.log(result);
 ```
 
-## Configuration
-
-### Simplified Options (Everyday Usage)
-
-| Option | Short | Type | Default | Description |
-|--------|-------|------|---------|-------------|
-| `--file` | `-f` | string | - | Attach document (PDF, DOC, DOCX, TXT, RTF, MD) |
-| `--image` | `-i` | string | - | Attach image (PNG, JPEG, WebP, HEIF, HEIC, GIF) |
-| `--format` | `-o` | string | json | Output format: json|jsonl |
-| `--model` | `-m` | string | sonar | AI model: sonar, sonar-pro, sonar-deep-research, sonar-reasoning |
-| `--version` | `-v` | boolean | - | Show version |
-| `--help` | `-h` | boolean | - | Show basic help |
-
-### Update Commands
-
-| Command | Options | Description |
-|---------|---------|-------------|
-| `pplx update` | `--check` | Check for available updates |
-| `pplx update` | `--auto` | Install available updates automatically |
-| `pplx version` | `--check-updates` | Show version and check for updates |
-| `pplx version` | `--verbose` | Show detailed version information |
-
-### Advanced Options (Power Users)
-
-| Option | Short | Type | Default | Description |
-|--------|-------|------|---------|-------------|
-| `--input` | `-I` | string | - | Read batch requests from JSON file |
-| `--stdin` | `-s` | boolean | false | Read JSONL requests from stdin |
-| `--concurrency` | `-c` | number | 5 | Max concurrent requests (1-20) |
-| `--timeout` | `-t` | number | 30000 | Request timeout in ms (1000-300000) |
-| `--workspace` | `-w` | string | - | Workspace directory for sandboxing |
-| `--attach` | - | string[] | - | Attach document files (multiple) |
-| `--attach-image` | - | string[] | - | Attach image files (multiple) |
-| `--async` | - | boolean | false | Process requests asynchronously |
-| `--webhook` | - | string | - | Webhook URL for async notifications |
- |
-
-### Quick Reference
-
-```bash
-# Basic usage (simplified)
-pplx -f doc.pdf -m sonar-pro "analyze this"
-
-# Advanced usage (full control)
-pplx -I batch.json -c 10 -t 60000 --format jsonl "process all"
-
-# See all available options
-pplx --help
-```
-
-### AI Models
-
-- `sonar` - Fast, concise responses (default)
-- `sonar-pro` - Detailed, comprehensive responses
-- `sonar-deep-research` - In-depth research with web search
-- `sonar-reasoning` - Step-by-step logical reasoning
-
-## Output Formats
-
-### JSON (Default)
-```json
-{
-  "version": "1.0.0",
-  "ok": true,
-  "summary": {
-    "total": 1,
-    "successful": 1,
-    "failed": 0,
-    "totalDuration": 572
-  },
-  "results": [...]
-}
-```
-
-### JSONL (Streaming)
-```bash
-pplx --format jsonl "AI trends"
-```
-Each result printed as a separate JSON line for real-time processing.
-
-## Development
-
-```bash
-# Clone and build
-git clone https://github.com/codewithkenzo/pplx-zero.git
-cd pplx-zero
-bun install && bun run build
-
-# Development mode
-bun run dev
-
-# Type checking
-bun run typecheck
-
-# Build for production
-bun run build
-
-# Create binary
-bun run build:binary
-```
-
-## Architecture
-
-- **Bun Runtime** - Fast JavaScript runtime
-- **Zod Validation** - Type-safe schema validation
-- **Error Handling** - Resilient error recovery
-- **Concurrency Control** - Semaphore pattern for rate limiting
-- **Streaming Events** - Real-time progress updates
-
-## Security Features
-
-- Environment variable API key management
-- Input validation and sanitization
-- Request timeout protection
-- Error information filtering
-- No external dependencies beyond core runtime
-
-## Error Handling
-
-PPLX-Zero provides comprehensive error classification:
-
-```typescript
-enum ErrorCode {
-  VALIDATION_ERROR = "VALIDATION_ERROR",
-  API_KEY_MISSING = "API_KEY_MISSING",
-  API_ERROR = "API_ERROR",
-  TIMEOUT_ERROR = "TIMEOUT_ERROR",
-  NETWORK_ERROR = "NETWORK_ERROR",
-  RATE_LIMIT_ERROR = "RATE_LIMIT_ERROR",
-  UNEXPECTED_ERROR = "UNEXPECTED_ERROR"
-}
-```
-
-## Contributing
-
-Contributions are welcome! Please feel free to submit a Pull Request.
-
-## License
-
-MIT License - see [LICENSE](LICENSE) file for details.
-
----
 
-**Built with [Bun](https://bun.sh) and [Perplexity AI](https://www.perplexity.ai)**
+### 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)**

package/dist/index.js

@@ -1883,7 +1883,7 @@ __export(exports_version, {
   getDescription: () => getDescription,
   getAuthor: () => getAuthor,
   formatVersionInfo: () => formatVersionInfo,
-  compareVersions: () => compareVersions
+  compareVersions: () => compareVersions2
 });
 import { readFile as readFile2 } from "node:fs/promises";
 import { join as join6, dirname as dirname3 } from "node:path";
@@ -1972,7 +1972,7 @@ async function formatVersionInfo(verbose = false) {
   }
   return `${versionInfo.name} v${versionInfo.version}`;
 }
-function compareVersions(version1, version2) {
+function compareVersions2(version1, version2) {
   const v1Parts = version1.split(".").map(Number);
   const v2Parts = version2.split(".").map(Number);
   const maxLength = Math.max(v1Parts.length, v2Parts.length);
@@ -1987,7 +1987,7 @@ function compareVersions(version1, version2) {
   return 0;
 }
 function isNewerVersion(current, latest) {
-  return compareVersions(latest, current) > 0;
+  return compareVersions2(latest, current) > 0;
 }
 function parseVersion(version) {
   const mainVersion = version.split("-")[0];
@@ -9118,149 +9118,156 @@ class CliFormatter {
 import { promises as fs3 } from "node:fs";
 import { join as join3 } from "node:path";
 import { homedir as homedir3 } from "node:os";
-
-class AutoUpdateService {
-  static UPDATE_CACHE_FILE = join3(homedir3(), ".pplx-zero", "update-cache.json");
-  static DEFAULT_CONFIG = {
-    enabled: true,
-    checkInterval: 1440,
-    autoInstall: false,
-    quietMode: true
-  };
-  config;
-  updateCache = null;
-  constructor(config = {}) {
-    this.config = { ...AutoUpdateService.DEFAULT_CONFIG, ...config };
-  }
-  async checkForUpdates() {
-    if (!this.config.enabled) {
-      return null;
-    }
-    try {
-      await this.loadUpdateCache();
-      const now = new Date;
-      const timeSinceLastCheck = this.updateCache?.lastChecked ? now.getTime() - this.updateCache.lastChecked.getTime() : Infinity;
-      const checkIntervalMs = this.config.checkInterval * 60 * 1000;
-      if (this.updateCache && timeSinceLastCheck < checkIntervalMs) {
-        return this.updateCache;
-      }
-      const updateInfo = await this.fetchUpdateInfo();
-      await this.saveUpdateCache(updateInfo);
-      if (this.config.autoInstall && updateInfo.updateAvailable) {
-        this.performAutoUpdate(updateInfo).catch((error) => {
-          if (!this.config.quietMode) {
-            console.error("Auto-update failed:", error);
-          }
-        });
-      }
-      return updateInfo;
-    } catch (error) {
-      if (!this.config.quietMode) {
-        console.error("Update check failed:", error);
-      }
-      return null;
-    }
-  }
-  async fetchUpdateInfo() {
-    const currentVersion = await this.getCurrentVersion();
-    try {
-      const npmResponse = await fetch("https://registry.npmjs.org/pplx-zero");
-      const npmData = await npmResponse.json();
-      const latestVersion = npmData["dist-tags"]?.latest || currentVersion;
-      const updateAvailable = this.compareVersions(latestVersion, currentVersion) > 0;
-      return {
-        currentVersion,
-        latestVersion,
-        updateAvailable,
-        lastChecked: new Date,
-        updateUrl: npmData.versions?.[latestVersion]?.dist?.tarball,
-        releaseNotes: npmData.versions?.[latestVersion]?.description
-      };
-    } catch (error) {
-      return {
-        currentVersion,
-        latestVersion: currentVersion,
-        updateAvailable: false,
-        lastChecked: new Date
-      };
-    }
+var UPDATE_CACHE_FILE = join3(homedir3(), ".pplx-zero", "update-cache.json");
+var CONFIG_FILE = join3(homedir3(), ".pplx-zero", "config.json");
+var DEFAULT_CONFIG = {
+  enabled: true,
+  checkInterval: 1440,
+  autoInstall: false,
+  quietMode: true
+};
+async function loadAutoUpdateConfig() {
+  try {
+    const configContent = await fs3.readFile(CONFIG_FILE, "utf-8");
+    const config = JSON.parse(configContent);
+    return { ...DEFAULT_CONFIG, ...config.autoUpdate };
+  } catch {
+    return DEFAULT_CONFIG;
   }
-  async getCurrentVersion() {
-    try {
-      const packageJsonPath = join3(process.cwd(), "package.json");
-      const packageJson = JSON.parse(await fs3.readFile(packageJsonPath, "utf-8"));
-      return packageJson.version || "1.1.4";
-    } catch {
-      return "1.1.4";
+}
+async function saveAutoUpdateConfig(config) {
+  try {
+    const configDir = join3(homedir3(), ".pplx-zero");
+    await fs3.mkdir(configDir, { recursive: true });
+    const existingConfig = await loadAutoUpdateConfig();
+    const updatedConfig = { ...existingConfig, ...config };
+    await fs3.writeFile(CONFIG_FILE, JSON.stringify({ autoUpdate: updatedConfig }, null, 2), "utf-8");
+  } catch (error) {
+    if (process.env.PPLX_DEBUG) {
+      console.error("Failed to save auto-update config:", error);
     }
   }
-  compareVersions(version1, version2) {
-    const v1Parts = version1.split(".").map(Number);
-    const v2Parts = version2.split(".").map(Number);
-    const maxLength = Math.max(v1Parts.length, v2Parts.length);
-    for (let i = 0;i < maxLength; i++) {
-      const v1Part = v1Parts[i] || 0;
-      const v2Part = v2Parts[i] || 0;
-      if (v1Part > v2Part)
-        return 1;
-      if (v1Part < v2Part)
-        return -1;
+}
+async function checkForUpdatesCached() {
+  try {
+    const config = await loadAutoUpdateConfig();
+    if (!config.enabled) {
+      return null;
     }
-    return 0;
-  }
-  async loadUpdateCache() {
+    let updateCache = null;
     try {
-      const cacheData = await fs3.readFile(AutoUpdateService.UPDATE_CACHE_FILE, "utf-8");
-      this.updateCache = JSON.parse(cacheData);
+      const cacheData = await fs3.readFile(UPDATE_CACHE_FILE, "utf-8");
+      updateCache = JSON.parse(cacheData);
     } catch {
-      this.updateCache = null;
+      updateCache = null;
     }
-  }
-  async saveUpdateCache(updateInfo) {
-    try {
-      await fs3.mkdir(join3(homedir3(), ".pplx-zero"), { recursive: true });
-      await fs3.writeFile(AutoUpdateService.UPDATE_CACHE_FILE, JSON.stringify(updateInfo, null, 2), "utf-8");
-      this.updateCache = updateInfo;
-    } catch (error) {
-      if (!this.config.quietMode) {
-        console.error("Failed to save update cache:", error);
-      }
+    const now = new Date;
+    const timeSinceLastCheck = updateCache?.lastChecked ? now.getTime() - new Date(updateCache.lastChecked).getTime() : Infinity;
+    const checkIntervalMs = config.checkInterval * 60 * 1000;
+    if (updateCache && timeSinceLastCheck < checkIntervalMs) {
+      return updateCache;
+    }
+    const updateInfo = await fetchUpdateInfo();
+    await saveUpdateCache(updateInfo);
+    return updateInfo;
+  } catch (error) {
+    if (process.env.PPLX_DEBUG) {
+      console.error("Update check failed:", error);
     }
+    return null;
   }
-  async performAutoUpdate(updateInfo) {
-    if (!updateInfo.updateAvailable || !updateInfo.updateUrl) {
-      return;
-    }
-    try {
-      if (!this.config.quietMode) {
-        console.log(`\uD83D\uDD04 Update available: ${updateInfo.currentVersion} → ${updateInfo.latestVersion}`);
-        console.log(`\uD83D\uDCA1 Run 'pplx update --auto' to install`);
-      }
-    } catch (error) {
-      if (!this.config.quietMode) {
-        console.error("Auto-update failed:", error);
-      }
-    }
+}
+async function forceUpdateCheck() {
+  try {
+    await fs3.unlink(UPDATE_CACHE_FILE);
+  } catch {}
+  return fetchUpdateInfo();
+}
+async function toggleAutoUpdate(enabled, autoInstall = false) {
+  const config = await loadAutoUpdateConfig();
+  const updatedConfig = {
+    ...config,
+    enabled,
+    autoInstall
+  };
+  await saveAutoUpdateConfig(updatedConfig);
+}
+async function getAutoUpdateStatus() {
+  const config = await loadAutoUpdateConfig();
+  let updateCache = null;
+  try {
+    const cacheData = await fs3.readFile(UPDATE_CACHE_FILE, "utf-8");
+    updateCache = JSON.parse(cacheData);
+  } catch {
+    updateCache = null;
   }
-  async getUpdateStatus() {
-    await this.loadUpdateCache();
+  return {
+    enabled: config.enabled,
+    autoInstall: config.autoInstall,
+    lastChecked: updateCache?.lastChecked ? new Date(updateCache.lastChecked) : undefined,
+    updateAvailable: updateCache?.updateAvailable,
+    currentVersion: updateCache?.currentVersion,
+    latestVersion: updateCache?.latestVersion
+  };
+}
+async function fetchUpdateInfo() {
+  const currentVersion = await getCurrentVersion();
+  try {
+    const npmResponse = await fetch("https://registry.npmjs.org/pplx-zero");
+    const npmData = await npmResponse.json();
+    const latestVersion = npmData["dist-tags"]?.latest || currentVersion;
+    const updateAvailable = compareVersions(latestVersion, currentVersion) > 0;
     return {
-      enabled: this.config.enabled,
-      lastChecked: this.updateCache?.lastChecked,
-      updateAvailable: this.updateCache?.updateAvailable,
-      currentVersion: this.updateCache?.currentVersion,
-      latestVersion: this.updateCache?.latestVersion
+      currentVersion,
+      latestVersion,
+      updateAvailable,
+      lastChecked: new Date,
+      updateUrl: npmData.versions?.[latestVersion]?.dist?.tarball,
+      releaseNotes: npmData.versions?.[latestVersion]?.description
+    };
+  } catch (error) {
+    return {
+      currentVersion,
+      latestVersion: currentVersion,
+      updateAvailable: false,
+      lastChecked: new Date
     };
   }
-  async forceUpdateCheck() {
-    this.updateCache = null;
-    try {
-      await fs3.unlink(AutoUpdateService.UPDATE_CACHE_FILE);
-    } catch {}
-    return this.checkForUpdates();
+}
+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";
+  } catch {
+    return "1.1.7";
+  }
+}
+function compareVersions(version1, version2) {
+  const v1Parts = version1.split(".").map(Number);
+  const v2Parts = version2.split(".").map(Number);
+  const maxLength = Math.max(v1Parts.length, v2Parts.length);
+  for (let i = 0;i < maxLength; i++) {
+    const v1Part = v1Parts[i] || 0;
+    const v2Part = v2Parts[i] || 0;
+    if (v1Part > v2Part)
+      return 1;
+    if (v1Part < v2Part)
+      return -1;
+  }
+  return 0;
+}
+async function saveUpdateCache(updateInfo) {
+  try {
+    const configDir = join3(homedir3(), ".pplx-zero");
+    await fs3.mkdir(configDir, { recursive: true });
+    await fs3.writeFile(UPDATE_CACHE_FILE, JSON.stringify(updateInfo, null, 2), "utf-8");
+  } catch (error) {
+    if (process.env.PPLX_DEBUG) {
+      console.error("Failed to save update cache:", error);
+    }
   }
 }
-var service_default = AutoUpdateService;
 
 // src/cli/commands/search.ts
 function parseNumber(value, defaultValue, min, max, name) {
@@ -9563,13 +9570,7 @@ async function logToHistory(queries, results, metadata, exportPath) {
 async function handleSearchCommand(options) {
   const startTime = Date.now();
   const sessionId = randomUUID3();
-  const autoUpdateService = new service_default({
-    enabled: true,
-    checkInterval: 1440,
-    autoInstall: false,
-    quietMode: true
-  });
-  autoUpdateService.checkForUpdates().catch((error) => {
+  checkForUpdatesCached().catch((error) => {
     if (process.env.PPLX_DEBUG) {
       console.error("Background update check failed:", error);
     }
@@ -9877,7 +9878,9 @@ import { join as join5 } from "node:path";
 import { homedir as homedir4 } from "node:os";
 async function handleUpdateCommand(options) {
   try {
-    if (options.check) {
+    if (options.check && options.auto) {
+      return await handleToggleAutoUpdate();
+    } else if (options.check) {
       return await handleUpdateCheck(options.silent);
     } else if (options.auto) {
       return await handleAutoUpdate();
@@ -9895,14 +9898,8 @@ async function handleUpdateCommand(options) {
   }
 }
 async function handleUpdateCheck(silent = false) {
-  const autoUpdateService = new service_default({
-    enabled: true,
-    checkInterval: 0,
-    autoInstall: false,
-    quietMode: silent
-  });
   try {
-    const updateInfo = await autoUpdateService.forceUpdateCheck();
+    const updateInfo = await forceUpdateCheck();
     if (!updateInfo) {
       const errorMessage = "Update check failed";
       if (!silent) {
@@ -9921,7 +9918,16 @@ async function handleUpdateCheck(silent = false) {
     if (updateInfo.updateAvailable && !silent) {
       const updateMessage = CliFormatter.formatUpdateNotification(updateInfo.currentVersion, updateInfo.latestVersion);
       console.log(CliFormatter.supportsColors() ? updateMessage : CliFormatter.formatPlainText(updateMessage));
-      console.log('\uD83D\uDCA1 Run "pplx update --auto" to install automatically');
+      const status = await getAutoUpdateStatus();
+      if (status.enabled) {
+        console.log("\uD83D\uDCA1 Auto-updates are enabled");
+        if (status.autoInstall) {
+          console.log("\uD83D\uDD04 Auto-install is enabled - updates will install automatically");
+        }
+      } else {
+        console.log('\uD83D\uDCA1 Run "pplx update --auto --check" to enable auto-updates');
+        console.log('   or run "pplx update --auto" to install manually');
+      }
     }
     return {
       exitCode: 0,
@@ -9958,13 +9964,7 @@ async function handleAutoUpdate() {
     } catch {}
     await writeFile(updateLockFile, currentPid.toString());
     try {
-      const autoUpdateService = new service_default({
-        enabled: true,
-        checkInterval: 0,
-        autoInstall: false,
-        quietMode: false
-      });
-      const updateInfo = await autoUpdateService.forceUpdateCheck();
+      const updateInfo = await forceUpdateCheck();
       if (!updateInfo || !updateInfo.updateAvailable) {
         console.log("ℹ️ No updates available. You are running the latest version.");
         return {
@@ -10051,17 +10051,36 @@ async function executeCommand(command, args) {
     });
   });
 }
-function validateUpdateOptions(options) {
-  if (!options.check && !options.auto) {
+async function handleToggleAutoUpdate() {
+  try {
+    const status = await getAutoUpdateStatus();
+    if (status.enabled) {
+      await toggleAutoUpdate(false);
+      return {
+        exitCode: 0,
+        output: "Auto-updates disabled"
+      };
+    } else {
+      await toggleAutoUpdate(true, false);
+      return {
+        exitCode: 0,
+        output: "Auto-updates enabled"
+      };
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`❌ Failed to toggle auto-update: ${errorMessage}`);
     return {
-      valid: false,
-      error: "Either --check or --auto must be specified for update command"
+      exitCode: 1,
+      error: errorMessage
     };
   }
-  if (options.check && options.auto) {
+}
+function validateUpdateOptions(options) {
+  if (!options.check && !options.auto) {
     return {
       valid: false,
-      error: "Cannot specify both --check and --auto options"
+      error: "Either --check or --auto must be specified for update command"
     };
   }
   return { valid: true };

package/package.json

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