fconvert 0.1.4 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fconvert",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Fast local CLI conversion tool with graph-based anything-to-anything routing",
   "type": "module",
   "main": "src/cli/main.ts",

package/src/cli/commands/convert.ts

@@ -7,10 +7,13 @@ import { ConsoleLogger } from "../../core/logger.ts";
 import type { ConvertSummary, FileFormat } from "../../core/types.ts";
 import { buildDefaultOutputPath, pickOutputFormatInteractive } from "../output-picker.ts";
 import { ConversionEngine } from "../../executor/executor.ts";
+import { Workspace } from "../../executor/workspace.ts";
 import { detectInputFormat, resolveOutputFormat } from "../../formats/detect.ts";
 import { FormatRegistry } from "../../formats/registry.ts";
 import { HandlerRegistry } from "../../handlers/registry.ts";
+import { ConversionGraph } from "../../planner/graph.ts";
 import { explainRoute } from "../../planner/explain.ts";
+import { findReachableFormats } from "../../planner/search.ts";
 
 async function outputExists(path: string): Promise<boolean> {
   try {
@@ -21,6 +24,37 @@ async function outputExists(path: string): Promise<boolean> {
   }
 }
 
+async function findSelectableOutputFormats(input: {
+  formats: FormatRegistry;
+  inputFormat: FileFormat;
+  bundle: BundleResolver;
+  logger: ConsoleLogger;
+  strict: boolean;
+  maxSteps: number;
+  timeoutMs?: number;
+}): Promise<FileFormat[]> {
+  const workspace = await Workspace.create("convert-probe-");
+  const probeHandlers = new HandlerRegistry();
+  try {
+    await probeHandlers.init({
+      workspace,
+      bundle: input.bundle,
+      logger: input.logger,
+      timeoutMs: input.timeoutMs,
+    });
+
+    const graph = new ConversionGraph(input.formats, probeHandlers.availableHandlers(), input.strict);
+    const reachable = findReachableFormats(graph, input.inputFormat.id, Math.max(1, input.maxSteps));
+    const candidates = input.formats
+      .all()
+      .filter((format) => reachable.has(format.id))
+      .sort((a, b) => a.id.localeCompare(b.id));
+    return candidates;
+  } finally {
+    await workspace.cleanup(false);
+  }
+}
+
 export async function runConvertCommand(input: {
   positionals: string[];
   options: {
@@ -54,11 +88,21 @@ export async function runConvertCommand(input: {
 
   const formats = new FormatRegistry();
   const inputFormat = detectInputFormat(inputPath, input.options.from, formats);
+  const bundle = new BundleResolver();
   let outputFormat: FileFormat;
   if (explicitOutputPath || input.options.to) {
     outputFormat = resolveOutputFormat(explicitOutputPath, input.options.to, formats);
   } else {
-    outputFormat = await pickOutputFormatInteractive(formats, inputPath);
+    const selectableFormats = await findSelectableOutputFormats({
+      formats,
+      inputFormat,
+      bundle,
+      logger,
+      strict: input.options.strict,
+      maxSteps: input.options.maxSteps,
+      timeoutMs: input.options.timeoutMs,
+    });
+    outputFormat = await pickOutputFormatInteractive(selectableFormats, inputPath);
   }
 
   const outputPath = explicitOutputPath ?? buildDefaultOutputPath(inputPath, outputFormat);
@@ -67,7 +111,6 @@ export async function runConvertCommand(input: {
     throw new CliError(`Output exists: ${outputPath}. Use --force to overwrite.`, ExitCode.InvalidArgs);
   }
 
-  const bundle = new BundleResolver();
   const handlers = new HandlerRegistry();
   const engine = new ConversionEngine(formats, handlers, bundle, logger);
 

package/src/cli/output-picker.ts

@@ -4,7 +4,6 @@ import { tmpdir } from "node:os";
 import { basename, dirname, extname, join } from "node:path";
 import { CliError, ExitCode } from "../core/errors.ts";
 import type { FileFormat } from "../core/types.ts";
-import { FormatRegistry } from "../formats/registry.ts";
 
 interface PickerPayload {
   prompt: string;
@@ -87,7 +86,7 @@ export function buildDefaultOutputPath(inputPath: string, outputFormat: FileForm
 }
 
 export async function pickOutputFormatInteractive(
-  registry: FormatRegistry,
+  formats: FileFormat[],
   inputPath: string,
 ): Promise<FileFormat> {
   if (!process.stdin.isTTY || !process.stdout.isTTY) {
@@ -97,6 +96,13 @@ export async function pickOutputFormatInteractive(
     );
   }
 
+  if (formats.length === 0) {
+    throw new CliError(
+      "No reachable output formats detected for this input with current handlers.",
+      ExitCode.UnsupportedRoute,
+    );
+  }
+
   const pickerBinary = await resolvePickerBinary();
   if (!pickerBinary) {
     throw new CliError(
@@ -113,7 +119,7 @@ export async function pickOutputFormatInteractive(
     prompt: "output format",
     query: "",
     preferred: extname(inputPath).replace(/^\./, ""),
-    options: registry.all().map((format) => ({
+    options: formats.map((format) => ({
       id: format.id,
       name: format.name,
       extension: format.extension,
@@ -141,7 +147,7 @@ export async function pickOutputFormatInteractive(
     }
 
     const chosenId = (await readFile(resultPath, "utf8")).trim();
-    const format = registry.getById(chosenId);
+    const format = formats.find((item) => item.id === chosenId);
     if (!format) {
       throw new CliError(`Picker returned unknown format: ${chosenId}`, ExitCode.InternalError);
     }

package/src/planner/search.ts

@@ -75,3 +75,45 @@ export function findRoutes(
 
   return routes.sort((a, b) => a.totalCost - b.totalCost);
 }
+
+interface ReachableState {
+  node: string;
+  steps: number;
+}
+
+export function findReachableFormats(
+  graph: ConversionGraph,
+  fromId: string,
+  maxSteps: number,
+): Set<string> {
+  const reached = new Set<string>();
+  const bestSteps = new Map<string, number>();
+  const queue: ReachableState[] = [{ node: fromId, steps: 0 }];
+
+  bestSteps.set(fromId, 0);
+
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (!current) {
+      break;
+    }
+
+    if (current.steps >= maxSteps) {
+      continue;
+    }
+
+    for (const edge of graph.outgoing(current.node)) {
+      const nextSteps = current.steps + 1;
+      const known = bestSteps.get(edge.to.id);
+      if (typeof known === "number" && known <= nextSteps) {
+        continue;
+      }
+
+      bestSteps.set(edge.to.id, nextSteps);
+      reached.add(edge.to.id);
+      queue.push({ node: edge.to.id, steps: nextSteps });
+    }
+  }
+
+  return reached;
+}