fconvert 0.1.0

package/src/formats/registry.ts

@@ -0,0 +1,64 @@
+import type { FileFormat, FormatDefinition } from "../core/types.ts";
+import { COMMON_FORMATS } from "./common.ts";
+import { FORMAT_ALIASES } from "./aliases.ts";
+
+export class FormatRegistry {
+  private readonly byId = new Map<string, FileFormat>();
+  private readonly byAlias = new Map<string, string>();
+  private readonly byExtension = new Map<string, string>();
+
+  constructor(definitions: FormatDefinition[] = COMMON_FORMATS) {
+    for (const definition of definitions) {
+      this.register(definition);
+    }
+
+    for (const [alias, id] of Object.entries(FORMAT_ALIASES)) {
+      this.byAlias.set(alias.toLowerCase(), id.toLowerCase());
+    }
+  }
+
+  private register(definition: FormatDefinition): void {
+    const id = definition.id.toLowerCase();
+    const aliases = (definition.aliases ?? []).map((value) => value.toLowerCase());
+
+    const fileFormat: FileFormat = {
+      id,
+      name: definition.name,
+      extension: definition.extension.toLowerCase(),
+      mime: definition.mime[0] ?? "application/octet-stream",
+      category: [...definition.category],
+      aliases,
+    };
+
+    this.byId.set(id, fileFormat);
+    this.byExtension.set(fileFormat.extension, id);
+    this.byAlias.set(id, id);
+
+    for (const extension of definition.extensions) {
+      this.byExtension.set(extension.toLowerCase(), id);
+    }
+
+    for (const alias of aliases) {
+      this.byAlias.set(alias, id);
+    }
+  }
+
+  getById(idOrAlias: string): FileFormat | undefined {
+    const normalized = idOrAlias.toLowerCase();
+    const resolved = this.byAlias.get(normalized) ?? normalized;
+    return this.byId.get(resolved);
+  }
+
+  getByExtension(extension: string): FileFormat | undefined {
+    const normalized = extension.toLowerCase();
+    const id = this.byExtension.get(normalized);
+    if (!id) {
+      return undefined;
+    }
+    return this.byId.get(id);
+  }
+
+  all(): FileFormat[] {
+    return [...this.byId.values()].sort((a, b) => a.id.localeCompare(b.id));
+  }
+}

package/src/handlers/base.ts

@@ -0,0 +1,61 @@
+import type { ArtifactRef } from "../artifacts/artifact.ts";
+import type { BundleResolver } from "../bundle/resolve.ts";
+import type { Logger } from "../core/logger.ts";
+import type { FileFormat } from "../core/types.ts";
+import type { Workspace } from "../executor/workspace.ts";
+
+export interface HandlerRule {
+  from: string | "*";
+  to: string | "*";
+  cost?: number;
+  lossless?: boolean;
+}
+
+export interface HandlerCapabilities {
+  supportsAnyInput?: boolean;
+  startupCost?: number;
+  priority?: number;
+  deterministic?: boolean;
+}
+
+export interface HandlerContext {
+  workspace: Workspace;
+  bundle: BundleResolver;
+  logger: Logger;
+  timeoutMs?: number;
+}
+
+export interface ConvertRequest {
+  input: ArtifactRef;
+  outputPath: string;
+  inputFormat: FileFormat;
+  outputFormat: FileFormat;
+}
+
+export interface HandlerResult {
+  output: ArtifactRef;
+  warnings?: string[];
+}
+
+export interface ConversionHandler {
+  readonly name: string;
+  readonly capabilities: HandlerCapabilities;
+  readonly rules: HandlerRule[];
+
+  init?(ctx: HandlerContext): Promise<void>;
+  isAvailable?(ctx: HandlerContext): Promise<boolean>;
+  convert(ctx: HandlerContext, request: ConvertRequest): Promise<HandlerResult>;
+}
+
+export interface PlannedEdge {
+  handler: ConversionHandler;
+  from: FileFormat;
+  to: FileFormat;
+  rule: HandlerRule;
+  cost: number;
+}
+
+export interface PlannedRoute {
+  edges: PlannedEdge[];
+  totalCost: number;
+}

package/src/handlers/bridges/binary.ts

@@ -0,0 +1,22 @@
+import { copyFile, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import type { ConversionHandler, ConvertRequest, HandlerContext, HandlerResult } from "../base.ts";
+import { toFileArtifact } from "../../artifacts/file.ts";
+
+export class BinaryBridgeHandler implements ConversionHandler {
+  readonly name = "binary-bridge";
+  readonly capabilities = {
+    startupCost: 1,
+    priority: 5,
+    deterministic: true,
+    supportsAnyInput: true,
+  };
+
+  readonly rules = [{ from: "*", to: "*", cost: 420, lossless: false }];
+
+  async convert(_ctx: HandlerContext, request: ConvertRequest): Promise<HandlerResult> {
+    await mkdir(dirname(request.outputPath), { recursive: true });
+    await copyFile(request.input.path, request.outputPath);
+    return { output: await toFileArtifact(request.outputPath) };
+  }
+}

package/src/handlers/bridges/text.ts

@@ -0,0 +1,127 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import type { ConversionHandler, ConvertRequest, HandlerContext, HandlerResult, HandlerRule } from "../base.ts";
+import { toFileArtifact } from "../../artifacts/file.ts";
+
+const TEXTISH = ["txt", "md", "html", "json", "xml", "yaml", "csv", "base64", "hex", "bin"];
+
+function textRules(): HandlerRule[] {
+  const rules: HandlerRule[] = [];
+  for (const from of TEXTISH) {
+    for (const to of TEXTISH) {
+      if (from === to) {
+        continue;
+      }
+      rules.push({ from, to, cost: 60, lossless: false });
+    }
+  }
+  rules.push({ from: "*", to: "base64", cost: 110, lossless: false });
+  rules.push({ from: "*", to: "hex", cost: 110, lossless: false });
+  rules.push({ from: "base64", to: "*", cost: 130, lossless: false });
+  rules.push({ from: "hex", to: "*", cost: 130, lossless: false });
+  return rules;
+}
+
+function decodeIfEncoded(inputFormat: string, bytes: Buffer): Buffer {
+  if (inputFormat === "base64") {
+    try {
+      return Buffer.from(bytes.toString("utf8").trim(), "base64");
+    } catch {
+      return bytes;
+    }
+  }
+  if (inputFormat === "hex") {
+    const normalized = bytes.toString("utf8").replace(/\s+/g, "").trim();
+    if (normalized.length % 2 !== 0) {
+      return bytes;
+    }
+    try {
+      return Buffer.from(normalized, "hex");
+    } catch {
+      return bytes;
+    }
+  }
+  return bytes;
+}
+
+function htmlEscape(value: string): string {
+  return value
+    .replaceAll("&", "&")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;")
+    .replaceAll("'", "&#39;");
+}
+
+function fromStructuredToText(inputFormat: string, text: string): string {
+  if (inputFormat === "json") {
+    try {
+      const parsed = JSON.parse(text) as Record<string, unknown>;
+      const data = parsed.data;
+      if (typeof data === "string") {
+        return data;
+      }
+    } catch {
+      return text;
+    }
+  }
+
+  if (inputFormat === "html" || inputFormat === "xml") {
+    return text.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+  }
+
+  return text;
+}
+
+export class TextBridgeHandler implements ConversionHandler {
+  readonly name = "text-bridge";
+  readonly capabilities = {
+    startupCost: 1,
+    priority: 20,
+    deterministic: true,
+  };
+
+  readonly rules: HandlerRule[] = textRules();
+
+  async convert(_ctx: HandlerContext, request: ConvertRequest): Promise<HandlerResult> {
+    const raw = Buffer.from(await readFile(request.input.path));
+    const decoded = decodeIfEncoded(request.inputFormat.id, raw);
+    const sourceText = fromStructuredToText(request.inputFormat.id, decoded.toString("utf8"));
+
+    await mkdir(dirname(request.outputPath), { recursive: true });
+
+    const target = request.outputFormat.id;
+    if (target === "bin") {
+      await writeFile(request.outputPath, decoded);
+      return { output: await toFileArtifact(request.outputPath) };
+    }
+
+    let outputText: string;
+    if (target === "base64") {
+      outputText = decoded.toString("base64");
+    } else if (target === "hex") {
+      outputText = decoded.toString("hex");
+    } else if (target === "txt") {
+      outputText = sourceText;
+    } else if (target === "json") {
+      outputText = JSON.stringify({ data: sourceText }, null, 2);
+    } else if (target === "xml") {
+      outputText = `<root><data><![CDATA[${sourceText}]]></data></root>`;
+    } else if (target === "html") {
+      outputText = `<html><body><pre>${htmlEscape(sourceText)}</pre></body></html>`;
+    } else if (target === "md") {
+      outputText = `\`\`\`text\n${sourceText}\n\`\`\``;
+    } else if (target === "yaml") {
+      const lines = sourceText.split("\n").map((line) => `  ${line}`);
+      outputText = `data: |\n${lines.join("\n")}`;
+    } else if (target === "csv") {
+      const escaped = sourceText.replaceAll('"', '""').replaceAll("\n", " ");
+      outputText = `data\n"${escaped}"\n`;
+    } else {
+      outputText = sourceText;
+    }
+
+    await writeFile(request.outputPath, outputText, "utf8");
+    return { output: await toFileArtifact(request.outputPath) };
+  }
+}

package/src/handlers/exec.ts

@@ -0,0 +1,47 @@
+import { CliError, ExitCode } from "../core/errors.ts";
+
+export interface ExecResult {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+}
+
+export async function runCommand(
+  command: string,
+  args: string[],
+  timeoutMs?: number,
+): Promise<ExecResult> {
+  const proc = Bun.spawn([command, ...args], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+
+  let timedOut = false;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  if (timeoutMs && timeoutMs > 0) {
+    timer = setTimeout(() => {
+      timedOut = true;
+      proc.kill();
+    }, timeoutMs);
+  }
+
+  const [stdoutBuf, stderrBuf, exitCode] = await Promise.all([
+    new Response(proc.stdout).arrayBuffer(),
+    new Response(proc.stderr).arrayBuffer(),
+    proc.exited,
+  ]);
+
+  if (timer) {
+    clearTimeout(timer);
+  }
+
+  if (timedOut) {
+    throw new CliError(`Command timed out: ${command}`, ExitCode.ConversionFailed);
+  }
+
+  return {
+    stdout: Buffer.from(stdoutBuf).toString("utf8"),
+    stderr: Buffer.from(stderrBuf).toString("utf8"),
+    exitCode,
+  };
+}

package/src/handlers/native/ffmpeg.ts

@@ -0,0 +1,77 @@
+import { dirname } from "node:path";
+import { mkdir } from "node:fs/promises";
+import type { HandlerContext, HandlerResult, ConversionHandler, ConvertRequest, HandlerRule } from "../base.ts";
+import { runCommand } from "../exec.ts";
+import { CliError, ExitCode } from "../../core/errors.ts";
+import { toFileArtifact } from "../../artifacts/file.ts";
+
+const AUDIO = ["wav", "mp3", "flac", "ogg"];
+const VIDEO = ["mp4", "mov", "webm", "wmv", "gif"];
+const IMAGE = ["png", "jpeg", "webp", "bmp", "tiff", "gif"];
+
+function pairRules(from: string[], to: string[], cost: number): HandlerRule[] {
+  const rules: HandlerRule[] = [];
+  for (const src of from) {
+    for (const dst of to) {
+      if (src === dst) {
+        continue;
+      }
+      rules.push({ from: src, to: dst, cost, lossless: false });
+    }
+  }
+  return rules;
+}
+
+export class FfmpegHandler implements ConversionHandler {
+  readonly name = "ffmpeg";
+  readonly capabilities = {
+    startupCost: 30,
+    priority: 90,
+    deterministic: true,
+  };
+
+  readonly rules: HandlerRule[] = [
+    ...pairRules(AUDIO, AUDIO, 15),
+    ...pairRules(VIDEO, VIDEO, 20),
+    ...pairRules(IMAGE, IMAGE, 10),
+    ...pairRules(VIDEO, AUDIO, 25),
+    ...pairRules(AUDIO, VIDEO, 70),
+    ...pairRules(VIDEO, IMAGE, 30),
+    ...pairRules(IMAGE, VIDEO, 40),
+  ];
+
+  async isAvailable(ctx: HandlerContext): Promise<boolean> {
+    const resolved = await ctx.bundle.resolveBinary("ffmpeg");
+    return Boolean(resolved);
+  }
+
+  async convert(ctx: HandlerContext, request: ConvertRequest): Promise<HandlerResult> {
+    const ffmpeg = await ctx.bundle.mustResolveBinary("ffmpeg");
+    await mkdir(dirname(request.outputPath), { recursive: true });
+
+    const args = [
+      "-y",
+      "-hide_banner",
+      "-loglevel",
+      "error",
+      "-i",
+      request.input.path,
+    ];
+
+    if (request.outputFormat.category.includes("image")) {
+      args.push("-frames:v", "1");
+    }
+
+    args.push(request.outputPath);
+    const result = await runCommand(ffmpeg, args, ctx.timeoutMs);
+
+    if (result.exitCode !== 0) {
+      throw new CliError(
+        `ffmpeg failed (${request.inputFormat.id} -> ${request.outputFormat.id}): ${result.stderr || result.stdout}`,
+        ExitCode.ConversionFailed,
+      );
+    }
+
+    return { output: await toFileArtifact(request.outputPath) };
+  }
+}

package/src/handlers/native/imagemagick.ts

@@ -0,0 +1,65 @@
+import { dirname } from "node:path";
+import { mkdir } from "node:fs/promises";
+import type { ConversionHandler, ConvertRequest, HandlerContext, HandlerResult, HandlerRule } from "../base.ts";
+import { runCommand } from "../exec.ts";
+import { CliError, ExitCode } from "../../core/errors.ts";
+import { toFileArtifact } from "../../artifacts/file.ts";
+
+const IMAGE_DOC = ["png", "jpeg", "webp", "bmp", "tiff", "gif", "svg", "pdf"];
+
+function imageRules(): HandlerRule[] {
+  const rules: HandlerRule[] = [];
+  for (const from of IMAGE_DOC) {
+    for (const to of IMAGE_DOC) {
+      if (from === to) {
+        continue;
+      }
+      rules.push({ from, to, cost: 18, lossless: false });
+    }
+  }
+  return rules;
+}
+
+export class ImageMagickHandler implements ConversionHandler {
+  readonly name = "imagemagick";
+  readonly capabilities = {
+    startupCost: 20,
+    priority: 80,
+    deterministic: true,
+  };
+
+  readonly rules: HandlerRule[] = imageRules();
+
+  private async resolveMagick(ctx: HandlerContext): Promise<string | undefined> {
+    const magick = await ctx.bundle.resolveBinary("magick");
+    if (magick) {
+      return magick;
+    }
+    return ctx.bundle.resolveBinary("convert");
+  }
+
+  async isAvailable(ctx: HandlerContext): Promise<boolean> {
+    const executable = await this.resolveMagick(ctx);
+    return Boolean(executable);
+  }
+
+  async convert(ctx: HandlerContext, request: ConvertRequest): Promise<HandlerResult> {
+    const magick = await this.resolveMagick(ctx);
+    if (!magick) {
+      throw new CliError("ImageMagick executable not found", ExitCode.EnvironmentError);
+    }
+
+    await mkdir(dirname(request.outputPath), { recursive: true });
+
+    const args = [request.input.path, request.outputPath];
+    const result = await runCommand(magick, args, ctx.timeoutMs);
+    if (result.exitCode !== 0) {
+      throw new CliError(
+        `ImageMagick failed (${request.inputFormat.id} -> ${request.outputFormat.id}): ${result.stderr || result.stdout}`,
+        ExitCode.ConversionFailed,
+      );
+    }
+
+    return { output: await toFileArtifact(request.outputPath) };
+  }
+}

package/src/handlers/native/pandoc.ts

@@ -0,0 +1,66 @@
+import { dirname } from "node:path";
+import { mkdir } from "node:fs/promises";
+import type { ConversionHandler, ConvertRequest, HandlerContext, HandlerResult, HandlerRule } from "../base.ts";
+import { runCommand } from "../exec.ts";
+import { CliError, ExitCode } from "../../core/errors.ts";
+import { toFileArtifact } from "../../artifacts/file.ts";
+
+const DOC_TEXT_DATA = [
+  "txt",
+  "md",
+  "html",
+  "json",
+  "xml",
+  "yaml",
+  "csv",
+  "pdf",
+  "docx",
+  "pptx",
+  "xlsx",
+];
+
+function pandocRules(): HandlerRule[] {
+  const rules: HandlerRule[] = [];
+  for (const from of DOC_TEXT_DATA) {
+    for (const to of DOC_TEXT_DATA) {
+      if (from === to) {
+        continue;
+      }
+      rules.push({ from, to, cost: 26, lossless: false });
+    }
+  }
+  return rules;
+}
+
+export class PandocHandler implements ConversionHandler {
+  readonly name = "pandoc";
+  readonly capabilities = {
+    startupCost: 40,
+    priority: 85,
+    deterministic: true,
+  };
+
+  readonly rules: HandlerRule[] = pandocRules();
+
+  async isAvailable(ctx: HandlerContext): Promise<boolean> {
+    const resolved = await ctx.bundle.resolveBinary("pandoc");
+    return Boolean(resolved);
+  }
+
+  async convert(ctx: HandlerContext, request: ConvertRequest): Promise<HandlerResult> {
+    const pandoc = await ctx.bundle.mustResolveBinary("pandoc");
+    await mkdir(dirname(request.outputPath), { recursive: true });
+
+    const args = [request.input.path, "-o", request.outputPath];
+    const result = await runCommand(pandoc, args, ctx.timeoutMs);
+
+    if (result.exitCode !== 0) {
+      throw new CliError(
+        `pandoc failed (${request.inputFormat.id} -> ${request.outputFormat.id}): ${result.stderr || result.stdout}`,
+        ExitCode.ConversionFailed,
+      );
+    }
+
+    return { output: await toFileArtifact(request.outputPath) };
+  }
+}

package/src/handlers/native/sevenzip.ts

@@ -0,0 +1,115 @@
+import { copyFile, mkdir, readdir, rm, stat, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import type { ConversionHandler, ConvertRequest, HandlerContext, HandlerResult, HandlerRule } from "../base.ts";
+import { runCommand } from "../exec.ts";
+import { CliError, ExitCode } from "../../core/errors.ts";
+import { toFileArtifact } from "../../artifacts/file.ts";
+
+const ARCHIVES = new Set(["zip", "tar", "7z"]);
+
+async function findFirstFile(root: string): Promise<string | undefined> {
+  const entries = await readdir(root, { withFileTypes: true });
+  for (const entry of entries) {
+    const candidate = join(root, entry.name);
+    if (entry.isFile()) {
+      return candidate;
+    }
+    if (entry.isDirectory()) {
+      const nested = await findFirstFile(candidate);
+      if (nested) {
+        return nested;
+      }
+    }
+  }
+  return undefined;
+}
+
+function sevenZipRules(): HandlerRule[] {
+  return [
+    { from: "*", to: "zip", cost: 90, lossless: false },
+    { from: "*", to: "tar", cost: 90, lossless: false },
+    { from: "*", to: "7z", cost: 95, lossless: false },
+    { from: "zip", to: "*", cost: 140, lossless: false },
+    { from: "tar", to: "*", cost: 140, lossless: false },
+    { from: "7z", to: "*", cost: 145, lossless: false },
+  ];
+}
+
+export class SevenZipHandler implements ConversionHandler {
+  readonly name = "7zip";
+  readonly capabilities = {
+    startupCost: 15,
+    priority: 60,
+    deterministic: true,
+    supportsAnyInput: true,
+  };
+
+  readonly rules: HandlerRule[] = sevenZipRules();
+
+  private async resolve7z(ctx: HandlerContext): Promise<string | undefined> {
+    const candidates = ["7zz", "7z"];
+    for (const candidate of candidates) {
+      const resolved = await ctx.bundle.resolveBinary(candidate);
+      if (resolved) {
+        return resolved;
+      }
+    }
+    return undefined;
+  }
+
+  async isAvailable(ctx: HandlerContext): Promise<boolean> {
+    const binary = await this.resolve7z(ctx);
+    return Boolean(binary);
+  }
+
+  async convert(ctx: HandlerContext, request: ConvertRequest): Promise<HandlerResult> {
+    const sevenZip = await this.resolve7z(ctx);
+    if (!sevenZip) {
+      throw new CliError("7zip executable not found", ExitCode.EnvironmentError);
+    }
+
+    await mkdir(dirname(request.outputPath), { recursive: true });
+    await rm(request.outputPath, { force: true });
+
+    const toArchive = ARCHIVES.has(request.outputFormat.id);
+    const fromArchive = ARCHIVES.has(request.inputFormat.id);
+
+    if (toArchive) {
+      const archiveType = request.outputFormat.id;
+      const args = ["a", "-y", `-t${archiveType}`, request.outputPath, request.input.path];
+      const result = await runCommand(sevenZip, args, ctx.timeoutMs);
+      if (result.exitCode !== 0) {
+        throw new CliError(`7zip archive creation failed: ${result.stderr || result.stdout}`, ExitCode.ConversionFailed);
+      }
+      return { output: await toFileArtifact(request.outputPath) };
+    }
+
+    if (fromArchive) {
+      const extractDir = join(ctx.workspace.outputDir, `extract-${Date.now()}`);
+      await mkdir(extractDir, { recursive: true });
+      const args = ["x", "-y", request.input.path, `-o${extractDir}`];
+      const result = await runCommand(sevenZip, args, ctx.timeoutMs);
+      if (result.exitCode !== 0) {
+        throw new CliError(`7zip extraction failed: ${result.stderr || result.stdout}`, ExitCode.ConversionFailed);
+      }
+
+      const first = await findFirstFile(extractDir);
+      if (!first) {
+        await writeFile(request.outputPath, new Uint8Array());
+      } else {
+        const stats = await stat(first);
+        if (stats.isFile()) {
+          await copyFile(first, request.outputPath);
+        } else {
+          await writeFile(request.outputPath, new Uint8Array());
+        }
+      }
+      return { output: await toFileArtifact(request.outputPath) };
+    }
+
+    throw new CliError(
+      `7zip cannot convert ${request.inputFormat.id} -> ${request.outputFormat.id}`,
+      ExitCode.ConversionFailed,
+    );
+  }
+}