fconvert 0.1.0 → 0.1.1

package/README.md

@@ -1,4 +1,4 @@
-# convert
+# fconvert
 
 Fast local CLI conversion tool with graph-based anything-to-anything routing.
 
@@ -12,13 +12,16 @@ bun run convert formats
 ## Commands
 
 ```bash
-bun run convert <input> <output>
+bun run convert <input> [output]
 bun run convert route <input> --to <format>
 bun run convert formats
 bun run convert handlers
 bun run convert doctor
 ```
 
+If you omit output and `--to`, an interactive Bubble Tea fuzzy picker appears so you can select the output format.
+The output file defaults to the input basename with the selected extension.
+
 ## Useful flags
 
 ```bash
@@ -42,6 +45,7 @@ bun run build
 ```
 
 Compiled binary is written to `dist/convert`.
+The Bubble Tea picker helper is written to `dist/fconvert-picker`.
 
 ## Project structure
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fconvert",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Fast local CLI conversion tool with graph-based anything-to-anything routing",
   "type": "module",
   "main": "src/cli/main.ts",
@@ -9,9 +9,12 @@
     "convert": "bun run src/cli/main.ts",
     "test": "bun test",
     "typecheck": "bunx tsc --noEmit",
-    "build": "bun build src/cli/main.ts --compile --outfile dist/convert"
+    "build:cli": "bun build src/cli/main.ts --compile --outfile dist/convert",
+    "build:picker": "go build -C tools/format-picker -o ../../dist/fconvert-picker .",
+    "build": "bun run build:cli && bun run build:picker"
   },
   "bin": {
+    "fconvert": "dist/convert",
     "convert": "dist/convert"
   },
   "devDependencies": {
@@ -20,6 +23,12 @@
   "peerDependencies": {
     "typescript": "^5"
   },
-  "keywords": ["convert", "converter", "ffmpeg", "pandoc", "cli"],
+  "keywords": [
+    "convert",
+    "converter",
+    "ffmpeg",
+    "pandoc",
+    "cli"
+  ],
   "license": "MIT"
 }

package/src/cli/commands/convert.ts

@@ -4,7 +4,8 @@ import { BundleResolver } from "../../bundle/resolve.ts";
 import { buildPlanOptions } from "../../core/config.ts";
 import { CliError, ExitCode } from "../../core/errors.ts";
 import { ConsoleLogger } from "../../core/logger.ts";
-import type { ConvertSummary } from "../../core/types.ts";
+import type { ConvertSummary, FileFormat } from "../../core/types.ts";
+import { buildDefaultOutputPath, pickOutputFormatInteractive } from "../output-picker.ts";
 import { ConversionEngine } from "../../executor/executor.ts";
 import { detectInputFormat, resolveOutputFormat } from "../../formats/detect.ts";
 import { FormatRegistry } from "../../formats/registry.ts";
@@ -42,24 +43,30 @@ export async function runConvertCommand(input: {
 
   const inputPath = input.positionals[0];
   const positionalOutput = input.positionals[1];
-  const outputPath = input.options.output ?? positionalOutput;
+  const explicitOutputPath = input.options.output ?? positionalOutput;
 
   if (!inputPath) {
-    throw new CliError("Usage: convert <input> <output> [--from fmt] [--to fmt]", ExitCode.InvalidArgs);
+    throw new CliError(
+      "Usage: convert <input> [output] [--from fmt] [--to fmt]",
+      ExitCode.InvalidArgs,
+    );
   }
 
-  if (!outputPath) {
-    throw new CliError("Missing output path. Provide <output> or --output", ExitCode.InvalidArgs);
+  const formats = new FormatRegistry();
+  const inputFormat = detectInputFormat(inputPath, input.options.from, formats);
+  let outputFormat: FileFormat;
+  if (explicitOutputPath || input.options.to) {
+    outputFormat = resolveOutputFormat(explicitOutputPath, input.options.to, formats);
+  } else {
+    outputFormat = await pickOutputFormatInteractive(formats, inputPath);
   }
 
+  const outputPath = explicitOutputPath ?? buildDefaultOutputPath(inputPath, outputFormat);
+
   if ((await outputExists(outputPath)) && !input.options.force) {
     throw new CliError(`Output exists: ${outputPath}. Use --force to overwrite.`, ExitCode.InvalidArgs);
   }
 
-  const formats = new FormatRegistry();
-  const inputFormat = detectInputFormat(inputPath, input.options.from, formats);
-  const outputFormat = resolveOutputFormat(outputPath, input.options.to, formats);
-
   const bundle = new BundleResolver();
   const handlers = new HandlerRegistry();
   const engine = new ConversionEngine(formats, handlers, bundle, logger);

package/src/cli/main.ts

@@ -9,11 +9,11 @@ import { CliError, ExitCode } from "../core/errors.ts";
 import { parseArgs } from "./parse.ts";
 
 function printUsage(): void {
-  console.log("convert <input> <output> [--from fmt] [--to fmt]");
-  console.log("convert route <input> --to <format>");
-  console.log("convert formats");
-  console.log("convert handlers");
-  console.log("convert doctor");
+  console.log("fconvert <input> [output] [--from fmt] [--to fmt]");
+  console.log("fconvert route <input> --to <format>");
+  console.log("fconvert formats");
+  console.log("fconvert handlers");
+  console.log("fconvert doctor");
 }
 
 async function main(): Promise<void> {

package/src/cli/output-picker.ts

@@ -0,0 +1,135 @@
+import { constants as fsConstants } from "node:fs";
+import { access, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+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;
+  options: Array<{
+    id: string;
+    name: string;
+    extension: string;
+  }>;
+}
+
+function withExecutableSuffix(path: string): string {
+  if (process.platform === "win32") {
+    return path.endsWith(".exe") ? path : `${path}.exe`;
+  }
+  return path;
+}
+
+async function pathExists(path: string): Promise<boolean> {
+  try {
+    await access(path, fsConstants.F_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function resolvePickerBinary(): Promise<string | undefined> {
+  const envPath = process.env.FCONVERT_PICKER_BIN;
+  if (envPath && (await pathExists(envPath))) {
+    return envPath;
+  }
+
+  const argv0Dir = dirname(Bun.argv[0] ?? process.cwd());
+  const argv1Dir = dirname(Bun.argv[1] ?? process.cwd());
+
+  const candidates = [
+    join(process.cwd(), "dist", "fconvert-picker"),
+    join(argv0Dir, "fconvert-picker"),
+    join(argv0Dir, "dist", "fconvert-picker"),
+    join(argv1Dir, "..", "dist", "fconvert-picker"),
+  ].map(withExecutableSuffix);
+
+  for (const candidate of candidates) {
+    if (await pathExists(candidate)) {
+      return candidate;
+    }
+  }
+
+  const inPath = Bun.which("fconvert-picker");
+  if (inPath) {
+    return inPath;
+  }
+
+  return undefined;
+}
+
+export function buildDefaultOutputPath(inputPath: string, outputFormat: FileFormat): string {
+  const inputDirectory = dirname(inputPath);
+  const inputName = basename(inputPath);
+  const currentExtension = extname(inputName);
+  const baseName = currentExtension.length > 0 ? inputName.slice(0, -currentExtension.length) : inputName;
+  return join(inputDirectory, `${baseName}.${outputFormat.extension}`);
+}
+
+export async function pickOutputFormatInteractive(
+  registry: FormatRegistry,
+  inputPath: string,
+): Promise<FileFormat> {
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new CliError(
+      "No output format provided and terminal is not interactive. Pass <output> or --to.",
+      ExitCode.InvalidArgs,
+    );
+  }
+
+  const pickerBinary = await resolvePickerBinary();
+  if (!pickerBinary) {
+    throw new CliError(
+      "Output picker binary not found. Build it with 'bun run build:picker' or pass --to.",
+      ExitCode.EnvironmentError,
+    );
+  }
+
+  const tempRoot = await mkdtemp(join(tmpdir(), "fconvert-picker-"));
+  const optionsPath = join(tempRoot, "options.json");
+  const resultPath = join(tempRoot, "result.txt");
+
+  const payload: PickerPayload = {
+    prompt: "output format",
+    query: extname(inputPath).replace(/^\./, ""),
+    options: registry.all().map((format) => ({
+      id: format.id,
+      name: format.name,
+      extension: format.extension,
+    })),
+  };
+
+  try {
+    await writeFile(optionsPath, JSON.stringify(payload), "utf8");
+
+    const processHandle = Bun.spawn(
+      [pickerBinary, "--options", optionsPath, "--result", resultPath],
+      {
+        stdin: "inherit",
+        stdout: "inherit",
+        stderr: "inherit",
+      },
+    );
+
+    const exitCode = await processHandle.exited;
+    if (exitCode === 130) {
+      throw new CliError("Output format selection cancelled", ExitCode.InvalidArgs);
+    }
+    if (exitCode !== 0) {
+      throw new CliError(`Output picker exited with code ${exitCode}`, ExitCode.InternalError);
+    }
+
+    const chosenId = (await readFile(resultPath, "utf8")).trim();
+    const format = registry.getById(chosenId);
+    if (!format) {
+      throw new CliError(`Picker returned unknown format: ${chosenId}`, ExitCode.InternalError);
+    }
+    return format;
+  } finally {
+    await rm(tempRoot, { recursive: true, force: true });
+  }
+}

package/test/unit/output-picker.test.ts

@@ -0,0 +1,15 @@
+import { expect, test } from "bun:test";
+import { buildDefaultOutputPath } from "../../src/cli/output-picker.ts";
+
+test("buildDefaultOutputPath replaces extension with selected format", () => {
+  const path = buildDefaultOutputPath("/tmp/sample.input.txt", {
+    id: "json",
+    name: "JSON",
+    extension: "json",
+    mime: "application/json",
+    category: ["data", "text"],
+    aliases: [],
+  });
+
+  expect(path).toBe("/tmp/sample.input.json");
+});

package/tools/format-picker/go.mod

@@ -0,0 +1,24 @@
+module github.com/timmy6942025/convert/tools/format-picker
+
+go 1.22
+
+require github.com/charmbracelet/bubbletea v1.3.4
+
+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
+	github.com/lucasb-eyer/go-colorful v1.2.0 // indirect
+	github.com/mattn/go-isatty v0.0.20 // indirect
+	github.com/mattn/go-localereader v0.0.1 // indirect
+	github.com/mattn/go-runewidth v0.0.16 // indirect
+	github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 // indirect
+	github.com/muesli/cancelreader v0.2.2 // indirect
+	github.com/muesli/termenv v0.15.2 // indirect
+	github.com/rivo/uniseg v0.4.7 // indirect
+	golang.org/x/sync v0.11.0 // indirect
+	golang.org/x/sys v0.30.0 // indirect
+	golang.org/x/text v0.3.8 // indirect
+)

package/tools/format-picker/go.sum

@@ -0,0 +1,37 @@
+github.com/aymanbagabas/go-osc52/v2 v2.0.1 h1:HwpRHbFMcZLEVr42D4p7XBqjyuxQH5SMiErDT4WkJ2k=
+github.com/aymanbagabas/go-osc52/v2 v2.0.1/go.mod h1:uYgXzlJ7ZpABp8OJ+exZzJJhRNQ2ASbcXHWsFqH8hp8=
+github.com/charmbracelet/bubbletea v1.3.4 h1:kCg7B+jSCFPLYRA52SDZjr51kG/fMUEoPoZrkaDHyoI=
+github.com/charmbracelet/bubbletea v1.3.4/go.mod h1:dtcUCyCGEX3g9tosuYiut3MXgY/Jsv9nKVdibKKRRXo=
+github.com/charmbracelet/lipgloss v1.0.0 h1:O7VkGDvqEdGi93X+DeqsQ7PKHDgtQfF8j8/O2qFMQNg=
+github.com/charmbracelet/lipgloss v1.0.0/go.mod h1:U5fy9Z+C38obMs+T+tJqst9VGzlOYGj4ri9reL3qUlo=
+github.com/charmbracelet/x/ansi v0.8.0 h1:9GTq3xq9caJW8ZrBTe0LIe2fvfLR/bYXKTx2llXn7xE=
+github.com/charmbracelet/x/ansi v0.8.0/go.mod h1:wdYl/ONOLHLIVmQaxbIYEC/cRKOQyjTkowiI4blgS9Q=
+github.com/charmbracelet/x/term v0.2.1 h1:AQeHeLZ1OqSXhrAWpYUtZyX1T3zVxfpZuEQMIQaGIAQ=
+github.com/charmbracelet/x/term v0.2.1/go.mod h1:oQ4enTYFV7QN4m0i9mzHrViD7TQKvNEEkHUMCmsxdUg=
+github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
+github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
+github.com/lucasb-eyer/go-colorful v1.2.0 h1:1nnpGOrhyZZuNyfu1QjKiUICQ74+3FNCN69Aj6K7nkY=
+github.com/lucasb-eyer/go-colorful v1.2.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
+github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=
+github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
+github.com/mattn/go-localereader v0.0.1 h1:ygSAOl7ZXTx4RdPYinUpg6W99U8jWvWi9Ye2JC/oIi4=
+github.com/mattn/go-localereader v0.0.1/go.mod h1:8fBrzywKY7BI3czFoHkuzRoWE9C+EiG4R1k4Cjx5p88=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6 h1:ZK8zHtRHOkbHy6Mmr5D264iyp3TiX5OmNcI5cIARiQI=
+github.com/muesli/ansi v0.0.0-20230316100256-276c6243b2f6/go.mod h1:CJlz5H+gyd6CUWT45Oy4q24RdLyn7Md9Vj2/ldJBSIo=
+github.com/muesli/cancelreader v0.2.2 h1:3I4Kt4BQjOR54NavqnDogx/MIoWBFa0StPA8ELUXHmA=
+github.com/muesli/cancelreader v0.2.2/go.mod h1:3XuTXfFS2VjM+HTLZY9Ak0l6eUKfijIfMUZ4EgX0QYo=
+github.com/muesli/termenv v0.15.2 h1:GohcuySI0QmI3wN8Ok9PtKGkgkFIk7y6Vpb5PvrY+Wo=
+github.com/muesli/termenv v0.15.2/go.mod h1:Epx+iuz8sNs7mNKhxzH4fWXGNpZwUaJKRS1noLXviQ8=
+github.com/rivo/uniseg v0.2.0/go.mod h1:J6wj4VEh+S6ZtnVlnTBMWIodfgj8LQOQFoIToxlJtxc=
+github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
+github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
+golang.org/x/sync v0.11.0 h1:GGz8+XQP4FvTTrjZPzNKTMFtSXH80RAzG+5ghFPgK9w=
+golang.org/x/sync v0.11.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20210809222454-d867a43fc93e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.30.0 h1:QjkSwP/36a20jFYWkSue1YwXzLmsV5Gfq7Eiy72C1uc=
+golang.org/x/sys v0.30.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/text v0.3.8 h1:nAL+RVCQ9uMn3vJZbV+MRnydTJFPf8qqY42YiA6MrqY=
+golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ=

package/tools/format-picker/main.go

@@ -0,0 +1,274 @@
+package main
+
+import (
+	"encoding/json"
+	"flag"
+	"fmt"
+	"os"
+	"sort"
+	"strings"
+
+	tea "github.com/charmbracelet/bubbletea"
+)
+
+type option struct {
+	ID        string `json:"id"`
+	Name      string `json:"name"`
+	Extension string `json:"extension"`
+}
+
+type payload struct {
+	Prompt  string   `json:"prompt"`
+	Query   string   `json:"query"`
+	Options []option `json:"options"`
+}
+
+type scoredOption struct {
+	option option
+	score  int
+}
+
+type model struct {
+	prompt    string
+	query     string
+	all       []option
+	filtered  []option
+	cursor    int
+	selected  *option
+	cancelled bool
+	width     int
+	height    int
+}
+
+func (m model) Init() tea.Cmd {
+	return nil
+}
+
+func (m model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
+	switch msg := msg.(type) {
+	case tea.WindowSizeMsg:
+		m.width = msg.Width
+		m.height = msg.Height
+		return m, nil
+	case tea.KeyMsg:
+		switch msg.String() {
+		case "ctrl+c", "esc":
+			m.cancelled = true
+			return m, tea.Quit
+		case "enter":
+			if len(m.filtered) == 0 {
+				return m, nil
+			}
+			selected := m.filtered[m.cursor]
+			m.selected = &selected
+			return m, tea.Quit
+		case "up", "k", "ctrl+p":
+			if m.cursor > 0 {
+				m.cursor--
+			}
+			return m, nil
+		case "down", "j", "ctrl+n":
+			if m.cursor < len(m.filtered)-1 {
+				m.cursor++
+			}
+			return m, nil
+		case "backspace", "ctrl+h":
+			if len(m.query) == 0 {
+				return m, nil
+			}
+			m.query = m.query[:len(m.query)-1]
+			m.refilter()
+			return m, nil
+		}
+
+		if msg.Type == tea.KeyRunes {
+			m.query += msg.String()
+			m.refilter()
+		}
+	}
+
+	return m, nil
+}
+
+func (m model) View() string {
+	var builder strings.Builder
+	builder.WriteString(fmt.Sprintf("%s > %s\n", m.prompt, m.query))
+
+	if len(m.filtered) == 0 {
+		builder.WriteString("  no matches\n")
+		builder.WriteString("  enter to keep typing, esc to cancel")
+		return builder.String()
+	}
+
+	maxRows := 8
+	if m.height > 6 {
+		maxRows = m.height - 4
+	}
+	if maxRows < 4 {
+		maxRows = 4
+	}
+	if maxRows > len(m.filtered) {
+		maxRows = len(m.filtered)
+	}
+
+	start := 0
+	if m.cursor >= maxRows {
+		start = m.cursor - maxRows + 1
+	}
+
+	end := start + maxRows
+	if end > len(m.filtered) {
+		end = len(m.filtered)
+	}
+
+	for index := start; index < end; index++ {
+		prefix := "  "
+		if index == m.cursor {
+			prefix = "> "
+		}
+		item := m.filtered[index]
+		builder.WriteString(fmt.Sprintf("%s%-10s .%-6s %s\n", prefix, item.ID, item.Extension, item.Name))
+	}
+
+	builder.WriteString("  enter select  esc cancel")
+	return builder.String()
+}
+
+func (m *model) refilter() {
+	query := strings.ToLower(strings.TrimSpace(m.query))
+	scored := make([]scoredOption, 0, len(m.all))
+
+	for _, item := range m.all {
+		score := fuzzyScore(query, item)
+		if score < 0 {
+			continue
+		}
+		scored = append(scored, scoredOption{option: item, score: score})
+	}
+
+	sort.SliceStable(scored, func(i, j int) bool {
+		if scored[i].score == scored[j].score {
+			return scored[i].option.ID < scored[j].option.ID
+		}
+		return scored[i].score > scored[j].score
+	})
+
+	m.filtered = make([]option, 0, len(scored))
+	for _, item := range scored {
+		m.filtered = append(m.filtered, item.option)
+	}
+
+	if m.cursor >= len(m.filtered) {
+		m.cursor = len(m.filtered) - 1
+	}
+	if m.cursor < 0 {
+		m.cursor = 0
+	}
+}
+
+func fuzzyScore(query string, item option) int {
+	if query == "" {
+		return 1
+	}
+
+	candidate := strings.ToLower(item.ID + " " + item.Extension + " " + item.Name)
+	queryRunes := []rune(query)
+	candidateRunes := []rune(candidate)
+
+	score := 0
+	queryIndex := 0
+	streak := 0
+	lastMatch := -2
+
+	for index, value := range candidateRunes {
+		if queryIndex >= len(queryRunes) {
+			break
+		}
+		if value != queryRunes[queryIndex] {
+			continue
+		}
+
+		score += 10
+		if index == lastMatch+1 {
+			streak++
+			score += 4 * streak
+		} else {
+			streak = 1
+		}
+		lastMatch = index
+		queryIndex++
+	}
+
+	if queryIndex != len(queryRunes) {
+		return -1
+	}
+
+	score -= len(candidateRunes) / 6
+	if strings.HasPrefix(strings.ToLower(item.ID), query) {
+		score += 15
+	}
+	return score
+}
+
+func readPayload(path string) (payload, error) {
+	raw, err := os.ReadFile(path)
+	if err != nil {
+		return payload{}, err
+	}
+
+	var data payload
+	if err := json.Unmarshal(raw, &data); err != nil {
+		return payload{}, err
+	}
+
+	if data.Prompt == "" {
+		data.Prompt = "output format"
+	}
+	return data, nil
+}
+
+func main() {
+	optionsPath := flag.String("options", "", "path to JSON options payload")
+	resultPath := flag.String("result", "", "path to output selected id")
+	flag.Parse()
+
+	if *optionsPath == "" || *resultPath == "" {
+		fmt.Fprintln(os.Stderr, "usage: fconvert-picker --options <file> --result <file>")
+		os.Exit(2)
+	}
+
+	data, err := readPayload(*optionsPath)
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+
+	picker := model{
+		prompt: data.Prompt,
+		query:  data.Query,
+		all:    data.Options,
+	}
+	picker.refilter()
+
+	program := tea.NewProgram(picker)
+	result, err := program.Run()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+
+	finalModel, ok := result.(model)
+	if !ok {
+		fmt.Fprintln(os.Stderr, "unexpected picker model type")
+		os.Exit(1)
+	}
+
+	if finalModel.cancelled || finalModel.selected == nil {
+		os.Exit(130)
+	}
+
+	if err := os.WriteFile(*resultPath, []byte(finalModel.selected.ID+"\n"), 0o644); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}