fconvert 0.1.4 → 0.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fconvert",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "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;
+}

package/tools/format-picker/go.mod

@@ -2,11 +2,13 @@ module github.com/timmy6942025/convert/tools/format-picker
 
 go 1.22
 
-require github.com/charmbracelet/bubbletea v1.3.4
+require (
+	github.com/charmbracelet/bubbletea v1.3.4
+	github.com/charmbracelet/lipgloss v1.0.0
+)
 
 require (
 	github.com/aymanbagabas/go-osc52/v2 v2.0.1 // indirect
-	github.com/charmbracelet/lipgloss v1.0.0 // indirect
 	github.com/charmbracelet/x/ansi v0.8.0 // indirect
 	github.com/charmbracelet/x/term v0.2.1 // indirect
 	github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f // indirect

package/tools/format-picker/main.go

@@ -9,6 +9,7 @@ import (
 	"strings"
 
 	tea "github.com/charmbracelet/bubbletea"
+	"github.com/charmbracelet/lipgloss"
 )
 
 type option struct {
@@ -42,6 +43,33 @@ type model struct {
 	height    int
 }
 
+var (
+	frameStyle = lipgloss.NewStyle().
+			Padding(0, 1)
+
+	headerStyle = lipgloss.NewStyle().
+			Bold(true)
+
+	promptStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.AdaptiveColor{Light: "241", Dark: "248"})
+
+	hintStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.AdaptiveColor{Light: "245", Dark: "240"})
+
+	selectedStyle = lipgloss.NewStyle().
+			Bold(true).
+			Foreground(lipgloss.AdaptiveColor{Light: "39", Dark: "117"})
+
+	rowStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.AdaptiveColor{Light: "250", Dark: "252"})
+
+	footerStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.AdaptiveColor{Light: "245", Dark: "240"})
+
+	emptyStyle = lipgloss.NewStyle().
+			Foreground(lipgloss.AdaptiveColor{Light: "203", Dark: "210"})
+)
+
 func (m model) Init() tea.Cmd {
 	return nil
 }
@@ -94,15 +122,19 @@ 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))
+	line := fmt.Sprintf("%s > %s", promptStyle.Render(m.prompt), m.query)
+	builder.WriteString(headerStyle.Render(line))
+	builder.WriteString("\n")
 	if m.query == "" && m.preferred != "" {
-		builder.WriteString(fmt.Sprintf("  hint: original extension '.%s' is ranked first\n", m.preferred))
+		builder.WriteString(hintStyle.Render(fmt.Sprintf("hint: original extension '.%s' is ranked first", m.preferred)))
+		builder.WriteString("\n")
 	}
 
 	if len(m.filtered) == 0 {
-		builder.WriteString("  no matches\n")
-		builder.WriteString("  enter to keep typing, esc to cancel")
-		return builder.String()
+		builder.WriteString(emptyStyle.Render("no matches"))
+		builder.WriteString("\n")
+		builder.WriteString(footerStyle.Render("keys: type to search, backspace delete, esc cancel"))
+		return frameStyle.Render(builder.String())
 	}
 
 	maxRows := 8
@@ -128,15 +160,26 @@ func (m model) View() string {
 
 	for index := start; index < end; index++ {
 		prefix := "  "
+		style := rowStyle
 		if index == m.cursor {
 			prefix = "> "
+			style = selectedStyle
 		}
 		item := m.filtered[index]
-		builder.WriteString(fmt.Sprintf("%s%-10s .%-6s %s\n", prefix, item.ID, item.Extension, item.Name))
+		line := fmt.Sprintf("%s%-10s .%-6s %s", prefix, item.ID, item.Extension, item.Name)
+		builder.WriteString(style.Render(line))
+		builder.WriteString("\n")
 	}
 
-	builder.WriteString("  enter select  esc cancel")
-	return builder.String()
+	status := fmt.Sprintf("%d shown / %d total", len(m.filtered), len(m.all))
+	if len(m.filtered) != len(m.all) {
+		status = fmt.Sprintf("%d matches / %d total", len(m.filtered), len(m.all))
+	}
+	builder.WriteString(footerStyle.Render(status))
+	builder.WriteString("\n")
+	builder.WriteString(footerStyle.Render("keys: up/down move, enter select, esc cancel"))
+
+	return frameStyle.Render(builder.String())
 }
 
 func (m *model) refilter() {
@@ -249,6 +292,10 @@ func readPayload(path string) (payload, error) {
 	if data.Prompt == "" {
 		data.Prompt = "output format"
 	}
+	if data.Query != "" {
+		data.Query = strings.TrimSpace(data.Query)
+	}
+	data.Prompt = strings.TrimSpace(data.Prompt)
 	return data, nil
 }