pplx-zero 1.1.8 → 2.1.0

package/src/index.ts

@@ -0,0 +1,179 @@
+#!/usr/bin/env bun
+import { parseArgs } from 'node:util';
+import { search, MODELS, type Model } from './api';
+import { encodeFile } from './files';
+import { getEnv } from './env';
+import { fmt, write, writeLn } from './output';
+import { appendHistory, readHistory, getLastEntry } from './history';
+
+getEnv();
+
+const { values, positionals } = parseArgs({
+  args: Bun.argv.slice(2),
+  options: {
+    model: { type: 'string', short: 'm', default: 'sonar' },
+    file: { type: 'string', short: 'f' },
+    image: { type: 'string', short: 'i' },
+    json: { type: 'boolean', default: false },
+    help: { type: 'boolean', short: 'h' },
+    history: { type: 'boolean', default: false },
+    'no-history': { type: 'boolean', default: false },
+    continue: { type: 'boolean', short: 'c', default: false },
+    output: { type: 'string', short: 'o' },
+  },
+  allowPositionals: true,
+  strict: true,
+});
+
+if (values.help) {
+  console.log(`
+pplx - Perplexity AI search from terminal
+
+Usage: pplx [options] <query>
+
+Options:
+  -m, --model <name>   Model: ${MODELS.join(', ')} (default: sonar)
+  -f, --file <path>    Attach a file (PDF, TXT, etc.)
+  -i, --image <path>   Attach an image (PNG, JPG, etc.)
+  -o, --output <path>  Save output to file (.md, .txt)
+  -c, --continue       Continue from last query (add context)
+  --history            Show query history
+  --no-history         Don't save this query to history
+  --json               Output as JSON
+  -h, --help           Show this help
+
+Examples:
+  pplx "what is bun"
+  pplx -m sonar-pro "explain quantum computing"
+  pplx -f report.pdf "summarize this document"
+  pplx -c "tell me more about that"
+  pplx --history | grep "bun"
+`);
+  process.exit(0);
+}
+
+if (values.history) {
+  const entries = await readHistory(20);
+  if (entries.length === 0) {
+    console.log('No history yet.');
+  } else {
+    for (const entry of entries) {
+      console.log(fmt.historyEntry(entry.ts, entry.m, entry.q));
+    }
+  }
+  process.exit(0);
+}
+
+if (positionals.length === 0 && !values.continue) {
+  console.error(fmt.error('No query provided. Use -h for help.'));
+  process.exit(2);
+}
+
+let query = positionals.join(' ');
+const model = (MODELS.includes(values.model as Model) ? values.model : 'sonar') as Model;
+
+if (values.continue) {
+  const last = await getLastEntry();
+  if (last) {
+    const context = `Previous question: "${last.q}"\nPrevious answer: "${last.a.slice(0, 500)}..."\n\nFollow-up question: ${query || 'Continue and elaborate on the previous answer.'}`;
+    query = context;
+    if (!values.json) {
+      await write(fmt.continuing(last.q));
+    }
+  } else if (!query) {
+    console.error(fmt.error('No previous query to continue from.'));
+    process.exit(2);
+  }
+}
+
+const filePath = values.file || values.image;
+const file = filePath ? await encodeFile(filePath) : undefined;
+
+const startTime = Date.now();
+let fullContent = '';
+let outputBuffer = '';
+
+if (!values.json) {
+  await write(fmt.model(model) + ' ');
+  await write(fmt.searching());
+}
+
+await search(query, model, {
+  onContent: async (text) => {
+    fullContent += text;
+    if (!values.json) {
+      await write(text);
+    }
+  },
+  onDone: async (citations, usage) => {
+    const elapsed = Date.now() - startTime;
+    const citationUrls = citations.map((c) => c.url);
+
+    if (values.json) {
+      const output = {
+        answer: fullContent,
+        citations: citationUrls,
+        model,
+        tokens: usage.prompt_tokens + usage.completion_tokens,
+        latency_ms: elapsed,
+      };
+      console.log(JSON.stringify(output, null, 2));
+    } else {
+      if (citations.length > 0) {
+        await writeLn(fmt.sources());
+        for (let i = 0; i < citations.length; i++) {
+          await writeLn(fmt.citation(i + 1, citations[i]!.url));
+        }
+      }
+      await write(fmt.stats(usage.prompt_tokens + usage.completion_tokens, elapsed));
+    }
+
+    if (values.output) {
+      const ext = values.output.split('.').pop()?.toLowerCase();
+      let content = '';
+      
+      if (ext === 'md') {
+        content = `# ${positionals.join(' ') || 'Query'}\n\n`;
+        content += `**Model:** ${model}\n`;
+        content += `**Date:** ${new Date().toISOString()}\n\n`;
+        content += `## Answer\n\n${fullContent}\n\n`;
+        if (citationUrls.length > 0) {
+          content += `## Sources\n\n`;
+          citationUrls.forEach((url, i) => {
+            content += `${i + 1}. ${url}\n`;
+          });
+        }
+      } else {
+        content = fullContent;
+        if (citationUrls.length > 0) {
+          content += '\n\nSources:\n';
+          citationUrls.forEach((url, i) => {
+            content += `${i + 1}. ${url}\n`;
+          });
+        }
+      }
+      
+      await Bun.write(values.output, content);
+      if (!values.json) {
+        await writeLn(`\n${fmt.model('saved')} ${values.output}`);
+      }
+    }
+
+    if (!values['no-history'] && !values.json) {
+      await appendHistory({
+        q: positionals.join(' ') || '(continued)',
+        m: model,
+        a: fullContent,
+        citations: citationUrls,
+      });
+    }
+  },
+  onError: async (error) => {
+    if (values.json) {
+      console.error(JSON.stringify({ error: error.message }));
+    } else {
+      await write(fmt.error(error.message));
+    }
+    process.exit(1);
+  },
+}, file);

package/src/output.test.ts

@@ -0,0 +1,41 @@
+import { test, expect, describe } from 'bun:test';
+import { fmt } from './output';
+
+describe('fmt', () => {
+  test('model formats with cyan color', () => {
+    const result = fmt.model('sonar');
+    expect(result).toContain('[sonar]');
+    expect(result).toContain('\x1b[36m');
+    expect(result).toContain('\x1b[0m');
+  });
+
+  test('searching shows dim text', () => {
+    const result = fmt.searching();
+    expect(result).toContain('Searching...');
+    expect(result).toContain('\x1b[2m');
+  });
+
+  test('error formats with red color', () => {
+    const result = fmt.error('test error');
+    expect(result).toContain('Error: test error');
+    expect(result).toContain('\x1b[31m');
+  });
+
+  test('citation formats with number and URL', () => {
+    const result = fmt.citation(1, 'https://example.com');
+    expect(result).toContain('1.');
+    expect(result).toContain('https://example.com');
+  });
+
+  test('stats formats tokens and time', () => {
+    const result = fmt.stats(100, 1500);
+    expect(result).toContain('100 tokens');
+    expect(result).toContain('1.5s');
+  });
+
+  test('sources shows yellow header', () => {
+    const result = fmt.sources();
+    expect(result).toContain('Sources:');
+    expect(result).toContain('\x1b[33m');
+  });
+});

package/src/output.ts

@@ -0,0 +1,35 @@
+const c = {
+  reset: '\x1b[0m',
+  dim: '\x1b[2m',
+  bold: '\x1b[1m',
+  cyan: '\x1b[36m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  red: '\x1b[31m',
+  gray: '\x1b[90m',
+} as const;
+
+export const fmt = {
+  model: (name: string) => `${c.cyan}[${name}]${c.reset}`,
+  searching: () => `${c.dim}Searching...${c.reset}\n`,
+  error: (msg: string) => `${c.red}Error: ${msg}${c.reset}\n`,
+  citation: (i: number, url: string) => `${c.dim}  ${i}. ${url}${c.reset}`,
+  stats: (tokens: number, ms: number) => 
+    `\n${c.gray}[${tokens} tokens, ${(ms / 1000).toFixed(1)}s]${c.reset}\n`,
+  sources: () => `\n${c.yellow}Sources:${c.reset}`,
+  historyEntry: (ts: number, model: string, query: string) => {
+    const date = new Date(ts).toLocaleString('en-US', { 
+      month: 'short', day: 'numeric', hour: '2-digit', minute: '2-digit' 
+    });
+    return `${c.dim}${date}${c.reset} ${c.cyan}[${model}]${c.reset} ${query}`;
+  },
+  continuing: (query: string) => `${c.dim}Continuing from:${c.reset} ${query.slice(0, 50)}${query.length > 50 ? '...' : ''}\n`,
+};
+
+export async function write(text: string): Promise<void> {
+  await Bun.write(Bun.stdout, text);
+}
+
+export async function writeLn(text: string): Promise<void> {
+  await Bun.write(Bun.stdout, text + '\n');
+}