fconvert 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fconvert",
-  "version": "0.1.3",
+  "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,11 +4,11 @@ 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;
   query: string;
+  preferred: string;
   options: Array<{
     id: string;
     name: string;
@@ -86,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) {
@@ -96,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(
@@ -110,8 +117,9 @@ export async function pickOutputFormatInteractive(
 
   const payload: PickerPayload = {
     prompt: "output format",
-    query: extname(inputPath).replace(/^\./, ""),
-    options: registry.all().map((format) => ({
+    query: "",
+    preferred: extname(inputPath).replace(/^\./, ""),
+    options: formats.map((format) => ({
       id: format.id,
       name: format.name,
       extension: format.extension,
@@ -139,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;
+}

package/tools/format-picker/main.go

@@ -18,9 +18,10 @@ type option struct {
 }
 
 type payload struct {
-	Prompt  string   `json:"prompt"`
-	Query   string   `json:"query"`
-	Options []option `json:"options"`
+	Prompt    string   `json:"prompt"`
+	Query     string   `json:"query"`
+	Preferred string   `json:"preferred"`
+	Options   []option `json:"options"`
 }
 
 type scoredOption struct {
@@ -31,6 +32,7 @@ type scoredOption struct {
 type model struct {
 	prompt    string
 	query     string
+	preferred string
 	all       []option
 	filtered  []option
 	cursor    int
@@ -93,6 +95,9 @@ func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 func (m model) View() string {
 	var builder strings.Builder
 	builder.WriteString(fmt.Sprintf("%s > %s\n", m.prompt, m.query))
+	if m.query == "" && m.preferred != "" {
+		builder.WriteString(fmt.Sprintf("  hint: original extension '.%s' is ranked first\n", m.preferred))
+	}
 
 	if len(m.filtered) == 0 {
 		builder.WriteString("  no matches\n")
@@ -139,7 +144,7 @@ func (m *model) refilter() {
 	scored := make([]scoredOption, 0, len(m.all))
 
 	for _, item := range m.all {
-		score := fuzzyScore(query, item)
+		score := fuzzyScore(query, item, m.preferred)
 		if score < 0 {
 			continue
 		}
@@ -166,9 +171,19 @@ func (m *model) refilter() {
 	}
 }
 
-func fuzzyScore(query string, item option) int {
+func fuzzyScore(query string, item option, preferred string) int {
 	if query == "" {
-		return 1
+		score := 1
+		if preferred != "" {
+			normalizedPreferred := strings.ToLower(preferred)
+			if strings.EqualFold(item.Extension, normalizedPreferred) {
+				score += 25
+			}
+			if strings.EqualFold(item.ID, normalizedPreferred) {
+				score += 20
+			}
+		}
+		return score
 	}
 
 	candidate := strings.ToLower(item.ID + " " + item.Extension + " " + item.Name)
@@ -207,6 +222,16 @@ func fuzzyScore(query string, item option) int {
 	if strings.HasPrefix(strings.ToLower(item.ID), query) {
 		score += 15
 	}
+	if preferred != "" {
+		normalizedPreferred := strings.ToLower(preferred)
+		if strings.EqualFold(item.Extension, normalizedPreferred) {
+			score += 8
+		}
+		if strings.EqualFold(item.ID, normalizedPreferred) {
+			score += 6
+		}
+	}
+
 	return score
 }
 
@@ -244,9 +269,10 @@ func main() {
 	}
 
 	picker := model{
-		prompt: data.Prompt,
-		query:  data.Query,
-		all:    data.Options,
+		prompt:    data.Prompt,
+		query:     data.Query,
+		preferred: strings.TrimSpace(data.Preferred),
+		all:       data.Options,
 	}
 	picker.refilter()