pplx-zero 1.1.8 → 2.1.0

package/package.json

@@ -1,80 +1,46 @@
 {
   "name": "pplx-zero",
-  "version": "1.1.8",
-  "description": "Fast Perplexity AI search CLI with multimodal support - minimal setup, maximal results",
+  "version": "2.1.0",
+  "description": "Minimal Perplexity AI CLI - search from terminal",
+  "author": "kenzo",
+  "license": "MIT",
   "type": "module",
-  "main": "dist/index.js",
+  "module": "src/index.ts",
   "bin": {
-    "pplx": "dist/index.js"
+    "pplx": "bin/pplx.js"
   },
   "scripts": {
-    "dev": "bun run src/cli/index.ts",
-    "dev:legacy": "bun run src/cli.ts",
-    "build": "rm -rf dist && bun build src/cli/index.ts --target node --outdir dist",
-    "build:legacy": "rm -rf dist && bun build src/cli.ts --target node --outdir dist",
-    "build:binary": "bun build --compile src/cli/index.ts --outfile=dist/pplx",
-    "build:binary:legacy": "bun build --compile src/cli.ts --outfile=dist/pplx-legacy",
-    "test": "bun test",
-    "test:watch": "bun test --watch",
-    "typecheck": "bun tsc --noEmit",
-    "lint": "bun run --bun eslint src/**/*.ts",
-    "lint:fix": "bun run --bun eslint src/**/*.ts --fix",
-    "clean": "rm -rf dist",
-    "dev:debug": "bun --inspect src/cli/index.ts",
-    "dev:debug:legacy": "bun --inspect src/cli.ts"
+    "build": "bun build src/index.ts --compile --outfile=pplx",
+    "dev": "bun run src/index.ts",
+    "test": "bun test"
   },
   "dependencies": {
-    "@perplexity-ai/perplexity_ai": "^0.11.0",
-    "abort-controller": "^3.0.0",
-    "commander": "^12.0.0",
-    "dotenv": "^16.3.1",
-    "zod": "^3.22.4"
+    "zod": "^4.0.0"
   },
   "devDependencies": {
-    "@types/node": "^20.0.0",
-    "typescript": "^5.0.0",
-    "bun-types": "latest",
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0",
-    "eslint": "^8.0.0"
+    "@types/bun": "latest"
   },
-  "engines": {
-    "bun": ">=1.0.0"
+  "peerDependencies": {
+    "typescript": "^5"
   },
-  "keywords": [
-    "pplx-zero",
-    "perplexity",
-    "search",
-    "ai",
-    "cli",
-    "command-line",
-    "tool",
-    "typescript",
-    "bun",
-    "api",
-    "minimal",
-    "fast",
-    "productivity",
-    "zero-config",
-    "multimodal",
-    "attachments",
-    "images",
-    "documents",
-    "sonar",
-    "reasoning",
-    "research",
-    "async"
+  "files": [
+    "src",
+    "bin"
   ],
-  "author": "Kenzo",
-  "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/codewithkenzo/pplx-zero.git"
   },
-  "files": [
-    "dist",
-    "README.md",
-    "LICENSE",
-    "package.json"
+  "bugs": {
+    "url": "https://github.com/codewithkenzo/pplx-zero/issues"
+  },
+  "homepage": "https://github.com/codewithkenzo/pplx-zero#readme",
+  "keywords": [
+    "perplexity",
+    "ai",
+    "search",
+    "cli",
+    "terminal",
+    "bun"
   ]
-}
+}

package/src/api.test.ts

@@ -0,0 +1,21 @@
+import { test, expect, describe } from 'bun:test';
+import { MODELS, type Model } from './api';
+
+describe('MODELS', () => {
+  test('includes all expected models', () => {
+    expect(MODELS).toContain('sonar');
+    expect(MODELS).toContain('sonar-pro');
+    expect(MODELS).toContain('sonar-reasoning');
+    expect(MODELS).toContain('sonar-reasoning-pro');
+    expect(MODELS).toContain('sonar-deep-research');
+  });
+
+  test('has exactly 5 models', () => {
+    expect(MODELS).toHaveLength(5);
+  });
+
+  test('Model type matches MODELS array', () => {
+    const model: Model = MODELS[0]!;
+    expect(MODELS.includes(model)).toBe(true);
+  });
+});

package/src/api.ts

@@ -0,0 +1,116 @@
+import { getEnv } from './env';
+import type { FileAttachment } from './files';
+
+const API_URL = 'https://api.perplexity.ai/chat/completions';
+
+export const MODELS = ['sonar', 'sonar-pro', 'sonar-reasoning', 'sonar-reasoning-pro', 'sonar-deep-research'] as const;
+export type Model = (typeof MODELS)[number];
+
+export interface SearchResult {
+  title: string;
+  url: string;
+  date?: string;
+}
+
+export interface StreamCallbacks {
+  onContent: (text: string) => void;
+  onDone: (citations: SearchResult[], usage: { prompt_tokens: number; completion_tokens: number }) => void;
+  onError: (error: Error) => void;
+}
+
+interface MessageContent {
+  type: 'text' | 'file_url';
+  text?: string;
+  file_url?: { url: string };
+  file_name?: string;
+}
+
+function buildMessages(query: string, file?: FileAttachment): { role: string; content: string | MessageContent[] }[] {
+  if (!file) {
+    return [{ role: 'user', content: query }];
+  }
+
+  const content: MessageContent[] = [
+    { type: 'text', text: query },
+    {
+      type: 'file_url',
+      file_url: { url: file.data },
+      file_name: file.filename,
+    },
+  ];
+
+  return [{ role: 'user', content }];
+}
+
+export async function search(
+  query: string,
+  model: Model,
+  callbacks: StreamCallbacks,
+  file?: FileAttachment
+): Promise<void> {
+  const body = JSON.stringify({
+    model,
+    messages: buildMessages(query, file),
+    stream: true,
+  });
+
+  const response = await fetch(API_URL, {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${getEnv().PERPLEXITY_API_KEY}`,
+      'Content-Type': 'application/json',
+    },
+    body,
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    callbacks.onError(new Error(`API error ${response.status}: ${text}`));
+    return;
+  }
+
+  if (!response.body) {
+    callbacks.onError(new Error('No response body'));
+    return;
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let citations: SearchResult[] = [];
+  let usage = { prompt_tokens: 0, completion_tokens: 0 };
+
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+
+    buffer += decoder.decode(value, { stream: true });
+    const lines = buffer.split('\n');
+    buffer = lines.pop() || '';
+
+    for (const line of lines) {
+      if (!line.startsWith('data: ')) continue;
+      const data = line.slice(6).trim();
+      if (data === '[DONE]') continue;
+
+      try {
+        const parsed = JSON.parse(data);
+        const delta = parsed.choices?.[0]?.delta?.content;
+        if (delta) {
+          callbacks.onContent(delta);
+        }
+
+        if (parsed.search_results) {
+          citations = parsed.search_results;
+        }
+        if (parsed.usage) {
+          usage = parsed.usage;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+
+  callbacks.onDone(citations, usage);
+}

package/src/env.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+
+const c = {
+  reset: '\x1b[0m',
+  red: '\x1b[31m',
+  yellow: '\x1b[33m',
+  cyan: '\x1b[36m',
+  dim: '\x1b[2m',
+} as const;
+
+const envSchema = z.object({
+  PERPLEXITY_API_KEY: z.string().min(1),
+});
+
+let _env: z.infer<typeof envSchema> | null = null;
+
+export function getEnv() {
+  if (_env) return _env;
+
+  const key = process.env.PERPLEXITY_API_KEY || process.env.PERPLEXITY_AI_API_KEY;
+  
+  if (!key) {
+    console.error(`
+${c.red}✗ Missing API Key${c.reset}
+
+Set your Perplexity API key:
+
+  ${c.cyan}export PERPLEXITY_API_KEY="pplx-..."${c.reset}
+
+${c.dim}Get one at: https://perplexity.ai/settings/api${c.reset}
+`);
+    process.exit(2);
+  }
+
+  _env = { PERPLEXITY_API_KEY: key };
+  return _env;
+}

package/src/files.test.ts

@@ -0,0 +1,71 @@
+import { test, expect, describe } from 'bun:test';
+import { encodeFile, toDataUrl, type FileAttachment } from './files';
+import { writeFile, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+
+const TMP_DIR = '/tmp';
+
+describe('encodeFile', () => {
+  test('encodes text file correctly', async () => {
+    const testPath = join(TMP_DIR, 'test.txt');
+    await writeFile(testPath, 'hello world');
+    
+    const result = await encodeFile(testPath);
+    
+    expect(result.type).toBe('file');
+    expect(result.mimeType).toBe('text/plain');
+    expect(result.filename).toBe('test.txt');
+    expect(result.data).toBe(Buffer.from('hello world').toString('base64'));
+    
+    await unlink(testPath);
+  });
+
+  test('encodes PDF as file type', async () => {
+    const testPath = join(TMP_DIR, 'test.pdf');
+    await writeFile(testPath, '%PDF-1.4 test');
+    
+    const result = await encodeFile(testPath);
+    
+    expect(result.type).toBe('file');
+    expect(result.mimeType).toBe('application/pdf');
+    
+    await unlink(testPath);
+  });
+
+  test('encodes PNG as image type', async () => {
+    const testPath = join(TMP_DIR, 'test.png');
+    const pngHeader = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]);
+    await writeFile(testPath, pngHeader);
+    
+    const result = await encodeFile(testPath);
+    
+    expect(result.type).toBe('image');
+    expect(result.mimeType).toBe('image/png');
+    
+    await unlink(testPath);
+  });
+
+  test('throws on unsupported file type', async () => {
+    const testPath = join(TMP_DIR, 'test.xyz');
+    await writeFile(testPath, 'test');
+    
+    await expect(encodeFile(testPath)).rejects.toThrow('Unsupported file type: .xyz');
+    
+    await unlink(testPath);
+  });
+});
+
+describe('toDataUrl', () => {
+  test('creates valid data URL', () => {
+    const attachment: FileAttachment = {
+      type: 'image',
+      data: 'aGVsbG8gd29ybGQ=',
+      mimeType: 'image/png',
+      filename: 'test.png',
+    };
+    
+    const result = toDataUrl(attachment);
+    
+    expect(result).toBe('data:image/png;base64,aGVsbG8gd29ybGQ=');
+  });
+});

package/src/files.ts

@@ -0,0 +1,44 @@
+import { readFile } from 'node:fs/promises';
+import { extname } from 'node:path';
+
+const MIME_TYPES: Record<string, string> = {
+  '.pdf': 'application/pdf',
+  '.txt': 'text/plain',
+  '.md': 'text/markdown',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+};
+
+export interface FileAttachment {
+  type: 'file' | 'image';
+  data: string;
+  mimeType: string;
+  filename: string;
+}
+
+export async function encodeFile(path: string): Promise<FileAttachment> {
+  const ext = extname(path).toLowerCase();
+  const mimeType = MIME_TYPES[ext];
+  
+  if (!mimeType) {
+    throw new Error(`Unsupported file type: ${ext}`);
+  }
+
+  const buffer = await readFile(path);
+  const data = buffer.toString('base64');
+  const isImage = mimeType.startsWith('image/');
+
+  return {
+    type: isImage ? 'image' : 'file',
+    data,
+    mimeType,
+    filename: path.split('/').pop() || 'file',
+  };
+}
+
+export function toDataUrl(attachment: FileAttachment): string {
+  return `data:${attachment.mimeType};base64,${attachment.data}`;
+}

package/src/history.test.ts

@@ -0,0 +1,84 @@
+import { test, expect, beforeEach, afterAll } from 'bun:test';
+import { appendHistory, readHistory, getLastEntry, clearHistory } from './history';
+
+beforeEach(async () => {
+  await clearHistory();
+});
+
+afterAll(async () => {
+  await clearHistory();
+});
+
+test('appendHistory creates entry', async () => {
+  await appendHistory({ q: 'test query', m: 'sonar', a: 'test answer' });
+  const entries = await readHistory();
+  expect(entries.length).toBe(1);
+  expect(entries[0]!.q).toBe('test query');
+  expect(entries[0]!.m).toBe('sonar');
+  expect(entries[0]!.a).toBe('test answer');
+  expect(entries[0]!.ts).toBeGreaterThan(0);
+});
+
+test('readHistory returns entries in reverse order', async () => {
+  await appendHistory({ q: 'first', m: 'sonar', a: 'a1' });
+  await appendHistory({ q: 'second', m: 'sonar-pro', a: 'a2' });
+  await appendHistory({ q: 'third', m: 'sonar', a: 'a3' });
+  
+  const entries = await readHistory();
+  expect(entries.length).toBe(3);
+  expect(entries[0]!.q).toBe('third');
+  expect(entries[1]!.q).toBe('second');
+  expect(entries[2]!.q).toBe('first');
+});
+
+test('readHistory respects limit', async () => {
+  await appendHistory({ q: 'one', m: 'sonar', a: 'a' });
+  await appendHistory({ q: 'two', m: 'sonar', a: 'a' });
+  await appendHistory({ q: 'three', m: 'sonar', a: 'a' });
+  
+  const entries = await readHistory(2);
+  expect(entries.length).toBe(2);
+  expect(entries[0]!.q).toBe('three');
+  expect(entries[1]!.q).toBe('two');
+});
+
+test('getLastEntry returns most recent', async () => {
+  await appendHistory({ q: 'old', m: 'sonar', a: 'old answer' });
+  await appendHistory({ q: 'new', m: 'sonar-pro', a: 'new answer' });
+  
+  const last = await getLastEntry();
+  expect(last?.q).toBe('new');
+  expect(last?.m).toBe('sonar-pro');
+});
+
+test('getLastEntry returns null when empty', async () => {
+  const last = await getLastEntry();
+  expect(last).toBeNull();
+});
+
+test('clearHistory removes all entries', async () => {
+  await appendHistory({ q: 'test', m: 'sonar', a: 'answer' });
+  await clearHistory();
+  const entries = await readHistory();
+  expect(entries.length).toBe(0);
+});
+
+test('appendHistory stores citations', async () => {
+  await appendHistory({ 
+    q: 'query', 
+    m: 'sonar', 
+    a: 'answer',
+    citations: ['https://example.com', 'https://test.com']
+  });
+  
+  const entries = await readHistory();
+  expect(entries[0]!.citations).toEqual(['https://example.com', 'https://test.com']);
+});
+
+test('appendHistory truncates long answers', async () => {
+  const longAnswer = 'x'.repeat(3000);
+  await appendHistory({ q: 'query', m: 'sonar', a: longAnswer });
+  
+  const entries = await readHistory();
+  expect(entries[0]!.a.length).toBe(2000);
+});

package/src/history.ts

@@ -0,0 +1,86 @@
+import type { Model } from './api';
+
+export interface HistoryEntry {
+  ts: number;
+  q: string;
+  m: Model;
+  a: string;
+  citations?: string[];
+}
+
+const HISTORY_DIR = `${process.env.HOME}/.pplx`;
+const HISTORY_PATH = `${HISTORY_DIR}/history.jsonl`;
+const MAX_ENTRIES = 1000;
+const MAX_ANSWER_LENGTH = 2000;
+
+async function ensureDir(): Promise<void> {
+  const dir = Bun.file(HISTORY_DIR);
+  if (!(await dir.exists())) {
+    await Bun.$`mkdir -p ${HISTORY_DIR}`;
+  }
+}
+
+export async function appendHistory(entry: Omit<HistoryEntry, 'ts'>): Promise<void> {
+  await ensureDir();
+  
+  const file = Bun.file(HISTORY_PATH);
+  const exists = await file.exists();
+  
+  if (exists) {
+    const text = await file.text();
+    const lines = text.trim().split('\n').filter(l => l.length > 0);
+    if (lines.length >= MAX_ENTRIES) {
+      const keep = lines.slice(-MAX_ENTRIES + 1).join('\n') + '\n';
+      await Bun.write(HISTORY_PATH, keep);
+    }
+  }
+  
+  const record: HistoryEntry = {
+    ts: Date.now(),
+    q: entry.q,
+    m: entry.m,
+    a: entry.a.slice(0, MAX_ANSWER_LENGTH),
+    ...(entry.citations?.length ? { citations: entry.citations } : {}),
+  };
+  
+  const line = JSON.stringify(record) + '\n';
+  
+  if (exists) {
+    const current = await Bun.file(HISTORY_PATH).text();
+    await Bun.write(HISTORY_PATH, current + line);
+  } else {
+    await Bun.write(HISTORY_PATH, line);
+  }
+}
+
+export async function readHistory(limit = 20): Promise<HistoryEntry[]> {
+  const file = Bun.file(HISTORY_PATH);
+  if (!(await file.exists())) return [];
+  
+  const text = await file.text();
+  const lines = text.trim().split('\n').filter(l => l.length > 0);
+  
+  return lines
+    .map(line => {
+      try {
+        return JSON.parse(line) as HistoryEntry;
+      } catch {
+        return null;
+      }
+    })
+    .filter((e): e is HistoryEntry => e !== null)
+    .reverse()
+    .slice(0, limit);
+}
+
+export async function getLastEntry(): Promise<HistoryEntry | null> {
+  const entries = await readHistory(1);
+  return entries[0] ?? null;
+}
+
+export async function clearHistory(): Promise<void> {
+  const file = Bun.file(HISTORY_PATH);
+  if (await file.exists()) {
+    await Bun.write(HISTORY_PATH, '');
+  }
+}