@seanmozeik/avicon 0.1.3

package/src/lib/ai.ts

@@ -0,0 +1,145 @@
+import type { AiResult, GenerateResult, MultiFileResult } from "../types.js";
+import type { CloudflareCredentials, AviconConfig } from "./config.js";
+
+export const CF_MODEL = "@cf/openai/gpt-oss-120b";
+export const CLAUDE_MODEL = "sonnet";
+
+export class ValidationError extends Error {
+	constructor(
+		message: string,
+		public readonly raw: string,
+	) {
+		super(message);
+		this.name = "ValidationError";
+	}
+}
+
+export function validateResponse(raw: string): AiResult {
+	const cleaned = raw
+		.trim()
+		.replace(/^```(?:json)?\n?/, "")
+		.replace(/\n?```$/, "");
+
+	let parsed: unknown;
+	try {
+		parsed = JSON.parse(cleaned);
+	} catch {
+		throw new ValidationError("Invalid JSON response from AI", raw);
+	}
+
+	const obj = parsed as {
+		multi_file?: unknown;
+		glob?: unknown;
+		commands?: unknown;
+		output_template?: unknown;
+		explanation?: unknown;
+	};
+
+	if (obj.multi_file === true) {
+		if (
+			!Array.isArray(obj.glob) ||
+			!obj.glob.every((g: unknown) => typeof g === "string") ||
+			!Array.isArray(obj.commands) ||
+			!obj.commands.every((c: unknown) => typeof c === "string") ||
+			typeof obj.output_template !== "string" ||
+			typeof obj.explanation !== "string"
+		) {
+			throw new ValidationError(
+				"Multi-file response missing required fields: glob (string[]), commands (string[]), output_template (string), explanation (string)",
+				raw,
+			);
+		}
+		return {
+			multi_file: true,
+			glob: obj.glob as string[],
+			commands: obj.commands as string[],
+			output_template: obj.output_template,
+			explanation: obj.explanation,
+		} satisfies MultiFileResult;
+	}
+
+	if (
+		!Array.isArray(obj.commands) ||
+		!obj.commands.every((c: unknown) => typeof c === "string") ||
+		typeof obj.explanation !== "string"
+	) {
+		throw new ValidationError(
+			"Response missing required fields: commands (string[]) and explanation (string)",
+			raw,
+		);
+	}
+
+	return {
+		commands: obj.commands as string[],
+		explanation: obj.explanation,
+	} satisfies GenerateResult;
+}
+
+export async function generateWithCloudflare(
+	systemPrompt: string,
+	userPrompt: string,
+	credentials: CloudflareCredentials,
+): Promise<AiResult> {
+	const response = await fetch(
+		`https://api.cloudflare.com/client/v4/accounts/${credentials.accountId}/ai/v1/chat/completions`,
+		{
+			method: "POST",
+			headers: {
+				Authorization: `Bearer ${credentials.apiToken}`,
+				"Content-Type": "application/json",
+			},
+			body: JSON.stringify({
+				model: CF_MODEL,
+				messages: [
+					{ role: "system", content: systemPrompt },
+					{ role: "user", content: userPrompt },
+				],
+				response_format: { type: "json_object" },
+				max_tokens: 2048,
+			}),
+		},
+	);
+
+	if (!response.ok) {
+		const error = await response.text();
+		throw new Error(`Cloudflare API error ${response.status}: ${error}`);
+	}
+
+	const data = (await response.json()) as {
+		choices?: { message?: { content?: string } }[];
+	};
+
+	const raw = data.choices?.[0]?.message?.content ?? "";
+	return validateResponse(raw);
+}
+
+export async function generateWithClaude(
+	systemPrompt: string,
+	userPrompt: string,
+): Promise<AiResult> {
+	const combinedPrompt = `${systemPrompt}\n\n${userPrompt}`;
+	const proc = Bun.spawn(
+		["claude", "--model", CLAUDE_MODEL, "-p", combinedPrompt],
+		{
+			stdout: "pipe",
+		},
+	);
+	const raw = (await new Response(proc.stdout).text()).trim();
+	return validateResponse(raw);
+}
+
+export async function generate(
+	systemPrompt: string,
+	userPrompt: string,
+	config: AviconConfig,
+): Promise<AiResult> {
+	if (config.defaultProvider === "cloudflare") {
+		if (!config.cloudflare) {
+			throw new Error(
+				"Cloudflare credentials not configured. Run: avicon setup",
+			);
+		}
+		return generateWithCloudflare(systemPrompt, userPrompt, config.cloudflare);
+	}
+	return generateWithClaude(systemPrompt, userPrompt);
+}

package/src/lib/clipboard.ts

@@ -0,0 +1,40 @@
+import { $ } from "bun";
+
+/**
+ * Copy text to clipboard (cross-platform)
+ * Returns true if successful, false if no clipboard tool available
+ */
+export async function copyToClipboard(text: string): Promise<boolean> {
+	// macOS
+	if (process.platform === "darwin") {
+		const proc = Bun.spawn(["pbcopy"], { stdin: "pipe" });
+		proc.stdin.write(text);
+		proc.stdin.end();
+		await proc.exited;
+		return true;
+	}
+
+	// Linux: try available clipboard tools in order of preference
+	const tools: string[][] = [
+		["xclip", "-selection", "clipboard"],
+		["xsel", "--clipboard", "--input"],
+		["wl-copy"], // Wayland
+	];
+
+	for (const cmd of tools) {
+		try {
+			const which = await $`which ${cmd[0]}`.quiet();
+			if (which.exitCode === 0) {
+				const proc = Bun.spawn(cmd, { stdin: "pipe" });
+				proc.stdin.write(text);
+				proc.stdin.end();
+				await proc.exited;
+				return true;
+			}
+		} catch {
+			// Tool not found, try next
+		}
+	}
+
+	return false;
+}

package/src/lib/config.ts

@@ -0,0 +1,83 @@
+import { CONFIG_KEY, SECRETS_SERVICE } from "./secrets.js";
+
+export type Provider = "cloudflare" | "claude";
+
+export interface CloudflareCredentials {
+	accountId: string;
+	apiToken: string;
+}
+
+export interface AviconConfig {
+	defaultProvider: Provider;
+	cloudflare?: CloudflareCredentials;
+}
+
+// Three-state cache: undefined = not yet loaded, null = nothing found, object = valid config
+let _cache: AviconConfig | null | undefined;
+
+export async function getConfig(): Promise<AviconConfig | null> {
+	if (_cache !== undefined) return _cache;
+
+	// Check env var first
+	const envVal = process.env[CONFIG_KEY];
+	if (envVal) {
+		try {
+			_cache = JSON.parse(envVal) as AviconConfig;
+			return _cache;
+		} catch {
+			// Invalid JSON in env var — fall through
+		}
+	}
+
+	// Try Bun.secrets
+	try {
+		const val = await Bun.secrets.get({
+			service: SECRETS_SERVICE,
+			name: CONFIG_KEY,
+		});
+		if (val) {
+			_cache = JSON.parse(val) as AviconConfig;
+			return _cache;
+		}
+	} catch {
+		// Secret store unavailable — fall through
+	}
+
+	_cache = null;
+	return null;
+}
+
+export async function setConfig(config: AviconConfig): Promise<void> {
+	try {
+		await Bun.secrets.set({
+			service: SECRETS_SERVICE,
+			name: CONFIG_KEY,
+			value: JSON.stringify(config),
+		});
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		if (
+			msg.toLowerCase().includes("libsecret") ||
+			msg.toLowerCase().includes("secret service")
+		) {
+			throw new Error(
+				`Failed to store config in keychain: ${msg}\n` +
+					`Install libsecret:\n` +
+					`  Ubuntu/Debian: sudo apt install libsecret-1-0 libsecret-tools\n` +
+					`  Fedora:        sudo dnf install libsecret\n` +
+					`  Arch:          sudo pacman -S libsecret`,
+			);
+		}
+		throw err;
+	}
+	_cache = config;
+}
+
+export async function deleteConfig(): Promise<void> {
+	_cache = undefined;
+	try {
+		await Bun.secrets.delete({ service: SECRETS_SERVICE, name: CONFIG_KEY });
+	} catch {
+		// Not found — no-op
+	}
+}

package/src/lib/multi.ts

@@ -0,0 +1,49 @@
+import * as path from "node:path";
+
+export async function expandGlob(patterns: string[]): Promise<string[]> {
+	const seen = new Set<string>();
+	for (const pattern of patterns) {
+		const glob = new Bun.Glob(pattern);
+		for await (const file of glob.scan(".")) {
+			seen.add(file);
+		}
+	}
+	return [...seen].sort();
+}
+
+export function resolveVars(
+	template: string,
+	vars: Record<string, string>,
+): string {
+	return template.replace(
+		/\{\{(\w+)\}\}/g,
+		(_, key) => vars[key] ?? `{{${key}}}`,
+	);
+}
+
+export function buildFileCommands(
+	file: string,
+	commandTemplates: string[],
+	outputTemplate: string,
+): string[] {
+	const dir = path.dirname(file);
+	const stem = path.basename(file, path.extname(file));
+	const input = file;
+
+	const baseVars: Record<string, string> = { input, stem, dir, output: "" };
+	const output = resolveVars(outputTemplate, baseVars);
+	const vars: Record<string, string> = { input, stem, dir, output };
+
+	return commandTemplates.map((tpl) => resolveVars(tpl, vars));
+}
+
+export function buildBatchCommands(
+	files: string[],
+	commandTemplates: string[],
+	outputTemplate: string,
+): Array<{ file: string; commands: string[] }> {
+	return files.map((file) => ({
+		file,
+		commands: buildFileCommands(file, commandTemplates, outputTemplate),
+	}));
+}

package/src/lib/prompt.ts

@@ -0,0 +1,102 @@
+import type { ToolContext } from "../types.js";
+
+export function buildSystemPrompt(ctx: ToolContext): string {
+	const lines: string[] = [];
+
+	lines.push("## Available Tools");
+
+	if (ctx.ffmpeg.installed) {
+		lines.push(`FFmpeg ${ctx.ffmpeg.version ?? "unknown"}`);
+		lines.push(`  Codecs: ${ctx.ffmpeg.codecs.join(", ") || "none"}`);
+		lines.push(`  Filters: ${ctx.ffmpeg.filters.join(", ") || "none"}`);
+		lines.push(
+			`  Bitstream filters: ${ctx.ffmpeg.bitstreamFilters.join(", ") || "none"}`,
+		);
+		lines.push(`  Formats: ${ctx.ffmpeg.formats.join(", ") || "none"}`);
+	} else {
+		lines.push("FFmpeg: NOT installed — do not generate ffmpeg commands");
+	}
+
+	if (ctx.magick.installed) {
+		lines.push(`magick ${ctx.magick.version ?? "unknown"}`);
+		lines.push(`  Formats: ${ctx.magick.formats.join(", ") || "none"}`);
+	} else {
+		lines.push("magick: NOT installed — do not generate magick commands");
+	}
+
+	const environment = lines.join("\n");
+
+	const rules = `## FFmpeg encoding defaults
+Apply these unless the user explicitly requests otherwise:
+
+Video quality — always use constant-quality mode, never omit a quality flag or use -b:v alone:
+  libx264:            -crf 23 -preset slow
+  libx265:            -crf 28 -preset slow
+  libsvtav1:          -crf 35 -preset 6
+  libvpx-vp9:         -crf 33 -b:v 0
+  h264_videotoolbox / hevc_videotoolbox: -q:v 65  (scale 1–100, higher=better quality)
+  h264_nvenc / hevc_nvenc / av1_nvenc:   -rc vbr -cq 28
+  h264_vaapi / hevc_vaapi / av1_vaapi:   -qp 28
+
+Pixel format — always add -pix_fmt yuv420p for H.264, H.265, VP9, AV1 output (required for broad device compatibility)
+
+MP4 output — always add -movflags +faststart (enables streaming before full download)
+
+Metadata — always add -map_metadata 0 to preserve source metadata (timestamps, GPS, rotation tags); omit for GIF or other formats that don't support metadata
+
+Audio — when transcoding audio, default to:
+  -c:a aac -b:a 192k -ar 48000 -ac 2   (for MP4/MOV output)
+  -c:a libopus -b:a 128k -ar 48000     (for WebM/MKV output)
+  -c:a flac                             (for lossless)
+  Honor any sample rate, bitrate, or channel count the user specifies.
+  Use -c:a copy only when the input audio codec already matches the output container
+
+Scaling — when resizing, always use scale=-2:<height> (e.g. scale=-2:720) to preserve aspect ratio with even dimensions; never use -1 (causes encoder errors on odd dimensions)
+
+Subtitles / attachments — use -sn -dn to explicitly drop subtitle and data streams unless the user asks to keep them
+
+GIF output — always use the two-step palette pipeline, never a single-command conversion:
+  Step 1 (palette):  ffmpeg -hide_banner -nostdin -i <input> -vf "fps=<fps>,scale=-2:<height>:flags=lanczos,palettegen=stats_mode=diff" /tmp/<stem>_palette.png
+  Step 2 (encode):   ffmpeg -hide_banner -nostdin -i <input> -i /tmp/<stem>_palette.png -lavfi "fps=<fps>,scale=-2:<height>:flags=lanczos [x];[x][1:v] paletteuse=dither=bayer:bayer_scale=5" <output>.gif
+  Default fps=15, height=480 unless the user specifies otherwise.
+
+## Container/codec compatibility (common cases — not exhaustive, use judgement for edge cases)
+- .mp4 / .mov  →  video: H.264, H.265, AV1   audio: AAC, MP3  (not Opus or FLAC)
+- .webm        →  video: VP8, VP9, AV1        audio: Opus, Vorbis  (not AAC)
+- .mkv         →  accepts almost any codec; good choice when unsure
+- .gif         →  no audio stream; use palette pipeline above
+- .mp3         →  audio only; use libmp3lame
+- .flac / .wav →  lossless audio only; no video
+
+## Rules
+- explanation: plain prose only — no shell syntax, no backticks, no code
+- BEFORE generating any command: choose the optimal codec and encoder from the available codecs list above for the target format, preferring hardware-accelerated encoders (e.g. h264_videotoolbox, hevc_videotoolbox) over software ones, and modern codecs (av1, hevc) over older ones when quality/efficiency matters
+- NEVER rely on FFmpeg auto-selection — always specify -c:v for video output and -c:a for audio output explicitly
+- If a required FFmpeg encoder is not available, use magick if the format is in its format list
+- Prefer non-destructive output: append _converted to output filenames, use -n flag to avoid overwriting
+
+SINGLE-FILE MODE: Use when operating on specific named file(s) or when the user provides explicit filenames.
+  Schema: { "commands": string[], "explanation": string }
+  - commands: concrete shell strings, no placeholders, no &&, no loops; may have multiple steps (e.g. transcode → encode)
+  - always include -hide_banner -nostdin in every ffmpeg command
+  - If neither tool can handle the task, return { "commands": [], "explanation": "<reason why it cannot be done with available tools>" }
+
+BATCH MODE: Use when user wants to process all files matching a pattern (e.g. "all mp4s", "every image", "all files in this folder").
+  Schema: { "multi_file": true, "glob": string[], "commands": string[], "output_template": string, "explanation": string }
+  - glob: array of glob patterns relative to cwd (e.g. ["*.mp4"])
+  - commands: template strings — each may use {{input}}, {{output}}, {{stem}}, {{dir}}; always include -hide_banner -nostdin in every ffmpeg command
+      {{input}} — path to the input file
+      {{output}} — resolved output path (from output_template)
+      {{stem}} — filename without extension (e.g. "video" from "video.mp4")
+      {{dir}} — directory of the input file
+  - output_template: e.g. "{{dir}}/{{stem}}_converted.mp4" — use {{dir}}/{{stem}} as vars, literal output extension
+  - Multiple commands per file are fine (e.g. intermediate files using /tmp/{{stem}}_raw.mkv)
+
+IMPORTANT: Reply with ONLY the JSON object — no markdown fences, no extra text`;
+
+	return [environment, rules].join("\n\n");
+}
+
+export function buildUserPrompt(request: string): string {
+	return request;
+}

package/src/lib/run.ts

@@ -0,0 +1,35 @@
+export type RunCallbacks = {
+	onBefore?: (cmd: string, index: number, total: number) => void;
+	onSuccess?: () => void;
+	onError?: (cmd: string, exitCode: number) => void;
+};
+
+/**
+ * Run commands in series via sh -c, streaming stdout/stderr to the terminal.
+ * Returns true if all commands exit 0, false on first non-zero exit.
+ */
+export async function runCommands(
+	commands: string[],
+	callbacks: RunCallbacks = {},
+): Promise<boolean> {
+	const total = commands.length;
+
+	for (const [i, cmd] of commands.entries()) {
+		callbacks.onBefore?.(cmd, i, total);
+
+		const proc = Bun.spawn(["sh", "-c", cmd], {
+			stdout: "inherit",
+			stderr: "inherit",
+		});
+
+		await proc.exited;
+
+		if (proc.exitCode !== 0) {
+			callbacks.onError?.(cmd, proc.exitCode ?? 1);
+			return false;
+		}
+	}
+
+	callbacks.onSuccess?.();
+	return true;
+}

package/src/lib/secrets.ts

@@ -0,0 +1,2 @@
+export const SECRETS_SERVICE = "com.avicon.cli";
+export const CONFIG_KEY = "AVICON_CONFIG";

package/src/lib/tools.ts

@@ -0,0 +1,112 @@
+import type { ToolContext } from "../types.js";
+
+let cached: ToolContext | undefined;
+
+async function run(cmd: string[]): Promise<string> {
+	try {
+		const proc = Bun.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+		return (await new Response(proc.stdout).text()).trim();
+	} catch {
+		return "";
+	}
+}
+
+async function probeFfmpeg(): Promise<ToolContext["ffmpeg"]> {
+	const versionOut = await run(["ffmpeg", "-version"]);
+	if (!versionOut)
+		return {
+			installed: false,
+			codecs: [],
+			filters: [],
+			bitstreamFilters: [],
+			formats: [],
+		};
+
+	const versionMatch = versionOut.split("\n")[0]?.match(/ffmpeg version (\S+)/);
+	const version = versionMatch?.[1];
+
+	const [codecsOut, filtersOut, bsfsOut, formatsOut] = await Promise.all([
+		run(["ffmpeg", "-codecs"]),
+		run(["ffmpeg", "-filters"]),
+		run(["ffmpeg", "-bsfs"]),
+		run(["ffmpeg", "-formats"]),
+	]);
+
+	// Codecs: " DEV.LS h264  H.264 ... (encoders: libx264 h264_videotoolbox)"
+	// Only keep entries where position 2 is 'E' (has at least one encoder).
+	// When an (encoders: ...) list is present, expose those names directly
+	// (they are the actual encoder IDs to pass to -c:v/-c:a).
+	// Otherwise the codec name itself is the encoder.
+	const codecs = codecsOut
+		.split("\n")
+		.filter((l) => /^ [D.]E[VASDT][I.][L.][S.] \S/.test(l))
+		.flatMap((l) => {
+			const rest = l.slice(8);
+			const name = rest.trim().split(/\s+/)[0] ?? "";
+			const encoderMatch = rest.match(/\(encoders: ([^)]+)\)/);
+			return encoderMatch?.[1] ? encoderMatch[1].trim().split(/\s+/) : [name];
+		})
+		.filter(Boolean);
+
+	// Filters: " TS scale  V->V  description"
+	const filters = filtersOut
+		.split("\n")
+		.filter((l) => /^ [T.][S.] \w/.test(l))
+		.map((l) => l.slice(4).trim().split(/\s+/)[0] ?? "")
+		.filter(Boolean);
+
+	// Bitstream filters: simple list after header
+	const bsfLines = bsfsOut.split("\n");
+	const bsfStart = bsfLines.findIndex((l) => l.includes("Bitstream filters:"));
+	const bitstreamFilters =
+		bsfStart >= 0
+			? bsfLines
+					.slice(bsfStart + 1)
+					.map((l) => l.trim())
+					.filter(Boolean)
+			: [];
+
+	// Formats: " DE  avi  AVI (Audio Video Interleaved)"
+	const formats = formatsOut
+		.split("\n")
+		.filter((l) => /^ [D ][E ][d ] \S/.test(l))
+		.map((l) => l.slice(5).trim().split(/\s+/)[0] ?? "")
+		.filter(Boolean);
+
+	return {
+		installed: true,
+		version,
+		codecs,
+		filters,
+		bitstreamFilters,
+		formats,
+	};
+}
+
+async function probeMagick(): Promise<ToolContext["magick"]> {
+	const versionOut = await run(["magick", "-version"]);
+	if (!versionOut) return { installed: false, formats: [] };
+
+	const versionMatch = versionOut
+		.split("\n")[0]
+		?.match(/Version: ImageMagick (\S+)/);
+	const version = versionMatch?.[1];
+
+	const formatsOut = await run(["magick", "-list", "format"]);
+
+	const formats = formatsOut
+		.split("\n")
+		.filter((l) => /^\s+[A-Z0-9]+\*?\s/.test(l))
+		.map((l) => l.trim().split(/\s+/)[0]?.replace("*", "") ?? "")
+		.filter(Boolean);
+
+	return { installed: true, version, formats };
+}
+
+export async function detectContext(): Promise<ToolContext> {
+	if (cached) return cached;
+
+	const [ffmpeg, magick] = await Promise.all([probeFfmpeg(), probeMagick()]);
+	cached = { ffmpeg, magick };
+	return cached;
+}

package/src/types.ts

@@ -0,0 +1,30 @@
+export interface GenerateResult {
+	commands: string[];
+	explanation: string;
+}
+
+export interface MultiFileResult {
+	multi_file: true;
+	glob: string[];
+	commands: string[];
+	output_template: string;
+	explanation: string;
+}
+
+export type AiResult = GenerateResult | MultiFileResult;
+
+export interface ToolContext {
+	ffmpeg: {
+		installed: boolean;
+		version?: string;
+		codecs: string[];
+		filters: string[];
+		bitstreamFilters: string[];
+		formats: string[];
+	};
+	magick: {
+		installed: boolean;
+		version?: string;
+		formats: string[];
+	};
+}

package/src/ui/banner.ts

@@ -0,0 +1,24 @@
+import gradient from "gradient-string";
+import { gradientColors } from "./theme.js";
+
+const bannerGradient = gradient([...gradientColors.banner]);
+
+const BANNER = `
+                       d8,                         
+                      \`8P                          
+                                                   
+   d888b8b  ?88   d8P  88b d8888b d8888b   88bd88b 
+  d8P' ?88  d88  d8P'  88Pd8P' \`Pd8P' ?88  88P' ?8b
+  88b  ,88b ?8b ,88'  d88 88b    88b  d88 d88   88P
+  \`?88P'\`88b\`?888P'  d88' \`?888P'\`?8888P'd88'   88b
+                                                   
+                                                   
+                                                   
+  `;
+
+/**
+ * Display the ASCII art banner with gradient colors
+ */
+export function showBanner(): void {
+	console.log(bannerGradient(BANNER));
+}