@seanmozeik/vicon 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@seanmozeik/vicon",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "AI-powered media conversion CLI — describe what you want, get the commands",
   "type": "module",
   "bin": {

package/src/index.ts

@@ -1,3 +1,5 @@
+#!/usr/bin/env bun
+
 import * as p from "@clack/prompts";
 import boxen from "boxen";
 import { generate, ValidationError } from "./lib/ai.js";
@@ -190,7 +192,8 @@ function renderToolSummary(ctx: ToolCtx): string {
 
 	if (ctx.ffmpeg.installed) {
 		const ver = ctx.ffmpeg.version ?? "?";
-		const enc = ctx.ffmpeg.encoders.length;
+		const enc =
+			ctx.ffmpeg.videoEncoders.length + ctx.ffmpeg.audioEncoders.length;
 		const dec = ctx.ffmpeg.decoders.length;
 		parts.push(
 			theme.muted(`ffmpeg ${ver} (${enc} encoders · ${dec} decoders)`),
@@ -395,13 +398,25 @@ async function handleEditCommandsAction(
 }
 
 async function handleRunAction(commands: string[]): Promise<void> {
+	const preExisting = new Set(
+		await Promise.all(
+			inferInputFiles(commands).map(async (f) => {
+				const file = Bun.file(f);
+				return (await file.exists()) ? f : null;
+			}),
+		).then((results) => results.filter((f): f is string => f !== null)),
+	);
+
 	const success = await runCommands(commands, {
 		onBefore: (cmd, i, total) => p.log.step(`▶ [${i + 1}/${total}] ${cmd}`),
 		onSuccess: () => p.log.success("All commands completed successfully."),
 		onError: (cmd, exitCode) =>
 			p.log.error(`Command exited with code ${exitCode}: ${cmd}`),
 	});
-	await runCleanup(inferInputFiles(commands));
+
+	if (success) {
+		await runCleanup([...preExisting]);
+	}
 	process.exit(success ? 0 : 1);
 }
 
@@ -417,6 +432,13 @@ async function runConversion(
 	toolSpinner.stop("Tools detected.");
 	p.log.info(renderToolSummary(ctx));
 
+	if (!ctx.ffmpeg.installed && !ctx.magick.installed) {
+		p.log.error(
+			"No media tools found. Install ffmpeg or ImageMagick and try again.",
+		);
+		process.exit(1);
+	}
+
 	let { result: currentResult, userRequest } = await generateUntilSuccess(
 		initialRequest,
 		ctx,

package/src/lib/prompt.ts

@@ -1,26 +1,63 @@
 import type { ToolContext } from "../types.js";
 
+// Common output format → required ffmpeg encoder.
+// Used to help the AI cross-reference before generating commands.
+const FORMAT_ENCODER_REF = `\
+## Output Format → Required ffmpeg Encoder
+webp      → libwebp
+hevc/h265 → libx265
+h264/mp4/mov/mkv → libx264
+vp8/webm  → libvpx
+vp9       → libvpx-vp9
+av1       → libsvtav1 or libaom-av1
+gif       → gif (built-in)
+png       → png (built-in)
+jpeg/jpg  → mjpeg (built-in)
+mp3       → libmp3lame
+aac       → aac (built-in)
+opus      → libopus
+flac      → flac (built-in)
+Use this table to identify which encoder is needed, then verify it appears in the available encoder lists before generating any command.`;
+
 export function buildSystemPrompt(ctx: ToolContext): string {
-	const ffmpegLine = ctx.ffmpeg.installed
-		? `ffmpeg ${ctx.ffmpeg.version ?? "unknown"} | encoders: [${ctx.ffmpeg.encoders.join(", ")}] | decoders: [${ctx.ffmpeg.decoders.join(", ")}]`
-		: "ffmpeg: not installed";
+	const lines: string[] = [];
+
+	lines.push("## Available Tools");
+
+	if (ctx.ffmpeg.installed) {
+		lines.push(`ffmpeg ${ctx.ffmpeg.version ?? "unknown"}`);
+		lines.push(
+			`  Video encoders: ${ctx.ffmpeg.videoEncoders.join(", ") || "none"}`,
+		);
+		lines.push(
+			`  Audio encoders: ${ctx.ffmpeg.audioEncoders.join(", ") || "none"}`,
+		);
+	} else {
+		lines.push("ffmpeg: NOT installed — do not generate ffmpeg commands");
+	}
 
-	const magickLine = ctx.magick.installed
-		? `magick ${ctx.magick.version ?? "unknown"} | formats: [${ctx.magick.formats.join(", ")}]`
-		: "magick: not installed";
+	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 = `## Environment\n${ffmpegLine}\n${magickLine}`;
+	const environment = lines.join("\n");
 
 	const rules = `## Rules
 Return ONLY valid JSON in this exact shape: { "commands": string[], "explanation": string }
 - explanation: plain prose only — no shell syntax, no backticks, no code
 - commands: complete, copy-pasteable shell strings — no placeholders, no &&, no loops
-- Only use tools that are listed as installed above
+- BEFORE generating any command: identify the required encoder/format using the reference table below, then verify it appears in the available lists above
+- 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
+- If neither tool can handle the task, return { "commands": [], "explanation": "<reason why it cannot be done with available tools>" }
 - Prefer non-destructive output: append _converted to output filenames, use -n flag to avoid overwriting
 - For batch tasks, emit one command per file
 IMPORTANT: Reply with ONLY the JSON object — no markdown fences, no extra text`;
 
-	return [environment, rules].join("\n\n");
+	return [environment, FORMAT_ENCODER_REF, rules].join("\n\n");
 }
 
 export function buildUserPrompt(request: string): string {

package/src/lib/tools.ts

@@ -13,7 +13,13 @@ async function run(cmd: string[]): Promise<string> {
 
 async function probeFfmpeg(): Promise<ToolContext["ffmpeg"]> {
 	const versionOut = await run(["ffmpeg", "-version"]);
-	if (!versionOut) return { installed: false, encoders: [], decoders: [] };
+	if (!versionOut)
+		return {
+			installed: false,
+			videoEncoders: [],
+			audioEncoders: [],
+			decoders: [],
+		};
 
 	const versionMatch = versionOut.split("\n")[0]?.match(/ffmpeg version (\S+)/);
 	const version = versionMatch?.[1];
@@ -21,21 +27,24 @@ async function probeFfmpeg(): Promise<ToolContext["ffmpeg"]> {
 	const encodersOut = await run(["ffmpeg", "-encoders"]);
 	const decodersOut = await run(["ffmpeg", "-decoders"]);
 
-	const encoders = encodersOut
-		.split("\n")
-		.slice(1)
-		.filter((l) => /^ [VAS.]+\s/.test(l))
-		.map((l) => l.trim().split(/\s+/)[1] ?? "")
-		.filter(Boolean);
+	const parseEncoderLines = (out: string) =>
+		out
+			.split("\n")
+			.filter((l) => /^ [VAS][A-Z.]{5} \S/.test(l))
+			.map((l) => ({ type: l[1], name: l.trim().split(/\s+/)[1] ?? "" }))
+			.filter((e) => e.name);
 
-	const decoders = decodersOut
-		.split("\n")
-		.slice(1)
-		.filter((l) => /^ [VAS.]+\s/.test(l))
-		.map((l) => l.trim().split(/\s+/)[1] ?? "")
-		.filter(Boolean);
+	const encoderEntries = parseEncoderLines(encodersOut);
+	const videoEncoders = encoderEntries
+		.filter((e) => e.type === "V")
+		.map((e) => e.name);
+	const audioEncoders = encoderEntries
+		.filter((e) => e.type === "A")
+		.map((e) => e.name);
+
+	const decoders = parseEncoderLines(decodersOut).map((e) => e.name);
 
-	return { installed: true, version, encoders, decoders };
+	return { installed: true, version, videoEncoders, audioEncoders, decoders };
 }
 
 async function probeMagick(): Promise<ToolContext["magick"]> {

package/src/types.ts

@@ -7,7 +7,8 @@ export interface ToolContext {
 	ffmpeg: {
 		installed: boolean;
 		version?: string;
-		encoders: string[];
+		videoEncoders: string[];
+		audioEncoders: string[];
 		decoders: string[];
 	};
 	magick: {