glance-cli 0.12.0 → 0.13.1

package/src/cli/types.ts

@@ -0,0 +1,114 @@
+/**
+ * Type definitions for CLI modules
+ */
+
+// Service detection types
+export interface ServiceStatus {
+	ollama: {
+		available: boolean;
+		models?: string[];
+		error?: string;
+	};
+	openai: {
+		available: boolean;
+		error?: string;
+	};
+	gemini: {
+		available: boolean;
+		error?: string;
+	};
+	elevenlabs: {
+		available: boolean;
+		voices?: string[];
+		error?: string;
+	};
+	defaultModel?: string;
+	priority?: string;
+	recommendations?: string[];
+}
+
+// Voice synthesis types
+export interface VoiceOptions {
+	voice?: string;
+	language?: string;
+	speed?: number;
+	pitch?: number;
+}
+
+// Cache options types
+export interface CacheOptions {
+	noCache?: boolean;
+	ttl?: number;
+	compress?: boolean;
+}
+
+// Model provider types
+export type ModelProvider = "openai" | "google" | "ollama" | "auto";
+
+// Summary types
+export interface SummaryOptions {
+	tldr?: boolean;
+	keyPoints?: boolean;
+	eli5?: boolean;
+	full?: boolean;
+	customQuestion?: string;
+	language?: string;
+	stream?: boolean;
+	maxTokens?: number;
+}
+
+// Fetch options types
+export interface FetchOptions {
+	fullRender?: boolean;
+	timeout?: number;
+	userAgent?: string;
+}
+
+// Format options types
+export interface FormatOptions {
+	url?: string;
+	language?: string;
+	customQuestion?: string;
+	customTitle?: string;
+	isFullContent?: boolean;
+}
+
+// CLI parsed values types
+export interface CliValues {
+	help?: boolean;
+	version?: boolean;
+	tldr?: boolean;
+	"key-points"?: boolean;
+	eli5?: boolean;
+	full?: boolean;
+	ask?: string;
+	language?: string;
+	read?: boolean;
+	voice?: string;
+	"list-voices"?: boolean;
+	"audio-output"?: string;
+	model?: string;
+	"list-models"?: boolean;
+	stream?: boolean;
+	"max-tokens"?: string;
+	"check-services"?: boolean;
+	"free-only"?: boolean;
+	"prefer-quality"?: boolean;
+	"no-cache"?: boolean;
+	"clear-cache"?: boolean;
+	"full-render"?: boolean;
+	screenshot?: string;
+	metadata?: boolean;
+	links?: boolean;
+	debug?: boolean;
+}
+
+// Error types with proper structure
+export interface GlanceErrorDetails {
+	code: string;
+	message: string;
+	userMessage: string;
+	recoverable?: boolean;
+	hint?: string;
+	cause?: Error;
+}

package/src/cli/utils.ts

@@ -0,0 +1,239 @@
+/**
+ * Utility functions for Glance CLI
+ */
+
+import ora, { type Ora } from "ora";
+import {
+	hasBinaryArtifacts,
+	nuclearCleanText,
+	sanitizeAIResponse,
+} from "../core/text-cleaner";
+import { CONFIG } from "./config";
+import { GlanceError } from "./errors";
+import { logger } from "./logger";
+
+/**
+ * Sanitize text output for terminal display
+ */
+export function sanitizeOutputForTerminal(text: string): string {
+	// Preserve terminal color codes while cleaning text
+	const ansiRegex = /\x1b\[[0-9;]*m/g;
+	const ansiCodes: string[] = [];
+	let cleanText = text;
+
+	// Extract ANSI codes
+	let match: RegExpExecArray | null;
+	// biome-ignore lint/suspicious/noAssignInExpressions: RegExp.exec pattern is idiomatic
+	while ((match = ansiRegex.exec(text)) !== null) {
+		ansiCodes.push(match[0]);
+	}
+
+	// Check if nuclear cleaning is needed
+	const needsNuclearCleaning = hasBinaryArtifacts(text);
+
+	if (needsNuclearCleaning) {
+		// Apply nuclear cleaning for binary artifacts
+		logger.warn("Binary artifacts detected, applying nuclear cleaning");
+		cleanText = nuclearCleanText(sanitizeAIResponse(text));
+	} else {
+		// Light cleaning for normal text
+		cleanText = text
+			// Remove null bytes and other control characters
+			.replace(/\0/g, "")
+			.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, "")
+			// Fix common encoding issues
+			.replace(/’/g, "'")
+			.replace(/â€"/g, "—")
+			.replace(/“/g, '"')
+			.replace(/�/g, '"')
+			.replace(/‘/g, "'")
+			.replace(/…/g, "...")
+			.replace(/é/g, "é")
+			.replace(/è/g, "è")
+			.replace(/Ã /g, "à")
+			.replace(/â/g, "â")
+			.replace(/î/g, "î")
+			.replace(/ô/g, "ô")
+			.replace(/ç/g, "ç")
+			// Fix spacing
+			.replace(/\r\n/g, "\n")
+			.replace(/\r/g, "\n")
+			.replace(/\n{4,}/g, "\n\n\n")
+			.trim();
+	}
+
+	return cleanText;
+}
+
+/**
+ * Retry logic for async operations
+ */
+export async function withRetry<T>(
+	operation: () => Promise<T>,
+	options: {
+		attempts?: number;
+		delay?: number;
+		backoff?: number;
+		onRetry?: (attempt: number, error: unknown) => void;
+	} = {},
+): Promise<T> {
+	const {
+		attempts = CONFIG.RETRY_ATTEMPTS,
+		delay = CONFIG.RETRY_DELAY,
+		backoff = 2,
+		onRetry,
+	} = options;
+
+	let lastError: unknown;
+
+	for (let attempt = 1; attempt <= attempts; attempt++) {
+		try {
+			return await operation();
+		} catch (error: unknown) {
+			lastError = error;
+
+			// Don't retry on non-recoverable errors
+			if (error instanceof GlanceError && !error.recoverable) {
+				throw error;
+			}
+
+			// Check for specific non-recoverable HTTP status codes
+			if (
+				error &&
+				typeof error === "object" &&
+				"status" in error &&
+				typeof error.status === "number" &&
+				[400, 401, 403, 404].includes(error.status)
+			) {
+				throw error;
+			}
+
+			if (attempt < attempts) {
+				const waitTime = delay * backoff ** (attempt - 1);
+
+				if (onRetry) {
+					onRetry(attempt, error);
+				} else {
+					logger.debug(
+						`Retry attempt ${attempt}/${attempts} after ${waitTime}ms`,
+					);
+				}
+
+				await new Promise((resolve) => setTimeout(resolve, waitTime));
+			}
+		}
+	}
+
+	throw lastError;
+}
+
+/**
+ * Create a spinner with consistent styling
+ */
+export function createSpinner(text: string): Ora {
+	return ora({
+		text,
+		spinner: "dots",
+		color: "cyan",
+	});
+}
+
+/**
+ * Format file size for display
+ */
+export function formatFileSize(bytes: number): string {
+	const units = ["B", "KB", "MB", "GB"];
+	let size = bytes;
+	let unitIndex = 0;
+
+	while (size >= 1024 && unitIndex < units.length - 1) {
+		size /= 1024;
+		unitIndex++;
+	}
+
+	return `${size.toFixed(2)} ${units[unitIndex]}`;
+}
+
+/**
+ * Format duration for display
+ */
+export function formatDuration(ms: number): string {
+	if (ms < 1000) {
+		return `${ms}ms`;
+	}
+
+	const seconds = Math.floor(ms / 1000);
+	const minutes = Math.floor(seconds / 60);
+
+	if (minutes > 0) {
+		return `${minutes}m ${seconds % 60}s`;
+	}
+
+	return `${seconds}s`;
+}
+
+/**
+ * Check if running in TTY environment
+ */
+export function isTTY(): boolean {
+	return process.stdout.isTTY || false;
+}
+
+/**
+ * Get terminal width
+ */
+export function getTerminalWidth(): number {
+	return process.stdout.columns || 80;
+}
+
+/**
+ * Truncate text to fit terminal width
+ */
+export function truncateToWidth(text: string, maxWidth?: number): string {
+	const width = maxWidth || getTerminalWidth() - 4; // Leave some margin
+
+	if (text.length <= width) {
+		return text;
+	}
+
+	return `${text.substring(0, width - 3)}...`;
+}
+
+/**
+ * Parse file extension for export
+ */
+export function getFileExtension(filename: string): string {
+	const parts = filename.split(".");
+	return parts.length > 1 ? (parts[parts.length - 1]?.toLowerCase() ?? "") : "";
+}
+
+/**
+ * Check if model is a premium model
+ */
+export function isPremiumModel(model: string): boolean {
+	const premiumPrefixes = ["gpt-4", "claude", "gemini-pro", "gemini-ultra"];
+	return premiumPrefixes.some((prefix) =>
+		model.toLowerCase().startsWith(prefix),
+	);
+}
+
+/**
+ * Format model name for display
+ */
+export function formatModelName(model: string): string {
+	// Add provider labels for clarity
+	if (model.startsWith("gpt")) {
+		return `${model} (OpenAI)`;
+	}
+	if (model.startsWith("gemini")) {
+		return `${model} (Google)`;
+	}
+	if (
+		model.includes("llama") ||
+		model.includes("mistral") ||
+		model.includes("phi")
+	) {
+		return `${model} (Local)`;
+	}
+	return model;
+}

package/src/cli/validators.ts

@@ -0,0 +1,176 @@
+/**
+ * Input validation utilities for Glance CLI
+ */
+
+import { LANGUAGE_MAP } from "./config";
+
+export function validateURL(urlString: string): {
+	valid: boolean;
+	error?: string;
+} {
+	try {
+		const url = new URL(urlString);
+
+		if (!["http:", "https:"].includes(url.protocol)) {
+			return {
+				valid: false,
+				error: "Only HTTP and HTTPS URLs are supported",
+			};
+		}
+
+		if (!url.hostname || url.hostname.length < 3) {
+			return {
+				valid: false,
+				error: "Invalid hostname",
+			};
+		}
+
+		return { valid: true };
+	} catch (_error) {
+		return {
+			valid: false,
+			error:
+				"Invalid URL format. Please provide a valid URL starting with http:// or https://",
+		};
+	}
+}
+
+export function validateLanguage(lang: string): {
+	valid: boolean;
+	error?: string;
+} {
+	const supportedLanguages = Object.keys(LANGUAGE_MAP);
+
+	if (!supportedLanguages.includes(lang)) {
+		return {
+			valid: false,
+			error: `Language '${lang}' is not supported. Supported languages: ${supportedLanguages.join(", ")}`,
+		};
+	}
+
+	return { valid: true };
+}
+
+export function validateMaxTokens(value: string | undefined): {
+	valid: boolean;
+	parsed?: number;
+	error?: string;
+} {
+	if (!value) {
+		return { valid: true };
+	}
+
+	const parsed = parseInt(value, 10);
+
+	if (Number.isNaN(parsed)) {
+		return {
+			valid: false,
+			error: "max-tokens must be a valid number",
+		};
+	}
+
+	if (parsed < 1 || parsed > 100000) {
+		return {
+			valid: false,
+			error: "max-tokens must be between 1 and 100000",
+		};
+	}
+
+	return { valid: true, parsed };
+}
+
+export async function validateAPIKeys(
+	provider: "openai" | "google" | "ollama",
+): Promise<{ valid: boolean; error?: string; hint?: string }> {
+	switch (provider) {
+		case "openai": {
+			const apiKey = process.env.OPENAI_API_KEY;
+			if (!apiKey) {
+				return {
+					valid: false,
+					error: "OpenAI API key not found",
+					hint: "Set your API key with: export OPENAI_API_KEY=sk-...",
+				};
+			}
+
+			if (!apiKey.startsWith("sk-")) {
+				return {
+					valid: false,
+					error: "Invalid OpenAI API key format",
+					hint: "OpenAI API keys should start with 'sk-'",
+				};
+			}
+
+			// Basic length check
+			if (apiKey.length < 40) {
+				return {
+					valid: false,
+					error: "OpenAI API key appears to be incomplete",
+					hint: "Make sure you've copied the entire API key",
+				};
+			}
+
+			return { valid: true };
+		}
+
+		case "google": {
+			const apiKey = process.env.GEMINI_API_KEY || process.env.GOOGLE_API_KEY;
+			if (!apiKey) {
+				return {
+					valid: false,
+					error: "Gemini API key not found",
+					hint: "Set your API key with: export GEMINI_API_KEY=...",
+				};
+			}
+
+			// Basic length check for Google API keys
+			if (apiKey.length < 30) {
+				return {
+					valid: false,
+					error: "Gemini API key appears to be incomplete",
+					hint: "Make sure you've copied the entire API key",
+				};
+			}
+
+			return { valid: true };
+		}
+
+		case "ollama": {
+			// Ollama doesn't require API keys, just check if it's running
+			const endpoint = process.env.OLLAMA_ENDPOINT || "http://localhost:11434";
+
+			try {
+				const controller = new AbortController();
+				const timeoutId = setTimeout(() => controller.abort(), 5000);
+
+				const response = await fetch(`${endpoint}/api/version`, {
+					signal: controller.signal,
+				});
+
+				clearTimeout(timeoutId);
+
+				if (!response.ok) {
+					return {
+						valid: false,
+						error: `Ollama is not responding at ${endpoint}`,
+						hint: "Make sure Ollama is running. Start it with: ollama serve",
+					};
+				}
+
+				return { valid: true };
+			} catch (_error) {
+				return {
+					valid: false,
+					error: `Cannot connect to Ollama at ${endpoint}`,
+					hint: "Install and start Ollama: https://ollama.ai/download",
+				};
+			}
+		}
+
+		default:
+			return {
+				valid: false,
+				error: `Unknown provider: ${provider}`,
+			};
+	}
+}

package/src/cli.ts

@@ -0,0 +1,17 @@
+#!/usr/bin/env node
+
+/**
+ * Glance CLI - Main entry point
+ *
+ * This file serves as a thin wrapper that imports and runs
+ * the modularized CLI from the cli/ directory.
+ *
+ */
+
+import { runCli } from "./cli/index";
+
+// Run the CLI
+runCli().catch((error) => {
+	console.error("Fatal error:", error);
+	process.exit(1);
+});

package/src/core/compat.ts

@@ -0,0 +1,96 @@
+/**
+ * Compatibility layer for Bun and Node.js
+ */
+
+import { execSync } from "node:child_process";
+import * as fs from "node:fs/promises";
+
+// Runtime detection
+export const isBun = typeof Bun !== "undefined";
+
+// Process arguments
+export const argv = isBun ? Bun.argv : process.argv;
+
+// Environment variables
+export const env = isBun ? Bun.env : process.env;
+
+// File operations
+export async function writeFile(
+	filePath: string,
+	content: string | Buffer,
+): Promise<void> {
+	if (isBun) {
+		await Bun.write(filePath, content);
+	} else {
+		await fs.writeFile(filePath, content);
+	}
+}
+
+export async function readFile(filePath: string): Promise<string> {
+	if (isBun) {
+		const file = Bun.file(filePath);
+		return (await file.exists()) ? await file.text() : "";
+	} else {
+		try {
+			return await fs.readFile(filePath, "utf-8");
+		} catch {
+			return "";
+		}
+	}
+}
+
+export async function readFileBuffer(filePath: string): Promise<Buffer> {
+	if (isBun) {
+		const file = Bun.file(filePath);
+		const buffer = await file.arrayBuffer();
+		return Buffer.from(buffer);
+	} else {
+		return await fs.readFile(filePath);
+	}
+}
+
+export async function fileExists(filePath: string): Promise<boolean> {
+	if (isBun) {
+		return Bun.file(filePath).exists();
+	} else {
+		try {
+			await fs.access(filePath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+}
+
+// Shell operations
+export async function shell(command: string): Promise<void> {
+	if (isBun) {
+		await Bun.$`sh -c ${command}`.quiet();
+	} else {
+		execSync(command, { stdio: "ignore" });
+	}
+}
+
+export async function mkdirp(dirPath: string): Promise<void> {
+	await fs.mkdir(dirPath, { recursive: true });
+}
+
+export async function rm(filePath: string): Promise<void> {
+	try {
+		await fs.unlink(filePath);
+	} catch {
+		// Ignore if file doesn't exist
+	}
+}
+
+export async function rmrf(dirPath: string): Promise<void> {
+	try {
+		await fs.rm(dirPath, { recursive: true, force: true });
+	} catch {
+		// Ignore if directory doesn't exist
+	}
+}
+
+export async function mv(src: string, dest: string): Promise<void> {
+	await fs.rename(src, dest);
+}