1dr-cli 0.1.0

package/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "1dr-cli",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "1dr": "./dist/index.js"
+  },
+  "scripts": {
+    "dev": "bun run src/index.ts",
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun",
+    "compile": "bun build ./src/index.ts --compile --outfile 1dr"
+  },
+  "dependencies": {
+    "commander": "^13.1.0"
+  }
+}

package/src/auth.ts

@@ -0,0 +1,153 @@
+import { CREDENTIALS_PATH, ensureConfigDir, loadConfig, type Credentials } from './config';
+
+const CLIENT_ID = '1dr-cli';
+const POLL_INTERVAL_MS = 5_000;
+
+export async function login(): Promise<void> {
+	const config = await loadConfig();
+	const base = config.baseUrl;
+
+	// Step 1: Request device + user code
+	const codeRes = await fetch(`${base}/api/auth/device/code`, {
+		method: 'POST',
+		headers: { 'Content-Type': 'application/json' },
+		body: JSON.stringify({ client_id: CLIENT_ID })
+	});
+
+	if (!codeRes.ok) {
+		const err = await codeRes.json().catch(() => null);
+		throw new Error(`Failed to start device flow: ${err?.error_description || codeRes.statusText}`);
+	}
+
+	const codeData = (await codeRes.json()) as {
+		device_code: string;
+		user_code: string;
+		verification_uri: string;
+		verification_uri_complete: string;
+		expires_in: number;
+		interval: number;
+	};
+
+	console.log();
+	console.log(`  Open this URL in your browser:`);
+	console.log(`  \x1b[1m\x1b[36m${codeData.verification_uri_complete}\x1b[0m`);
+	console.log();
+	console.log(`  Or go to \x1b[36m${codeData.verification_uri}\x1b[0m and enter code:`);
+	console.log(`  \x1b[1m\x1b[33m${codeData.user_code}\x1b[0m`);
+	console.log();
+	console.log(`  Waiting for authorization...`);
+
+	// Step 2: Poll for token
+	const deadline = Date.now() + codeData.expires_in * 1000;
+	const interval = Math.max((codeData.interval || 5) * 1000, POLL_INTERVAL_MS);
+
+	while (Date.now() < deadline) {
+		await sleep(interval);
+
+		const tokenRes = await fetch(`${base}/api/auth/device/token`, {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({
+				grant_type: 'urn:ietf:params:oauth:grant-type:device_code',
+				device_code: codeData.device_code,
+				client_id: CLIENT_ID
+			})
+		});
+
+		if (tokenRes.ok) {
+			const tokenData = (await tokenRes.json()) as {
+				access_token: string;
+				token_type: string;
+				expires_in: number;
+				scope: string;
+			};
+
+			await saveCredentials({
+				accessToken: tokenData.access_token,
+				expiresIn: tokenData.expires_in,
+				obtainedAt: Date.now()
+			});
+
+			console.log(`  \x1b[32mAuthenticated successfully!\x1b[0m`);
+			return;
+		}
+
+		const err = (await tokenRes.json().catch(() => null)) as {
+			error?: string;
+			error_description?: string;
+		} | null;
+
+		if (err?.error === 'authorization_pending') {
+			continue; // still waiting
+		}
+		if (err?.error === 'slow_down') {
+			await sleep(5000); // back off
+			continue;
+		}
+		if (err?.error === 'access_denied') {
+			throw new Error('Authorization denied by user');
+		}
+		if (err?.error === 'expired_token') {
+			throw new Error('Device code expired. Please try again.');
+		}
+
+		throw new Error(`Token error: ${err?.error_description || err?.error || 'unknown'}`);
+	}
+
+	throw new Error('Device code expired. Please try again.');
+}
+
+export async function logout(): Promise<void> {
+	const { unlink } = await import('fs/promises');
+	try {
+		await unlink(CREDENTIALS_PATH);
+		console.log('Logged out successfully.');
+	} catch {
+		console.log('Not currently logged in.');
+	}
+}
+
+export async function getToken(): Promise<string> {
+	const creds = await loadCredentials();
+	if (!creds) {
+		throw new Error('Not logged in. Run `1dr login` first.');
+	}
+
+	// Check if expired (with 60s buffer)
+	const expiresAt = creds.obtainedAt + creds.expiresIn * 1000;
+	if (Date.now() > expiresAt - 60_000) {
+		throw new Error('Session expired. Run `1dr login` to re-authenticate.');
+	}
+
+	return creds.accessToken;
+}
+
+async function loadCredentials(): Promise<Credentials | null> {
+	try {
+		const raw = await Bun.file(CREDENTIALS_PATH).text();
+		return JSON.parse(raw) as Credentials;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * Bump obtainedAt to now — keeps local expiry in sync with
+ * the server-side session extension that happens on every request.
+ */
+export async function refreshCredentials(): Promise<void> {
+	const creds = await loadCredentials();
+	if (creds) {
+		creds.obtainedAt = Date.now();
+		await saveCredentials(creds);
+	}
+}
+
+async function saveCredentials(creds: Credentials): Promise<void> {
+	await ensureConfigDir();
+	await Bun.write(CREDENTIALS_PATH, JSON.stringify(creds, null, 2) + '\n');
+}
+
+function sleep(ms: number): Promise<void> {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/src/client.ts

@@ -0,0 +1,43 @@
+import { getToken, refreshCredentials } from './auth';
+import { loadConfig } from './config';
+
+type ApiResponse<T> = { data: T } | { error: { code: string; message: string; details?: unknown } };
+
+export async function api<T>(path: string, options?: RequestInit): Promise<T> {
+	const config = await loadConfig();
+	const token = await getToken();
+
+	const url = `${config.baseUrl}${path}`;
+	const res = await fetch(url, {
+		...options,
+		headers: {
+			'Authorization': `Bearer ${token}`,
+			'Content-Type': 'application/json',
+			...options?.headers
+		}
+	});
+
+	if (res.status === 401) {
+		throw new Error('Session expired. Run `1dr login` to re-authenticate.');
+	}
+
+	// Server extends session on every authenticated request,
+	// so bump local expiry to stay in sync
+	await refreshCredentials();
+
+	const body = (await res.json()) as ApiResponse<T>;
+
+	if ('error' in body) {
+		throw new Error(`${body.error.code}: ${body.error.message}`);
+	}
+
+	return body.data;
+}
+
+export function buildQuery(params: Record<string, string | number | undefined>): string {
+	const entries = Object.entries(params).filter(
+		(entry): entry is [string, string | number] => entry[1] !== undefined
+	);
+	if (entries.length === 0) return '';
+	return '?' + new URLSearchParams(entries.map(([k, v]) => [k, String(v)])).toString();
+}

package/src/commands/config.ts

@@ -0,0 +1,18 @@
+import { loadConfig, saveConfig } from '../config';
+
+export async function configCommand(opts: { baseUrl?: string; json?: boolean }) {
+	if (opts.baseUrl) {
+		await saveConfig({ baseUrl: opts.baseUrl });
+		console.log(`Base URL set to: ${opts.baseUrl}`);
+		return;
+	}
+
+	const config = await loadConfig();
+
+	if (opts.json) {
+		console.log(JSON.stringify(config, null, 2));
+		return;
+	}
+
+	console.log(`  Base URL: ${config.baseUrl}`);
+}

package/src/commands/login.ts

@@ -0,0 +1,10 @@
+import { login } from '../auth';
+
+export async function loginCommand() {
+	try {
+		await login();
+	} catch (err) {
+		console.error(`Login failed: ${(err as Error).message}`);
+		process.exit(1);
+	}
+}

package/src/commands/logout.ts

@@ -0,0 +1,5 @@
+import { logout } from '../auth';
+
+export async function logoutCommand() {
+	await logout();
+}

package/src/commands/mode.ts

@@ -0,0 +1,13 @@
+import { loadConfig, setMode } from '../config';
+
+export async function devCommand() {
+	await setMode(true);
+	const config = await loadConfig();
+	console.log(`  \x1b[33m[DEV]\x1b[0m Switched to dev mode → ${config.baseUrl}`);
+}
+
+export async function prodCommand() {
+	await setMode(false);
+	const config = await loadConfig();
+	console.log(`  Switched to prod mode → ${config.baseUrl}`);
+}

package/src/commands/transcripts.ts

@@ -0,0 +1,283 @@
+import { api, buildQuery } from '../client';
+
+type CompanySearchResult = {
+	exchangeTicker: string | null;
+	ticker: string | null;
+	exchange: string | null;
+	yahooTicker: string | null;
+	name: string | null;
+	sector: string | null;
+	industry: string | null;
+	country: string | null;
+};
+
+type TranscriptListItem = {
+	id: number;
+	headline: string | null;
+	date: string | null;
+	type: string | null;
+	year: number | null;
+	ticker: string | null;
+	exchange: string | null;
+	exchangeTicker: string | null;
+	yahooTicker: string | null;
+	companyName: string | null;
+	sector: string | null;
+	industry: string | null;
+	country: string | null;
+	usdmarketcap: number | null;
+	snippets: string[];
+};
+
+type TranscriptListResponse = {
+	items: TranscriptListItem[];
+	cursor: string | null;
+};
+
+type TranscriptDetail = {
+	id: number;
+	headline: string | null;
+	date: string | null;
+	type: string | null;
+	year: number | null;
+	ticker: string | null;
+	exchange: string | null;
+	exchangeTicker: string | null;
+	yahooTicker: string | null;
+	companyName: string | null;
+	components: Array<{
+		order: number;
+		text: string | null;
+		speaker: string | null;
+		speakerTypeId: number | null;
+		componentTypeId: number | null;
+	}>;
+};
+
+type CompanyTranscriptItem = {
+	id: number;
+	headline: string | null;
+	date: string | null;
+	type: string | null;
+	year: number | null;
+};
+
+type CompanyTranscriptsResponse = {
+	company: CompanySearchResult | null;
+	items: CompanyTranscriptItem[];
+	cursor: string | null;
+};
+
+type LastUpdatedResponse = {
+	lastUpdated: string | null;
+};
+
+// ── Company search ──────────────────────────────────────────────────
+
+export async function companySearchCommand(query: string, opts: { json?: boolean }) {
+	try {
+		const q = buildQuery({ q: query });
+		const results = await api<CompanySearchResult[]>(`/api/v1/transcripts/company-search${q}`);
+
+		if (opts.json) {
+			console.log(JSON.stringify(results, null, 2));
+			return;
+		}
+
+		if (results.length === 0) {
+			console.log('No companies found.');
+			return;
+		}
+
+		for (const c of results) {
+			console.log(
+				`  \x1b[1m${c.exchangeTicker || c.ticker || '???'}\x1b[0m  ${c.name || ''}  \x1b[2m${c.sector || ''} | ${c.country || ''}\x1b[0m`
+			);
+			if (c.yahooTicker && c.yahooTicker !== c.ticker) {
+				console.log(`    yahoo: ${c.yahooTicker}`);
+			}
+		}
+	} catch (err) {
+		console.error((err as Error).message);
+		process.exit(1);
+	}
+}
+
+// ── List transcripts ────────────────────────────────────────────────
+
+export async function listCommand(opts: {
+	limit?: string;
+	cursor?: string;
+	types?: string;
+	year?: string;
+	dateFrom?: string;
+	dateTo?: string;
+	search?: string;
+	yahooTicker?: string;
+	json?: boolean;
+}) {
+	try {
+		const q = buildQuery({
+			limit: opts.limit,
+			cursor: opts.cursor,
+			types: opts.types,
+			year: opts.year,
+			dateFrom: opts.dateFrom,
+			dateTo: opts.dateTo,
+			search: opts.search,
+			yahooTicker: opts.yahooTicker
+		});
+
+		const result = await api<TranscriptListResponse>(`/api/v1/transcripts${q}`);
+
+		if (opts.json) {
+			console.log(JSON.stringify(result, null, 2));
+			return;
+		}
+
+		if (result.items.length === 0) {
+			console.log('No transcripts found.');
+			return;
+		}
+
+		for (const t of result.items) {
+			const date = t.date ? new Date(t.date).toLocaleDateString() : 'n/a';
+			console.log(
+				`  \x1b[1m${t.id}\x1b[0m  ${date}  \x1b[36m${t.exchangeTicker || t.ticker || '???'}\x1b[0m  ${t.headline || ''}`
+			);
+			if (t.snippets.length > 0) {
+				for (const s of t.snippets.slice(0, 2)) {
+					const clean = s.replace(/<\/?mark>/g, '');
+					console.log(`    \x1b[2m${clean.slice(0, 120)}...\x1b[0m`);
+				}
+			}
+		}
+
+		console.log(`\n  ${result.items.length} result(s)`);
+		if (result.cursor) {
+			console.log(`  \x1b[2mNext page: --cursor ${result.cursor}\x1b[0m`);
+		}
+	} catch (err) {
+		console.error((err as Error).message);
+		process.exit(1);
+	}
+}
+
+// ── Get single transcript ───────────────────────────────────────────
+
+export async function getCommand(id: string, opts: { json?: boolean }) {
+	try {
+		const transcript = await api<TranscriptDetail>(`/api/v1/transcripts/${id}`);
+
+		if (opts.json) {
+			console.log(JSON.stringify(transcript, null, 2));
+			return;
+		}
+
+		console.log(`\n  \x1b[1m${transcript.headline}\x1b[0m`);
+		console.log(
+			`  ${transcript.exchangeTicker || transcript.ticker} | ${transcript.type} | ${transcript.date ? new Date(transcript.date).toLocaleDateString() : ''}\n`
+		);
+
+		for (const c of transcript.components) {
+			if (c.speaker) {
+				console.log(`\x1b[1m\x1b[33m${c.speaker}:\x1b[0m`);
+			}
+			if (c.text) {
+				console.log(c.text);
+				console.log();
+			}
+		}
+	} catch (err) {
+		console.error((err as Error).message);
+		process.exit(1);
+	}
+}
+
+// ── Company transcripts ─────────────────────────────────────────────
+
+export async function companyCommand(
+	ticker: string,
+	opts: {
+		limit?: string;
+		cursor?: string;
+		timeRange?: string;
+		types?: string;
+		year?: string;
+		dateFrom?: string;
+		dateTo?: string;
+		json?: boolean;
+	}
+) {
+	try {
+		const q = buildQuery({
+			limit: opts.limit,
+			cursor: opts.cursor,
+			timeRange: opts.timeRange,
+			types: opts.types,
+			year: opts.year,
+			dateFrom: opts.dateFrom,
+			dateTo: opts.dateTo
+		});
+
+		const result = await api<CompanyTranscriptsResponse>(
+			`/api/v1/transcripts/company/${encodeURIComponent(ticker)}${q}`
+		);
+
+		if (opts.json) {
+			console.log(JSON.stringify(result, null, 2));
+			return;
+		}
+
+		if (!result.company) {
+			console.log(`No company found for ticker: ${ticker}`);
+			return;
+		}
+
+		console.log(
+			`\n  \x1b[1m${result.company.name}\x1b[0m (${result.company.exchangeTicker || result.company.ticker})\n`
+		);
+
+		if (result.items.length === 0) {
+			console.log('  No transcripts found.');
+			return;
+		}
+
+		for (const t of result.items) {
+			const date = t.date ? new Date(t.date).toLocaleDateString() : 'n/a';
+			console.log(
+				`  \x1b[1m${t.id}\x1b[0m  ${date}  ${t.type || ''} ${t.year || ''}  ${t.headline || ''}`
+			);
+		}
+
+		console.log(`\n  ${result.items.length} transcript(s)`);
+		if (result.cursor) {
+			console.log(`  \x1b[2mNext page: --cursor ${result.cursor}\x1b[0m`);
+		}
+	} catch (err) {
+		console.error((err as Error).message);
+		process.exit(1);
+	}
+}
+
+// ── Last updated ────────────────────────────────────────────────────
+
+export async function lastUpdatedCommand(opts: { json?: boolean }) {
+	try {
+		const result = await api<LastUpdatedResponse>(`/api/v1/transcripts/last-updated`);
+
+		if (opts.json) {
+			console.log(JSON.stringify(result, null, 2));
+			return;
+		}
+
+		if (result.lastUpdated) {
+			console.log(`  Last updated: ${new Date(result.lastUpdated).toLocaleString()}`);
+		} else {
+			console.log('  No transcripts in database.');
+		}
+	} catch (err) {
+		console.error((err as Error).message);
+		process.exit(1);
+	}
+}

package/src/commands/whoami.ts

@@ -0,0 +1,36 @@
+import { getToken } from '../auth';
+import { loadConfig } from '../config';
+
+export async function whoamiCommand(opts: { json?: boolean }) {
+	try {
+		const config = await loadConfig();
+		const token = await getToken();
+
+		const res = await fetch(`${config.baseUrl}/api/auth/get-session`, {
+			headers: { Authorization: `Bearer ${token}` }
+		});
+
+		if (!res.ok) {
+			throw new Error('Failed to get session. Try `1dr login` again.');
+		}
+
+		const data = (await res.json()) as {
+			user: { id: string; name: string; email: string; level: number; username?: string };
+			session: { id: string; expiresAt: string };
+		};
+
+		if (opts.json) {
+			console.log(JSON.stringify(data, null, 2));
+			return;
+		}
+
+		console.log(`  Name:     ${data.user.name}`);
+		console.log(`  Email:    ${data.user.email}`);
+		console.log(`  Username: ${data.user.username || '(not set)'}`);
+		console.log(`  Level:    ${data.user.level}`);
+		console.log(`  Expires:  ${new Date(data.session.expiresAt).toLocaleString()}`);
+	} catch (err) {
+		console.error((err as Error).message);
+		process.exit(1);
+	}
+}

package/src/config.ts

@@ -0,0 +1,58 @@
+import { homedir } from 'os';
+import { join } from 'path';
+
+const CONFIG_DIR = join(homedir(), '.config', '1dr');
+export const CREDENTIALS_PATH = join(CONFIG_DIR, 'credentials.json');
+export const CONFIG_PATH = join(CONFIG_DIR, 'config.json');
+
+export type Config = {
+	baseUrl: string;
+	dev?: boolean;
+};
+
+export type Credentials = {
+	accessToken: string;
+	expiresIn: number;
+	obtainedAt: number; // epoch ms
+};
+
+const PROD_URL = 'https://firstdraftresearch.com';
+const DEV_URL = 'http://localhost:5173';
+
+const DEFAULT_CONFIG: Config = {
+	baseUrl: PROD_URL,
+	dev: false
+};
+
+export async function ensureConfigDir() {
+	const { mkdir } = await import('fs/promises');
+	await mkdir(CONFIG_DIR, { recursive: true });
+}
+
+export async function loadConfig(): Promise<Config> {
+	try {
+		const raw = await Bun.file(CONFIG_PATH).text();
+		const stored = JSON.parse(raw);
+		const config = { ...DEFAULT_CONFIG, ...stored };
+		// Resolve baseUrl from dev flag unless explicitly overridden
+		if (!stored.baseUrl) {
+			config.baseUrl = config.dev ? DEV_URL : PROD_URL;
+		}
+		return config;
+	} catch {
+		return DEFAULT_CONFIG;
+	}
+}
+
+export async function saveConfig(config: Partial<Config>) {
+	await ensureConfigDir();
+	const existing = await loadConfig();
+	const merged = { ...existing, ...config };
+	await Bun.write(CONFIG_PATH, JSON.stringify(merged, null, 2) + '\n');
+}
+
+/** Switch dev/prod mode — clears any manual baseUrl override */
+export async function setMode(dev: boolean) {
+	await ensureConfigDir();
+	await Bun.write(CONFIG_PATH, JSON.stringify({ dev }, null, 2) + '\n');
+}

package/src/index.ts

@@ -0,0 +1,102 @@
+#!/usr/bin/env bun
+import { Command } from 'commander';
+import { loginCommand } from './commands/login';
+import { logoutCommand } from './commands/logout';
+import { whoamiCommand } from './commands/whoami';
+import {
+	companySearchCommand,
+	listCommand,
+	getCommand,
+	companyCommand,
+	lastUpdatedCommand
+} from './commands/transcripts';
+import { configCommand } from './commands/config';
+import { devCommand, prodCommand } from './commands/mode';
+import { loadConfig } from './config';
+
+const program = new Command();
+
+program.name('1dr').description('First Draft Research CLI').version('0.1.0');
+
+// Show [DEV] indicator before every command when in dev mode
+program.hook('preAction', async (_thisCmd, actionCmd) => {
+	if (['dev', 'prod'].includes(actionCmd.name())) return;
+	const config = await loadConfig();
+	if (config.dev) {
+		console.log(`  \x1b[33m[DEV]\x1b[0m ${config.baseUrl}`);
+	}
+});
+
+// Auth
+program.command('login').description('Authenticate via browser (device flow)').action(loginCommand);
+program.command('logout').description('Remove stored credentials').action(logoutCommand);
+program
+	.command('whoami')
+	.description('Show current user info')
+	.option('--json', 'Output as JSON')
+	.action(whoamiCommand);
+
+// Config
+program
+	.command('config')
+	.description('View or set configuration')
+	.option('--base-url <url>', 'Set the API base URL')
+	.option('--json', 'Output as JSON')
+	.action(configCommand);
+
+// Mode
+program.command('dev').description('Switch to dev mode (localhost:5173)').action(devCommand);
+program.command('prod').description('Switch to prod mode (firstdraftresearch.com)').action(prodCommand);
+
+// Transcripts
+const transcripts = program
+	.command('transcripts')
+	.alias('t')
+	.description('Search and read earnings call transcripts');
+
+transcripts
+	.command('search <query>')
+	.description('Search companies by ticker or name (returns exchange:ticker)')
+	.option('--json', 'Output as JSON')
+	.action(companySearchCommand);
+
+transcripts
+	.command('list')
+	.description('List transcripts by date (cursored, max 500)')
+	.option('-l, --limit <n>', 'Max results (max 500)', '50')
+	.option('--cursor <date>', 'Cursor from previous page (ISO date)')
+	.option('-s, --search <term>', 'Full-text search')
+	.option('--yahoo-ticker <ticker>', 'Filter by yahoo ticker (e.g. AAPL, 2330.TW)')
+	.option('--types <list>', 'Filter by call types (Q1,Q2,Q3,Q4,CONF,OTHER,CMD)')
+	.option('-y, --year <year>', 'Filter by fiscal year')
+	.option('--date-from <date>', 'Start date (ISO)')
+	.option('--date-to <date>', 'End date (ISO)')
+	.option('--json', 'Output as JSON')
+	.action(listCommand);
+
+transcripts
+	.command('get <id>')
+	.description('Read a full transcript')
+	.option('--json', 'Output as JSON')
+	.action(getCommand);
+
+transcripts
+	.command('company <ticker>')
+	.description('List transcripts for a company (yahoo ticker)')
+	.option('-l, --limit <n>', 'Max results (max 500)', '50')
+	.option('--cursor <date>', 'Cursor from previous page (ISO date)')
+	.option('-t, --time-range <range>', 'Time range: 1M,3M,6M,YTD,1Y,2Y,5Y,Max')
+	.option('--types <list>', 'Filter by call types (Q1,Q2,Q3,Q4,CONF,OTHER,CMD)')
+	.option('-y, --year <year>', 'Filter by fiscal year')
+	.option('--date-from <date>', 'Start date (ISO)')
+	.option('--date-to <date>', 'End date (ISO)')
+	.option('--json', 'Output as JSON')
+	.action(companyCommand);
+
+transcripts
+	.command('last-updated')
+	.description('Show when the transcript database was last updated')
+	.option('--json', 'Output as JSON')
+	.action(lastUpdatedCommand);
+
+program.parse();

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "rootDir": "src",
+    "types": ["bun-types"]
+  },
+  "include": ["src"]
+}